[Question]
  [
Rock-and-roll founding father [Chuck Berry](https://en.wikipedia.org/wiki/Chuck_Berry) sadly passed away today.
Consider the [chorus](https://genius.com/Chuck-berry-johnny-b-goode-lyrics) of his [famous](http://www.rollingstone.com/music/lists/the-500-greatest-songs-of-all-time-20110407/chuck-berry-johnny-b-goode-20110516) song "[Johnny B. Goode](https://youtu.be/ZFo8-JqzSCM)":
```
Go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Johnny B. Goode
```
(There are [other](http://www.azlyrics.com/lyrics/chuckberry/johnnybgoode.html) [ways](http://www.metrolyrics.com/johnny-b-goode-lyrics-chuck-berry.html) it has been punctuated but the above will serve for the purposes of the challenge.) 
# Challenge
Given a nonempty, lowercase string of letters a-z, output the chorus of "Johnny B. Goode" with all the instances of `Go` or `go` replaced with the input string, capitalized in the same way.
A trailing newline may optionally follow. Nothing else in the chorus should change.
> 
> **For example**, if the input is `code` the output must be exactly
> 
> 
> 
> ```
> Code, code
> Code Johnny code, code
> Code Johnny code, code
> Code Johnny code, code
> Code Johnny code, code
> Johnny B. Codeode
> 
> ```
> 
> optionally followed by a newline.
> 
> 
> 
Note that the capitalization of all words matches the original chorus, and (despite lack of rhythm) the `Go` in `Goode` is replaced as well as the individual words `Go` and `go`.
**The shortest code in bytes wins.**
# Test Cases
```
"input"
output
"go"
Go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Johnny B. Goode
"code"
Code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Johnny B. Codeode
"a"
A, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
Johnny B. Aode
"johnny"
Johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny B. Johnnyode
"fantastic"
Fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Johnny B. Fantasticode
```
  
[Answer]
# Go, 123 bytes
*Go Johnny, **Go**!*
[Try it online!](https://play.golang.org/p/k3F-bwqIE_)
```
import."strings"
func(s string)string{t,e:=Title(s),", "+s+"\n";return t+e+Repeat(t+" Johnny "+s+e,4)+"Johnny B. "+t+"ode"}
```
[Answer]
# VIM, ~~54~~ 49 Keystrokes (saved 1 keystroke from [Kritixi Lithos](https://codegolf.stackexchange.com/users/41805/kritixi-lithos))
```
yw~hC<Ctrl-R>", <Ctrl-R>0<Enter>Johnny B. <Ctrl-R>"ode<Esc>}O<Ctrl-R>", Johnny <Ctrl-R>0, <Ctrl-R>0<Esc>3.         
```
---
Start with the word on a line on a file with the cursor at the first character, then this will replace it all with the text
Explanation
1. Copy the word into a register, then change the first letter to be capitalized and save that to a register.
2. Write the first line using the registers to fill in the replacements and last lines
3. Write the second line using the registers to fill in the replacements
4. Repeat the middle line 3 times
[Try it online!](https://tio.run/nexus/v#@19ZXpfhbOOsW2SnpKMApg24vPIz8vIqFZz0IAJK@SmpNqnFyXa1/jCFUBUQ9TB9YDXGev//p@f/1y0DAA "V – TIO Nexus") (Thanks [DJMcMayhem](https://codegolf.stackexchange.com/users/31716/djmcmayhem)!)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 37 bytes
```
™„, ¹J¹Ð™”ÿºÇ ÿ, ÿ”4.D¹™”ºÇ B. ÿode”»
```
[Try it online!](https://tio.run/nexus/05ab1e#@/@oZdGjhnk6Cod2eh3aeXgCmDv38P5Duw63KxzerwPEQL6JnsuhnRApsISTHlA8PyUVxN/9/39aTj4A "05AB1E – TIO Nexus")
**Explanation**
```
™„, ¹J                                # concatenate title-cased input with ", " and input
     ¹Ð™                              # push input, input, title-cased input
        ”ÿºÇ ÿ, ÿ”                    # push the string "ÿ Johnny ÿ, ÿ" with "ÿ" replaced 
                                      # by title-cased input, input, input
                  4.D                 # push 3 copies of that string
                     ¹™               # push title-cased input
                       ”ºÇ B. ÿode”   # push the string "Johnny B. ÿode" with "ÿ" replaced 
                                      # by title-case input
                                   »  # join the strings by newlines
```
[Answer]
# Pure Bash, ~~69~~ 76 bytes
```
M=aaaa;echo -e ${1^}, $1 ${M//a/\\n${1^} Johnny $1, $1}\\nJohnny B. ${1^}ode
```
[Try it online!](https://tio.run/nexus/bash#@@9rmwgE1qnJGfkKuqkKKtWGcbU6CiqGQJavvn6ifkxMHlhMwSs/Iy@vEigDkq0FCkMFnPQgmvJTUv///58MpL7m5esmJyZnpAIA "Bash – TIO Nexus")
[Answer]
## Batch, 207 bytes
```
@set s= %1
@for %%l in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set s=%%s: %%l=%%l%%
@set j="%s% Johnny %1, %1"
@for %%l in ("%s%, %1" %j% %j% %j% %j% "Johnny B. %s%ode")do @echo %%~l
```
[Answer]
# JavaScript, 98
```
s=>[S=s[0].toUpperCase()+s.slice(1),[,,,].fill(` ${s}
${S} Johnny `+s)]+`, ${s}
Johnny B. ${S}ode`
```
Abuses array-to-string serialization to create commas. Builds an array of the form:
```
["Go",
 " go\nGo Johnny go", (repeated...)]
```
And concatenates it to the string of the form `", go\nJohnny B. Goode"`:
```
["Go",
 " go\nGo Johnny go",
 " go\nGo Johnny go",
 " go\nGo Johnny go",
 " go\nGo Johnny go"] + ", go\nJohnny B. Goode"
```
[Answer]
# JavaScript (ES6), ~~104~~ ~~101~~ 99 bytes
```
(i,u=i[0].toUpperCase()+i.slice(1),x=`, ${i}
${u} Johnny `+i)=>u+x+x+x+x+`, ${i}
Johnny B. ${u}ode`
```
Previous version:
```
(i,u=i[0].toUpperCase()+i.slice(1))=>u+`, ${i}
${u} Johnny ${i}`.repeat(4)+`, ${i}
Johnny B. ${u}ode`
```
---
**How it works:**
* It's an anonymous function that takes the input as the parameter `i`
* Defines a variable `u` as the input `i` with the first letter capitalized (Note that this assumes input is nonempty, which is OK)
* Just directly construct the string to be returned from those two variables.
* Repeating the string `"go, \nGo Johnny go"` four times instead of repeating `"Go Johnny go, go"` saves one byte.
---
**Edit 1:** Forgot to golf out the semicolon, haha!! Also miscounted the bytes, it was originally 102, not 104. Thanks [apsillers](https://codegolf.stackexchange.com/users/7796/apsillers).
**Edit 2:** Instead of `.repeat(4)`, by putting that string in a variable `x` and doing `x+x+x+x` allows saving two bytes.
---
### Test snippet
```
let f = (i,u=i[0].toUpperCase()+i.slice(1),x=`, ${i}
${u} Johnny `+i)=>u+x+x+x+x+`, ${i}
Johnny B. ${u}ode`;
```
```
<input id=I type="text" size=70 value="code"><button onclick="console.log(f(I.value))">Run</button>
```
[Answer]
# [V](https://github.com/DJMcMayhem/V), ~~41~~, 38 bytes
```
ÄJé,Ùäwa johnny 5ÄGdwwcWB.W~Aode.Î~
```
[Try it online!](https://tio.run/##K/v//3CL1@GVOodnHl5SnqiQlZ@Rl1epIG16uMU9pbw8OdxJTzq8zjE/JVVP@nBf3f//aYl5JYnFJZnJAA "V – Try It Online")
The perfect challenge for V!
Explanation:
```
ä$                              " Duplicate the input ('go' --> 'gogo', and cursor is on the first 'o')
  a, <esc>                      " Append ', '
                                " Now the buffer holds 'go, go'
          Ù                     " Duplicate this line
           äw                   " Duplicate this word (Buffer: 'gogo, go')
             a Johnny <esc>     " Append ' Johnny ' (Buffer: 'go Johnny go, go')
                           5Ä   " Make 5 copies of this line
G                               " Go to the very last line in the buffer
 dw                             " Delete a word
   w                            " Move forward one word (past 'Johnny')
    cW                          " Change this WORD (including the comma), to
      B.<esc>                   "   'B.'
             W                  " Move forward a WORD
              ~                 " Toggle the case of the character under the cursor
               Aode.<esc>       " Apppend 'ode.'
                         ÎvU    " Capitalize the first letter of each line
```
[Answer]
# Pyth - 52 bytes
```
j", "_ArBQ3V4s[H" Johnny "G", "G;%"Johnny B. %sode"H
```
[Test Suite](http://pyth.herokuapp.com/?code=j%22%2C+%22_ArBQ3V4s%5BH%22+Johnny+%22G%22%2C+%22G%3B%25%22Johnny+B.+%25sode%22H&test_suite=1&test_suite_input=%22go%22%0A%22code%22%0A%22a%22%0A%22fantastic%22&debug=0).
[Answer]
# C, ~~156~~ 151 bytes
```
i,a,b;B(char*s){a=*s++;printf("%c%s, %c%s\n",b=a-32,s,a,s);for(;++i%4;)printf("%c%s Johnny %c%s, %c%s\n",b,s,a,s,a,s);printf("Johnny B. %c%sode",b,s);}
```
[Answer]
## Python 3, 88 bytes
```
lambda x:("{0}, {1}\n"+4*"{0} Johnny {1}, {1}\n"+"Johnny B. {0}ode").format(x.title(),x)
```
A simple format string, with positional arguments.
[Answer]
## [Retina](https://github.com/m-ender/retina), 65 bytes
Byte count assumes ISO 8859-1 encoding.
```
^
$', 
:T01`l`L
:`,
 Johnny$',
:`$
¶$`
(\S+) (\S+ ).+$
$2B. $1ode
```
[Try it online!](https://tio.run/nexus/retina#@x/HpaKuo8BlFWJgmJCT4MNllaDDpeCVn5GXVwmUAHJVuA5tU0ng0ogJ1tZUAJEKmnraKlwqRk56CiqG@Smp//@nZqan5uUCAA "Retina – TIO Nexus")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 41 bytes
```
5“ Johnny “, “¶”ẋj¹Ḋṙ7ỴŒu1¦€Y“B. ”⁸Œt“ode
```
[Try it online!](https://tio.run/nexus/jelly#@2/6qGGOgld@Rl5epQKQqQMiDm171DD34a7urEM7H@7oerhzpvnD3VuOTio1PLTsUdOaSKAKJz2gurmPGnccnVQC5OanpP7//z8LbAoA "Jelly – TIO Nexus")
[Answer]
# Python, 94 bytes
```
lambda s:("|, #\n"+"| Johnny #, #\n"*4+"Johnny B. |ode").replace("|",s.title()).replace("#",s)
```
[Answer]
# C#, ~~219~~ ~~211~~ ~~212~~ ~~146~~ 122 Bytes
Implemented multiple suggestions from comments with additional optimization
This is the Endresult:
```
a=>{string x=(char)(a[0]^32)+a.Remove(0,1),n=a+"\n",c=", ",r=n+x+" Johnny "+a+c;return x+c+r+r+r+r+n+$"Johnny B. {x}ode";}
```
[Try it online!](https://tio.run/nexus/cs-mono#pZFNa8MwDIbv@RXC7GBjE7rtmLmHDnoYG4ztsEPXgXCd1qWVwXZKSshvz/LRcy@RDkLo0Ste1FXR0R6@rzHZc5GZE8YIn1mTQR8xYXIGLt7t4AMd8ZhCT2@2UKEYiYkbYl2ReZnmCqa6hBI0oF42Uw@15uaAQXDcLLZ/z09CYv5lz/5i@UI9CkUaJfslpoxmCpgKmmQtGbz5A9EVmERpimBTFQhqaWS4JckHdmNWOTR163eWFW2RTbbyV0/Rn2z@E1yy744sLznbeybEHUTcXzfDjTkCOGv7ONqdJVEiJYz9g0eV4Ydt1nbdPw "C# (Mono) – TIO Nexus")
Explantation:
```
a=>//Input parameter Explanation assumes "go" was passed
{
string x = (char)(a[0] ^ 32) + a.Remove(0, 1)// Input with first letter Uppercase "go"->"Go"
,
n = a + "\n",                               //"go" followed by newline
c = ", "                                    //Hard to believe: Comma followed by space
,
r = n + x + " Johnny " + a + c             //"go" follwed by newline followed by "Go Johnny go, "
;
return x + c + r + r + r + r + n + $"Johnny B. {x}ode"; };//return in the right order                              //Johnny B. Goode
```
Output for testcases:
```
Go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Johnny B. Goode
Code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Johnny B. Codeode
A, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
Johnny B. Aode
Johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny B. Johnnyode
Fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Johnny B. Fantasticode
```
Edit: Thanks to weston for suggesting using a function
[Answer]
# MATLAB/[Octave](https://www.gnu.org/software/octave/), ~~133~~ 111 bytes
```
@(a)regexprep(['1, 2' 10 repmat(['1 32, 2' 10],1,4) '3B. 1ode'],{'1','2','3'},{[a(1)-32 a(2:end)],a,'Johnny '})
```
It's a start. Can hopefully be reduced further.
Basically it's an anonymous function which takes a string input and then uses regex to create the required output.
```
@(a)                                                    %Anonymous Function
    regexprep(                                          %Regex Replace
        ['1, 2' 10                                      %First line is: Code, code
            repmat(['1 32, 2' 10],1,4)                  %Then four lines of: Code Johnny code, code 
                               '3B. 1ode'],             %Final line: Johnny B. Codeode
         {'1','2','3'},                                 %1,2,3 are our replace strings in the lines above
         {[a(1)-32 a(2:end)],a,'Johnny '}               %We replace with '(I)nput', 'input' and 'Johnny ' respectively.
    )
```
An example:
```
@(a)regexprep(['1, 2' 10 repmat(['1 32, 2' 10],1,4) '3B. 1ode'],{'1','2','3'},{[a(1)-32 a(2:end)],a,'Johnny '});
ans('hi')
ans =
Hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Johnny B. Hiode
```
~~You can *sort of* [Try it online!](https://tio.run/nexus/octave#LcgxCsJAEEbhq0z378AozqyVlVh6hbDFQAZj4SZECyXk7GsEi1e8r52T8xy3eE9zTKmDChlID7Ttw18/oWx/LKJyZEK@7EnHPlBkgUJgWxmrLJ0n5V028mSnqD0XccF1HGr9EFZuXp8Jwx3cvg "Octave – TIO Nexus"). The code doesn't quite work with Octave as all the upper case letters become `${upper($0)}`, whereas in MATLAB this is converted to the actual upper case letter.~~
Given the input is guaranteed to only be `a-z` (lowercase alphabet), I can save 22 bytes by using a simple subtraction of 32 to convert the first letter in the string to capital, rather than using regex with the `upper()` function.
As a result, the code now works with Octave as well, so you can now [Try it online!](https://tio.run/nexus/octave#LcgxCsJAEEbhq0z378AozqyVlVh6hbDFQAZj4SZECyXk7GsEi1e8r52T8xy3eE9zTKmDChlID7Ttw18/oWx/LKJyZEK@7EnHPlBkgUJgWxmrLJ0n5V028mSnqD0XccF1HGr9EFZuXp8Jwx3cvg "Octave – TIO Nexus")
[Answer]
# Ruby, ~~89~~ ~~88~~ ~~86~~ 79 bytes
My first golf submission :
```
->x{"^, *
#{"^ Johnny *, *
"*4}Johnny B. ^ode".gsub(?^,x.capitalize).gsub ?*,x}
```
Thanks a lot to @manatwork for his awesome comment : 7 bytes less!
[Answer]
# [Nova](https://github.com/NovaFoundation/Nova), 105 bytes
```
a(String s)=>"#{s.capitalize()+", #s\n"+"#s.capitalize() Johnny #s, #s\n"*4}Johnny B. #s.capitalize()ode"
```
Because Nova (<http://nova-lang.org>) is extremely early beta (and buggy), there are some obvious handicaps that are in place here keeping it from using even less bytes.
For example, could have saved capitalized function call (which is called 3 times) in a local variable like this:
```
a(String s)=>"#{(let c=s.capitalize())+", #s\n"+"#c Johnny #s, #s\n"*4}Johnny B. #{c}ode"
```
which would have taken the byte count down to **89 bytes**. The reason this doesn't work now can be blamed on the argument evaluation order in the C language, because Nova is compiled to C. (The argument evaluation order will be fixed in a future update)
Even more, I could have introduced a "title" property in the String class (and I will after doing this lol) to reduce the count from the capitalization function call:
```
a(String s)=>"#{(let c=s.title)+", #s\n"+"#c Johnny #s, #s\n"*4}Johnny B. #{c}ode"
```
and that would free up 7 bytes to a new total of **82 bytes**.
Furthermore (and further off), once lambda variable type inference is added, this would be valid:
```
s=>"#{(let c=s.title)+", #s\n"+"#c Johnny #s, #s\n"*4}Johnny B. #{c}ode"
```
The count could be brought down to **72 bytes**.
By the way, this is my first code golf, so I probably have missed even more optimizations that could have been made. And this being a **non-golf centric**, **general purpose** language, I think it's pretty impressive.
The first 105 byte code works in the current Nova Beta v0.3.8 build available on <http://nova-lang.org>
```
class Test {
    static a(String s)=>"#{s.capitalize()+", #s\n"+"#s.capitalize() Johnny #s, #s\n"*4}Johnny B. #s.capitalize()ode"
    public static main(String[] args) {
        Console.log(a("expl"))
    }
}
```
outputs:
```
Expl, expl
Expl Johnny expl, expl
Expl Johnny expl, expl
Expl Johnny expl, expl
Expl Johnny expl, expl
Johnny B. Explode
```
Thank you for listening to my shameless advertisement for the general purpose language Nova (found at <http://nova-lang.org> ...get it now!!)
[Answer]
# Brainfuck, 352 bytes
```
,[>+>+<<-]++++++++[>----<-]>.>>>,[.>,]++++++[>+++++++>+++++>++<<<-]>++.>++.>--<<<<[<]<.>>[.>]>>>.>++++++++[>+++++++++>+++++++<<-]>>[<<++>>-]<<[>>+>+>+>+>+<<<<<<-]>++>->-------->-->-->+++++++++>>++++[<<[<]<<<<<[<]<<.>>>[.>]>>.>>>[.>]<[<]<<.<<<[<]<.>>[.>]>.>.<<<[<]<.>>[.>]>>>.>>[>]>-]<<[<]>[.>]<[<]<<.>>>--------.<<<<++.>.<<<[<]<<.>>>[.>]>>>>>>.>----.+.
```
[Try it online!](https://copy.sh/brainfuck/?c=LFs-Kz4rPDwtXSsrKysrKysrWz4tLS0tPC1dPi4-Pj4sWy4-LF0rKysrKytbPisrKysrKys-KysrKys-Kys8PDwtXT4rKy4-KysuPi0tPDw8PFs8XTwuPj5bLj5dPj4-Lj4rKysrKysrK1s-KysrKysrKysrPisrKysrKys8PC1dPj5bPDwrKz4-LV08PFs-Pis-Kz4rPis-Kzw8PDw8PC1dPisrPi0-LS0tLS0tLS0-LS0-LS0-KysrKysrKysrPj4rKysrWzw8WzxdPDw8PDxbPF08PC4-Pj5bLj5dPj4uPj4-Wy4-XTxbPF08PC48PDxbPF08Lj4-Wy4-XT4uPi48PDxbPF08Lj4-Wy4-XT4-Pi4-Pls-XT4tXTw8WzxdPlsuPl08WzxdPDwuPj4-LS0tLS0tLS0uPDw8PCsrLj4uPDw8WzxdPDwuPj4-Wy4-XT4-Pj4-Pi4-LS0tLS4rLg$$)
1. Get the input.
2. Save special characters for later.
3. Write the first part.
4. Save "Johnny" for later
5. Print "Go Johnny go, go" four times
6. Write The last part
I always like challenges in Brainfuck so it was fun. It can probably be golfed more but golfing Brainfuck is kind of long.
[Answer]
# PHP, 86 Bytes
```
echo strtr("1, 0\n2222Johnny B. 1ode",[$l=$argn,$u=ucfirst($l),"$u Johnny $l, $l\n"]);
```
[Answer]
# Java 8, ~~151~~ ~~147~~ ~~146~~ 130 bytes
```
s->{String x=(char)(s.charAt(0)^32)+s.substring(1),n=s+"\n",r=n+x+" Johnny "+s+", ";return x+", "+r+r+r+r+n+"Johnny B. "+x+"ode";}
```
**Explanation:**
[Try it here.](https://tio.run/##pVDLasMwELz7KxadJOSIPo7GgeYYaC499gGKrCR2nZXRysEh@Ntd2ejYXhoEknZ2ZpnZRl/0ynUWm@p7Mq0mgldd4y0DqDFYf9DGwm4uAd6Cr/EIhqcPiSLiYxYvCjrUBnaAUMJEq/UtcYaSm5P2gpOa35fAH8TX85OQpKjf00LijyLHkiT7QJb7EuUgGWzdCfEKTEY8B1Z4G3qPMCyV9OmgZIm4URGOXVdZVoxTMbvq@n0bXSVzF1dXcI7hkv/3T9AiJbtSsGfl@qC62AotclSGs6NjYgn5K@XvziI2s5X/y/Ud2mbZyR0DDhqDpri1NGPMxukH)
```
s->{                               // Method with String as both parameter and return-type
  String x=                        //  Temp String with: 
           (char)(s.charAt(0)^32)  //   The first letter capitalized
    +s.substring(1),               //   + the rest of the String
         n=s+"\n",                 //  Temp String with input + new-line
         c=", ",                   //  Temp String with ", "
         r=n+x+" Johnny "+s+c;     //  Temp String with "input\nInput Johnny input, "
  return x+c+r+r+r+r+n+"Johnny B. "+x+"ode";
                                   //  Return output by putting together the temp Strings
}                                  // End of method
```
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 64 bytes
```
:@n tc@N('%N, %n
'!'%N Johnny %n, %n
'!4*'Johnny B. 'N'ode'!)sum
```
[Try it online!](https://tio.run/nexus/stacked#U8/Kz8hT/2/lkKdQkuzgp6Gu6qejoJrHpa4IZCl4ASXzKoF8qJiJljpUyElPQd1PPT8lVV1Rs7g0939@acl/AA "stacked – TIO Nexus")
[Answer]
## [C#](http://csharppad.com/gist/aafba32276210e86607fcd502ba14855), ~~159~~ ~~130~~ 128 bytes
---
**Golfed**
```
i=>string.Format("{0},{1}????\n{2} B. {0}ode".Replace("?","\n{0} {2}{1},{1}"),(i[0]+"").ToUpper()+i.Substring(1)," "+i,"Johnny");
```
---
**Ungolfed**
```
i => string.Format( "{0},{1}????\n{2} B. {0}ode"
    .Replace( "?", "\n{0} {2}{1},{1}" ),
    
    ( i[ 0 ] + "" ).ToUpper() + i.Substring( 1 ), // {0}
    " " + i,                                      // {1}
    "Johnny" );                                   // {2}
```
---
**Ungolfed readable**
```
i => string.Format( @"{0},{1}
    ????
    {2} B. {0}ode"
    
    // Replaces the '?' for the string format that contains the 
    // repetition of "___ Johnny ___, ___".
    .Replace( "?", "\n{0} {2}{1},{1}" ),
    // {0} - Converts the first letter to upper,
    //       then joins to the rest of the string minus the first letter
    ( i[ 0 ] + "" ).ToUpper() + i.Substring( 1 ),
    // {1} - The input padded with a space, to save some bytes
    " " + i,
    // {2} - The name used as parameter, to save some bytes
    "Johnny" );
```
---
**Full code**
```
using System;
namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            Func<string, string> func = i =>
                string.Format( "{0},{1}????\n{2} B. {0}ode"
                    .Replace( "?", "\n{0} {2}{1},{1}" ),
                    
                    ( i[ 0 ] + "" ).ToUpper() + i.Substring( 1 ),
                    " " + i,
                    "Johnny" );
            int index = 1;
            // Cycle through the args, skipping the first ( it's the path to the .exe )
            while( index < args.Length ) {
                Console.WriteLine( func( args[index++] ) );
            }
            Console.ReadLine();
        }
    }
}
```
---
[Answer]
# **Javascript - ~~72~~ 106 bytes**
~~**Edit: Oops!! I didn't pay attention to the capitalization rules! It'll be longer after a while**~~
**Edit 2: Should be following the rules now!**
Could probably be golfed more
```
c=>(`G,g
`+`G Johnnyg,g
`.repeat(4)+`Johnny B.Gode`).replace(/g/g,' '+c.toLowerCase()).replace(/G/g,' '+c)
```
Used as:
```
c=>(`G,g
`+`G Johnnyg,g
`.repeat(4)+`Johnny B.Gode`).replace(/g/g,' '+c.toLowerCase()).replace(/G/g,' '+c)
alert(f("Code"));
alert(f("Go"));
```
[Answer]
# Excel VBA, ~~137~~ ~~121~~ ~~112~~ ~~89~~ ~~87~~ 84 Bytes
Anonymous VBE immediate window function that takes input of type `Variant/String` from cell `[A1]` and outputs by printing the the VBE immediate window
```
c=[Proper(A1)]:s=vbCr+c+[" Johnny "&A1&", "&A1]:?c", "[A1]s;s;s;s:?"Johnny B. "c"ode
```
-16 Bytes for converting to Immediate window function
-9 Bytes for using `[PROPER(A1)]`
-23 Bytes for dropping `For ...` loop and abusing the `?` statement
-2 Bytes for replacing `" Johnny "&[A1]&", "&[A1]` with `[" Johnny "&A1&", "&A1]`
-3 Bytes for using `+` over  `&` for String concatenation and leaving the terminal string unclosed
## Example Case
```
[A1]="an"          ''  <- Setting [A1] (may be done manually)
                   '' (Below) Anonymous VBE function
c=[Proper(A1)]:s=vbCr+c+[" Johnny "&A1&", "&A1]:?c", "[A1]s;s;s;s:?"Johnny B. "c"ode"
 An, an            ''  <- output
 An Johnny an, an
 An Johnny an, an
 An Johnny an, an
 An Johnny an, an
 Johnny B. Anode
```
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 50 bytes
```
r:L(eu\+:M',SLN[MS"Johnny ":OL',SLN]4*O"B. "M"ode"
```
[Try it online!](https://tio.run/nexus/cjam#@19k5aORWhqjbeWrrhPs4xftG6zklZ@Rl1epoGTl7wMWizXR8ldy0lNQ8lXKT0lV@v8/LTGvJLG4JDMZAA "CJam – TIO Nexus")
Explanation:
```
r:L(eu\+:M',SLN[MS"Johnny ":OL',SLN]4*O"B. "M"ode" e# Accepts an input token.
r:L                                                e# Gets input token and stores it in L.
   (eu\+:M                                         e# Converts token to uppercase-first and stores it in M.
          ',S                                      e# Appears as ", ".
             L                                     e# Input token.
              N                                    e# Newline.
               [                                   e# Opens array.
                M                                  e# Modified token.
                 S                                 e# Space.
                  "Johnny ":O                      e# Pushes "Johnny " and stores it in O.
                             L                     e# Input token.
                              ',SLN                e# The same {',SLN} as before.
                                   ]4*             e# Closes array and repeats it 4 times.
                                      O            e# "Johnny ".
                                       "B. "       e# "B. ".
                                            M      e# Modified token.
                                             "ode" e# "ode".
```
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 43 bytes
```
l5j", "Qs3
Qld"Johnny "iQs3:D4i"B. ode"+Tj:
```
[Try it online!](https://tio.run/nexus/pyke#@59jmqWko6AUWGzMFZiTouSVn5GXV6mglAkUsHIxyVRy0lPIT0lV0g7Jsvr/PwssCwA "Pyke – TIO Nexus")
Constructs and prints the first line then inserts `Johnny go` before the comma and duplicates that 4 times. Finally constructs the last part.
[Answer]
# Python, 258 bytes
```
from jinja2 import Template
def f(go):
    t = Template("""{{ Go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
Johnny B. {{ Go }}ode""")
    return t.render(Go=go.title(), go=go)
```
[Answer]
# Java 6, ~~258~~ 242 bytes
```
enum j{;public static void main(String[]a){char[]b=a[0].toCharArray();b[0]^=32;System.out.printf("%1$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%3$sB. %1$sode",new String(b),a[0],"Johnny ");}}
```
Longest part of it is the format for printf. There are problems with input different than string from `a` to `z`(yes I know I don't need to support anything else).
Ungolfed with comments:
```
enum j {
    ;
    public static void main(String[] a) {
        char[] b = a[0].toCharArray();              // Copy of the input string
        b[0]^=32;                                   // First character of copy to uppercase
        System.out.printf(
                "%1$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%3$sB. %1$sode", // Format string
                new String(b),  // Capitalized string
                a[0],           // Original input string
                "Johnny ");     // "Johnny "
    }
}
```
EDIT: Golfed 16 bytes thanks to weston
[Answer]
# Mathematica, 83 bytes
```
{a=ToTitleCase@#,b=", ",#,{"
",a," Johnny ",#,b,#}~Table~4,"
Johnny B. ",a}<>"ode"&
```
Anonymous function. Takes a string as input and returns a string as output. Could probably be golfed further.
]