[Question]
  [
Write a program that prints "Hello, World!".
But also, if you take only the first, third, fifth, etc. characters of your program, the resulting program should still print "Hello, World!". 
If your program is:
```
abc
def
```
It should output "Hello, World!", but so should 
```
acdf
```
No solutions with fewer than 2 characters. 
  
[Answer]
# [Python 3](https://docs.python.org/3/), 61 bytes
```
rant="partisn't"
print(("HHeelllloo,,  WWoorrlldd!!"""[::2]))
```
[Try it online!](https://tio.run/##K6gsycjPM/7/vygxr8RWqSCxqCSzOE@9RImroCgzr0RDQ8nDIzU1Bwjy83V0FBTCw/Pzi4pyclJSFBWVlJSirayMYjU1//8HAA "Python 3 – Try It Online")
Abusing the fact that `print` is a function in Python 3 :)
The least partisan solution you'll find here on PPCG.
Becomes
```
rn=print
rn("Hello, World!"[:])
```
[Answer]
## [Cardinal](https://www.esolangs.org/wiki/Cardinal), 29 bytes
```
%
"
H
e
l
l
o
,
 
W
o
r
l
d
!
```
[Try it online!](https://tio.run/##S04sSsnMS8z5/1@VS4nLgyuVKwcI87l0uBS4woF0EZCXwqX4/z8A "Cardinal – Try It Online")
Removing every other character removes all the linefeeds, which still results in `Hello, World!`:
```
%"Hello, World!
```
[Try it online!](https://tio.run/##S04sSsnMS8z5/19VySM1JydfRyE8vygnRfH/fwA "Cardinal – Try It Online")
The reason this works is that `%` creates four instruction pointers, moving in each of the four cardinal directions. IPs that leave the source code are simply removed. So in the first case, only the south-going IP remains and in the second case, only the east-going IP remains, all the others are simply dropped. In either case, the executed program is then just `"Hello, World!`. The `"` toggles to string mode where each cell is simply printed to STDOUT. We don't need to terminate the string, because leaving the source code still terminates the program.
Note that the same idea works in [Beeswax](http://esolangs.org/wiki/Beeswax), using `*` instead of `%` and ``` instead of `"` (this is because Beeswax was largely inspired by Cardinal but uses a hexagonal grid).
[Try it online!](https://tio.run/##S0pNLS5PrPj/X4srgcuDK5UrBwjzuXS4uMKBVBGQk8Kl@P8/AA "Beeswax – Try It Online") (vertical) | | [Try it online!](https://tio.run/##S0pNLS5PrPj/XyvBIzUnJ19HITy/KCdF8f9/AA) (horizontal)
[Answer]
# C, 125 bytes
```
xpxuxtxs( ) { }xuxs ( ) { } main( ) {puts ( "Hello, World!" ) ; } mxaxixn ( ) {xpxuxtxs ( " H e l l o ,   W o r l d ! " ) ; }
```
[Try it online!](https://tio.run/##NUxbCoAgELzK2FeBnaALdIO@RSOETaMUFqKz29qD/ZjHzoztF2tL4Y0zJz5adDhxiTjwcazGh4dvOVW3GWeiqDHFnZxq5DPUFBv2HN7WP1fTGDGD5CI0gElwF@Wg8HVLuQE)
**With even characters removed:**
```
xxxx(){}us(){}mi(){us("el,Wrd");}main(){puts("Hello, World!");}
```
[Try it online!](https://tio.run/##S9ZNT07@/78CCDQ0q2tLi0FkbiaQBDKVUnN0wotSlDSta3MTM/OAggWlJUBhj9ScnHwdhfD8opwURZDs//8A)
[Answer]
# [Actually](https://github.com/Mego/Seriously), 2 bytes
```
HH
```
Explanation:
`H`, as you might expect, pushes `Hello, World!` to the stack.
The main program (`HH`) will encounter the first `H` and push `Hello, World!` to the stack. On the second `H`, however, it will try to use two arguments (as the stack needs to be empty to push `Hello, World!`) and fail. However, this error will be ignored and then `Hello, World!` will be implicitly printed.
The second program (`H`) will push `Hello, World!` once, and that will be impliclty printed.
This is similar to Fatalize's 2-byte answer, but this doesn't really "cheat".
[Try it online!](https://tio.run/##S0wuKU3Myan8/9/D4/9/AA "Actually – Try It Online")
[Answer]
# [Lua](https://www.lua.org), 89 bytes
```
--- [ [
print("Hello, World!")
--[[ ] ]
pCrAiLnCtU(L"AHTeOlRlFoE,L IWNoEr:lDd !:"D)
---]]
```
[Try it online!](https://tio.run/##yylN/P9fV1dXIVohmqugKDOvREPJIzUnJ19HITy/KCdFUUmTS1c3OlohViGWq8C5yDHTJ8@5JFTDR8nRIyTVPycoxy3fVcdHwTPcL9@1yCrHJUVB0UrJBaRJNzb2/38A "Lua – Try It Online") As the syntax highlighting shows, this is massive comment abuse.
Alternate:
```
--[[pit"el,Wrd"
-[]]print("Hello, World!")--]
```
[Try it online!](https://tio.run/##yylN/P9fVzc6uiCzRCk1Rye8KEWJSzc6NragKDOvREPJIzUnJ19HITy/KCdFUUlTVzf2/38A "Lua – Try It Online")
And for convenience, a program to convert a program into every other character form: [Try it online!](https://tio.run/##LcuxCsMgFEDRPV/x4qQQM7Sb0CEkKSlIC6UlgzgUFCK8qqhLvt620PHCuXEvW/DHWt07hlQg77mJyflCrTenb/W5GOf7ZF@GMiXEQbNaOeegQP0lWSxi6GANCU1LWMO5UqBBN3FMg5N@LE8qybA87A3veA5zJ@GyXsOcBE4GWkGm38S1/gA "Python 3 – Try It Online")
[Answer]
# [Retina](https://github.com/m-ender/retina), 39 bytes
```
HHeelllloo,,  WWoorrlldd!!
(.).x?
$1
```
[Try it online!](https://tio.run/##K0otycxL/P@fy8MjNTUHCPLzdXQUFMLD8/OLinJyUlIUFbm4uDT0NPUq7LlUDP//BwA "Retina – Try It Online")
Taking every other character gives:
```
Hello, World!
()x
1
```
[Try it online!](https://tio.run/##K0otycxL/P@fyyM1JydfRyE8vygnRZFLQ7OCy/D/fwA "Retina – Try It Online")
The first program creates a string with the greeting duplicated. Then it replaces each pair of characters with the first character. There is also an empty stage that replaces all empty strings with empty strings in between, but that doesn't do anything. The second program fails to match the letter "x" so it doesn't replace anything after creating the greeting.
Perhaps more amusingly, if the third stage is changed slightly the first set of characters doesn't have to be the same message. This could lead to many identical length solutions such as [full](https://tio.run/##K0otycxL/P@fy88jMzU5Jz8nJ19BR0HBKTw/P6coMac4RVGRi4tLT0NPs8KeS8Xw/38A) and [halved](https://tio.run/##K0otycxL/P@fyyM1JydfRyE8vygnRZFLT6@Cy/D/fwA).
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 25 bytes
```
H→e→l→l→o→,→ →W→o→r→l→d→!
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9/jUdukVCDOgeJ8INYBYgUgDofyi6ByKUCs@P8/AA "Charcoal – Try It Online")
If you remove the even characters, you just remove the arrow commands that indicate the direction of the next text, and that leaves the following code:
```
Hello, World!
```
[Try it online!](https://tio.run/##S85ILErOT8z5/98jNScnX0chPL8oJ0Xx/38A "Charcoal – Try It Online")
That also prints the greeting.
[Answer]
# [Haskell](https://www.haskell.org/), 85 bytes
```
{--}main=putStr"Hello, World!"--} m a i n = p u t S t r " H e l l o ,   W o r l d ! "
```
[Try it online!](https://tio.run/##DYkxCoAwEAS/MqbWJ6S3T5E6YEDxksgZK/Ht8ViWYWf3dJ9ZZIx3Wb6Sjuqvp4eubjXbZmJT2SZnJ4XEQcVz8dAJVsWxkhFLYwaiUW1tTLgxfg "Haskell – Try It Online")
Every second character removed:
```
{-mi=uSrHlo ol!-}main=putStr"Hello, World!"
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/v1o3N9O2NLjIIydfIT9HUbc2NzEzz7agtCS4pEjJA6gkX0chPL8oJ0VR6f9/AA "Haskell – Try It Online")
This exploits the two comment formats in Haskell: `{- -}` for in-line or multi-line comments and `--` to comment the rest of the line.
[Answer]
# Javascript, 67 bytes
```
/**/alert`Hello, World`// * / a l e r t ` H e l l o ,   W o r l d `
```
Every second letter removed:
```
/*aetHlo ol`/*/alert`Hello, World`
```
Just like many other answers, this exploits comments.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes
```
Ḥ~wḤ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@GOJXXlQOL///8A "Brachylog – Try It Online")
### Explanation
`~w` writes its right variable to `STDOUT`, and ignores its left argument. `Ḥ` is `"Hello, World!"`, so this prints `Hello, World!`.
If we only take the first and third chars, we get `Ḥw`. In that case `w` writes its left variable and ignores its right variable, so it also prints `Hello, World!`.
### 2 bytes
```
ḤḤ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@GOJUD0////KAA)
This is technically a valid answer, but this unifies the output variable of the program instead of printing to `STDOUT`, so I guess the 4 bytes program is more in the spirit of the challenge.
[Answer]
# x86 machine code, 162 bytes
[![demo](https://i.stack.imgur.com/JxNEM.png)](https://i.stack.imgur.com/JxNEM.png)
**PROG.COM** [Download](https://www.dropbox.com/s/hiwlgivis06mfjz/PROG.COM?dl=1) and run it in **MS-DOS** emulator, [DOSBox](https://en.wikipedia.org/wiki/DOSBox) for example.
```
90 B3 B4 B4 02 90 90 B3 B2 B2 48 90 90 B3 CD CD 21 90 90 B3 B2 B2 65 90 
90 B3 CD CD 21 90 90 B3 B2 B2 6C 90 90 B3 CD CD 21 90 90 B3 CD CD 21 90 
90 B3 B2 B2 6F 90 90 B3 CD CD 21 90 90 B3 B2 B2 2C 90 90 B3 CD CD 21 90 
90 B3 B2 B2 20 90 90 B3 CD CD 21 90 90 B3 B2 B2 77 90 90 B3 CD CD 21 90 
90 B3 B2 B2 6F 90 90 B3 CD CD 21 90 90 B3 B2 B2 72 90 90 B3 CD CD 21 90 
90 B3 B2 B2 6C 90 90 B3 CD CD 21 90 90 B3 B2 B2 64 90 90 B3 CD CD 21 90 
90 B3 B2 B2 21 90 90 B3 CD CD 21 90 90 B3 CD CD 20 90
```
after removal **MINI.COM** [Download](https://www.dropbox.com/s/c8sgud72fjxkz5i/MINI.COM?dl=1)
```
90 B4 02 90 B2 48 90 CD 21 90 B2 65 90 CD 21 90 B2 6C 90 CD 21 90 CD 21 
90 B2 6F 90 CD 21 90 B2 2C 90 CD 21 90 B2 20 90 CD 21 90 B2 77 90 CD 21 
90 B2 6F 90 CD 21 90 B2 72 90 CD 21 90 B2 6C 90 CD 21 90 B2 64 90 CD 21 
90 B2 21 90 CD 21 90 CD 20
```
## How to run?
Install DOSBox, for Ubuntu/Debian
```
sudo apt install dosbox
```
Run it
```
dosbox
```
**In DOSBOX**
```
mount c /home/user/path/to/your/directory
c:
PROG.COM
MINI.COM
```
## How does it works?
Machine **operation codes** represents **assembly** language **instructions**.
In MS-DOS to **print char** you will set registers and make interrupt. AH register will be 0x02, DL register contains your char. Interrupt vector is 0x21.
```
mov ah,0x2  ;AH register to 0x2 (B4 02)
mov dl,0x48 ;DL register to "H" (B2 48)
int 0x21    ;0x21 interrupt     (CD 21)
```
MS-DOS [COM file](https://en.wikipedia.org/wiki/COM_file) tiny model is good choise, because it **doesn't have any headers**. It is limited by 64K, but in our case it doesn't matters.
To stop program use 0x20 interrupt
```
int 0x20    ;0x20 interrupt     (CD 20)
```
## Magic
If you want to execute **0xAB** opcode command with one parameter **0xCD**, you write
```
AB CD
```
In **PROG.COM**
```
90 B3 AB AB CD 90
nop         ; No operation (90)
mov bl,0xb4 ; BL register to AB (B3 AB)
AB CD command (AB CD)
nop         ; No operation (90)
```
In **MINI.COM**
```
90 AB CD
nop         ; No operation (90)
AB CD command (AB CD)
```
It is **equal** machine codes, if you don't use **BL register**.
## Generator
Convert text file with hex to hex binary
```
cat hex_file | xxd -r -p > exec.com
```
```
function byte2hex(byte){
	var ret=byte.toString(16).toUpperCase();
	return ret.length==1 ? "0"+ret : ret;
}
function str2hex(str){
	var ret = [];
	for(var i=0;i<str.length;i++){
		ret.push(byte2hex(str.charCodeAt(i)));
	}
	return ret;
}
function genCode(hexArr){
	var ret = [["B4","02"]];
	for(var i=0;i<hexArr.length;i++){
		if(hexArr[i]!=hexArr[i-1]){
			ret.push(["B2",hexArr[i]]);
		}
		ret.push(["CD","21"]);
	}
	ret.push(["CD","20"]);
	return ret;
}
function magicCode(str){
	var ret=[""];
	var code=genCode(str2hex(str));
	for(var i=0;i<code.length;i++){
		ret.push("90 B3 "+code[i][0]+" "+code[i][0]+" "+code[i][1]+" 90");
		if(i%4==3){ret.push("\n");}
	}
	return ret.join(" ");
}
function magicCodeMinified(str){
	var ret=[""];
	var code=genCode(str2hex(str));
	for(var i=0;i<code.length;i++){
		ret.push("90 "+code[i][0]+" "+code[i][1]);
		if(i%8==7){ret.push("\n");}
	}
	return ret.join(" ");
}
var str=prompt("string","Hello, world!");
var out="PROG.COM\n" + magicCode(str)+"\n\nMINI.COM\n"+magicCodeMinified(str);
document.write(out.replace("\n","<br>"));
alert(out);
```
[Answer]
# Haskell, 102 bytes
The full program:
```
main= putStr"Hello, World!";;
putSt   x ="p u t S t r  \" H e l l o ,   W o r l d !\"";
mmaaiin = main
```
and with every other character removed:
```
mi=ptt"el,Wrd";ptt x=putStr "Hello, World!";main=mi
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 31 bytes
```
p% 2"HHeelllloo,,  WWoorrlldd!!
```
[Try it online!](https://tio.run/##K6gsyfj/v0BVwUjJwyM1NQcI8vN1dBQUwsPz84uKcnJSUhQV//8HAA "Pyth – Try It Online")
Becomes 
```
p "Hello, World!
```
Thanks to @CalculatorFeline for pointing out an error and removing one byte.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 32 bytes
```
i;H;e;l;l;o;,; ;w;o;r;l;d;!;<esc>;Ó;
```
Note that `<esc>` is a single character, e.g. `0x1b`
[Try it online!](https://tio.run/##K/v/P9PawzrVOgcI8611rBWsy4F0EZCXYq1oLW19eLL1//8A "V – Try It Online")
Removing every other character gives:
```
iHello, world!<esc>Ó
```
[Try it online!](https://tio.run/##K/v/P9MjNScnX0ehPL8oJ0VR@vDk//8B "V – Try It Online")
[Answer]
# PHP, 53 bytes
```
#
echo date(
$e_c_h_o='\H\e\l\l\o\,\ \W\o\r\l\d\!
');
```
With every other character removed:
```
#eh ae
echo'Hello, World!';
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~26~~ 25 bytes
```
““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »
```
[Try it online!](https://tio.run/##y0rNyan8//9RwxwgMn64ozXxyHTro5MP7X64YztQRMFYASimkKhwZLqCtcLRyQqHdv//DwA "Jelly – Try It Online")
After removing every second character, we're left with the following code.
```
“3a;»“3ḅaė;œ»
```
[Try it online!](https://tio.run/##y0rNyan8//9RwxzjROtDu0H0wx2tiUemWx@dfGj3//8A "Jelly – Try It Online")
### How it works
```
““3ḅaė;œ»ḷ“ 3 ḅ a ė ; œ »  Main link.
““3ḅaė;œ»                  Index into Jelly's dictionary to yield
                           ["", "Hello, World!"]. 
          “ 3 ḅ a ė ; œ »  Index into Jelly's dictionary to yield.
                          " FullERebitingBEfluffiest adoptable".
         ḷ                 Take the left result.
```
```
“3a;»“3ḅaė;œ»  Main link.
“3a;»          Index into Jelly's dicrionary to yield " N-".
               Set the argument and the return value to the result.
     “3ḅaė;œ»  Index into Jelly's dicrionary to yield "Hello, World!".
               Set the return value to the result.
```
[Answer]
# [Cubically](https://github.com/aaronryank/cubically) [v2.1](https://github.com/aaronryank/cubically/releases/tag/v2.1), 222 bytes
```
+0503 @@6 :22 //1 +050501 @@6 :55 +0502 @@6@6 :33 //1 +050502 @@6 :55 +03 //1 +04 @@6 :55 //1 +03 @@6 :55 +01 //1 +0504 @@6 :33 //1 +050502 @@6 :55 +01 //1 +050502 @@6 :55 +0502 @@6 :11 //1 +050501 @@6 :55 +01 //1 +03 @@6
```
[Try it online!](https://tio.run/##Sy5NykxOzMmp/P9f28DUwFjBwcFMwcrISEFf31ABJGJqYAgRMzUF841APBDf2BhJjRGSGpi4CVwMwjdGUmMI1wtVhdM0QxzicJ6hIQ63GiLb@/8/AA)
Every other letter:
```
+53@6:2/1+551@6:5+52@66:3/1+552@6:5+3/1+4@6:5/1+3@6:5+1/1+54@6:3/1+552@6:5+1/1+552@6:5+52@6:1/1+551@6:5+1/1+3@6
```
[Try it online!](https://tio.run/##Sy5NykxOzMmp/P9f29TYwczKSN9Q29TUEMgy1TY1cjAzszIGixiBRUBsExALSBuDRQxBsiAhZGWGSGwwZYhkqiFE7///AA)
[Answer]
# [Befunge-93](https://github.com/catseye/Befunge-93), ~~43~~ 41 bytes
Coming back to this a few years later, I found a way to avoid running those unsupported instructions, meaning this can even be run on implementations that treat those differently.
```
"!!ddllrrooWW  ,,oolllleeHH"""> :$# ,#__@
```
[Try it online!](https://tio.run/##S0pNK81LT/3/X0lRMSUlJ6eoKD8/PFxBQUcnPz8HCFJTPTyUlJTsFKxUlBV0lOPjHf7/BwA "Befunge-93 – Try It Online")
Second version
```
"!dlroW ,olleH">:#,_@
```
is the shortest possible "Hello World!". This therefore is the shortest possible answer to this question for Befunge-93.
[Try It Online](https://tio.run/##S0pNK81LT/3/X0kxJacoP1xBJz8nJ9VDyc5KWSfe4f9/AA)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 29 bytes
```
”ïŸŸ™ ,ï‚‚ï ! ”# ¦2 ä ø¨øJð ý
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcPcw@uP7ji641HLIgWdw@sfNcwCosPrFRQVgFLKCoeWGSkcXqJweMehFYd3eB3eoHB47///AA "05AB1E (legacy) – Try It Online")
**Explanation**
```
”ïŸŸ™ ,ï‚‚ï ! ”                # push the string "Weekly Hello , Changed World ! "
               #               # split on spaces
                               # RESULT: ['Weekly','Hello',',','Changed','World','!','']
                ¦              # remove the first element (Weekly)
                 2ä            # split in 2 parts
                               # RESULT: [['Hello', ',', 'Changed'], ['World', '!', '']]
                   ø           # zip
                               # RESULT: [['Hello', 'World'], [',', '!'], ['Changed', '']]
                    ¨          # remove the last element
                     ø         # zip
                               # RESULT: [['Hello', ','], ['World', '!']]
                      J        # join each inner list
                       ðý      # join on space
```
After removing every other character we are left with the code
```
”Ÿ™,‚ï!” 2äøøðý
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcPcozsetSzSedQw6/B6RSBXwejwksM7gHDD4b3//wMA "05AB1E – Try It Online")
**Explanation**
```
”Ÿ™,‚ï!”       # push the string "Hello, World!"
        2ä     # split in 2 parts
               # RESULT: ['Hello, ', 'World!']
          ø    # zip, as the string has an odd length the space is lost
               # RESULT: ['HW', 'eo', 'lr', 'll', 'od', ',!']
           ø   # zip again
               # RESULT: ['Hello,', 'World!']
            ðý # join on space
```
[Answer]
# [///](https://esolangs.org/wiki////), 25 bytes
```
H\e\l\l\o\,\ \W\o\r\l\d\!
```
[Try it online!](https://tio.run/##K85JLM5ILf7/3yMmNSYHCPNjdGIUYsKBdBGQlxKj@P8/AA "/// – Try It Online")
With every other character removed:
```
Hello, World!
```
[Answer]
# Octave, ~~49~~ 45 bytes
Saved 4 bytes since Octave doesn't require brackets to do indexing.
```
'HHeelllloo,,  WWoorrlldd!! ' (1:2 : 3 ^ 3)''
```
[Try it online!](https://tio.run/##y08uSSxL/f9f3cMjNTUHCPLzdXQUFMLD8/OLinJyUlIUFRXUFTQMrYwUrBSMFeIUjDXV1f//BwA "Octave – Try It Online")
And the reduced one:
```
'Hello, World!'(:    )'
```
[Try it online!](https://tio.run/##y08uSSxL/f8/Wt0jNScnX0chPL8oJ0VRPVbDSgEINNX//wcA)
## Explanation:
The initial code has the letters in the string duplicated, so that we're left with `Hello, World!` when every second is removed. Some spaces are added to ensure the brackets and apostrophes are kept.
The indexing is really `1:2:end`. There are 27 characters, and we can't use `end` or `27` since we must remove a character, so we go with `3 ^ 3` instead. When we remove every third character, the indexing becomes `(:)` (and some additional spaces).
`(:)` means *"flatten and turn into a vertical vector"*. So, we need to transpose it, using `'`. We don't need to transpose the string in the original code, but double transposing works, so the first string is transposed twice using `''`, and the second is transposed just once.
[Answer]
# Mathematica, 62 bytes
```
P0r0i0n0t0@0"0H0e0l0l0o0,0 0W0o0r0l0d0!0"Print@"Hello, World!"
```
It returns `"0H0e0l0l0o0,0 0W0o0r0l0d0!0" Null P0r0i0n0t0[0]`, and prints `Hello, World!` as a side effect. When run as a program (not in the REPL), the return value will not be printed.
After removing every other character:
```
Print@"Hello, World!"rn@Hlo ol!
```
It returns `Null ol! rn[Hlo]`, and prints `Hello, World!`.
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 32 bytes
```
"HHeelllloo,,  WWoorrlldd!! "2 %
```
[Try it online!](https://tio.run/##S85KzP3/X8nDIzU1Bwjy83V0FBTCw/Pzi4pyclJSFBUVlIwUVP//BwA "CJam – Try It Online")
Taking every other character gives:
```
"Hello, World!" 
```
[Try it online!](https://tio.run/##S85KzP3/X8kjNScnX0chPL8oJ0VRSeH/fwA)
[Answer]
# [Help, WarDoq!](http://esolangs.org/wiki/Help,_WarDoq!), 2 bytes
```
Hi
```
[Try it online!](http://cjam.aditsu.net/#code=l%3AQ%7B%22HhEeLlOoWwRrDd%2C!AaPpQq%22Q%7C%5B%22Hh%22%22ello%22a%5B'%2CL%5DSa%22Ww%22%22orld%22a%5B'!L%5D%5D%3Am*%3A%60%5B%7Briri%2B%7D%7Briri%5E%7D%7Brimp%7D%7Brizmp%7DQ%60Q%7B%5C%2B%7D*%60L%5D%2Ber%3A~N*%7D%3AH~&input=Hi)
`H` prints `Hello, World!`, `i` is a no-op.
Help, WarDoq! can add two numbers and test for primes, so it is considered as a valid programming language per [this meta post](https://codegolf.meta.stackexchange.com/questions/2028/what-are-programming-languages/2073#2073).
[Answer]
## [><>](https://esolangs.org/wiki/Fish), 47 bytes
Original:
```
| v~" H e l l o ,   W o r l d ! "
~o<< ;!!!? l
```
With every second character removed:
```
|v"Hello, World!"
o<;!?l
```
Try them online: [original](https://tio.run/##S8sszvj/v0ahrE5JwUMhVSEHCPMVdBQUFMKBdBGQl6KgqKDExVWXb2OjYK2oqGivkPP/PwA), [modified](https://tio.run/##S8sszvj/v6ZMySM1JydfRyE8vygnRVGJK9/GWtE@5/9/AA)
The original program pushes the characters of "Hello, World!" to the stack (in reverse order) interspersed with spaces, then alternately prints a character and deletes one until the length of the stack is zero. The second program does the same, except the deletion instructions `~` are gone.
If you don't mind halting with an error, we can take a leaf out of Martin Ender's [Cardinal](https://codegolf.stackexchange.com/a/128498/66104) book: the modified code is
```
\"!dlroW ,olleH"!#o#
```
and the original is the same but with newlines inserted between all the characters, for 39 bytes. Try them online: [original](https://tio.run/##S8sszvj/P4ZLiUuRK4Urh6uIK58rnEuBSwdI5wBhKpcHWE4ZyFf@/x8A), [modified](https://tio.run/##S8sszvj/P0ZJMSWnKD9cQSc/JyfVQ0lROV/5/38A).
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), ~~35~~ 34 bytes
-1 thanks to Martin Ender.
```
'0H0e0l0l0o0,0 0W0o0r0l0d0!0'~ ⍕ 0
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPdMSfnv7qBh0GqQQ4Q5hvoGCgYhAPpIiAvxUDRQF2hTuFR71QFA5BiLiD2T0nhUvdIzcnJ11EIzy/KSVFUr1PXUwdJ/QcaxgWUBwA "APL (Dyalog Unicode) – Try It Online")
`'0H0e0l0l0o0,0 0W0o0r0l0d0!0'` the message with zeros as removable filler characters
`~` except
`⍕` formatted (stringified)
`0` number zero
Leaving just the odd characters, this becomes
`'Hello, World!'` .
[Answer]
# [,,,](https://github.com/totallyhuman/commata), 34 [bytes](https://github.com/totallyhuman/commata/wiki/Code-page)
```
 2"Hteoltlaol,l yWhourmladn!! "⟛
```
On removing the even numbered characters...
```
 "Hello, World!"
```
## Explanation
With all the characters:
```
 2"..."⟛
               no-op
 2             push 2 to the stack
  "..."        push "Hteoltlaol,l yWhourmladn!! " to the stack
       ⟛      pop 2 and the string and push every 2nd character of the string
               implicit output
```
Without the even numbered characters:
```
 "..."
               no-op
 "..."         push "Hello, World!" to the stack
               implicit output
```
[Answer]
# JavaScript, 138 bytes
A lot of people used comments and I found it too easy so here's one entry **without comments**:
```
c_n_o_e_l_g ="c o n s o l e . l o g"; console.log ( "_H_e_l_l_o_,_ _W_o_r_l_d_!".replaceAll( "_","") ) ;[ ' s l i c e ' ]+( 0 , - 9 )+ ")"
```
Taking every other character out:
```
cnoelg=console.log;cnoelg("Hello, World!.elcAl _,"  ['slice'](0,-9) )
```
## Important
This code uses [`String.prototype.replaceAll()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll), which is a fairly recent feature, and thus wont work in older browsers/NodeJS versions (**NodeJS v15.0.0 and above** is required, for example).
## Explanation
1. First it create an alias of `console.log` named `c_n_o_e_l_g` which returns the same as `console.log` when every other character is removed.
2. Then `console.log` is called (being replaced with `cnoelg` when converted).
3. Inside `console.log` there's `"_H_e_l_l_o_,_ _W_o_r_l_d_!"` in which every underscore (`_`) is removed, but not in the converted version (they will be removed anyway because in even position); because of the clever placement of the last double quote (`"`), the string will look like `"Hello, World!.elcAl _,"`.
4. Since `"Hello, World!.elcAl _,"` needs to be cleaned up, a `slice()` is applied with the brackets notations (`[]`), removing the last 9 characters (`".elcAl _,"`).
5. But we don't want any modification to happen to the not converted version, so a `)` closes the `console.log` being removed when converted alongside a `;` (since in even position). Then it will apply correctly to the converted version but nothing will happen to the not converted one, since it's a value not assigned to anything.
6. This consist of `[ ' s l i c e ' ]`, `( 0 , - 9 )` and `")"`, concatenated with a `+` sign (removed during conversion), so that the script stays valid. The last `")"` is there to close the `console.log` in the converted version.
[Answer]
# Brainfuck, 155 bytes
```
- - < - < < + [ + [ < + > - - - > - > - > - < < < ] > ] < < - - . < + + + + + + . < < - . . < < . < + . > > . > > . < < < . + + + . > > . > > - . < < < + .
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v9fV0FXwQaMbRS0FaLBGMSyU9AFQzskbAOGsUB2LJgFktcDq0ZAPaiMHpQFkdcD6rGDkzZQGZgOhJwuXBYo/v8/AA)
Every second character removed:
```
--<-<<+[+[<+>--->->->-<<<]>]<<--.<++++++.<<-..<<.<+.>>.>>.<<<.+++.>>.>>-.<<<+.
```
[Answer]
# T-SQL, 75 bytes
```
---
PRINT 'Hello, World!'
/*
-P-R-I-N-T-'-H-e-l-l-o-,- -W-o-r-l-d-!-'
---*/
```
Single- and multi-line comment abuse, [inspired by CalculatorFeline's LUA version](https://codegolf.stackexchange.com/a/128511/70172).
After removal of all even-numbered characters, some of which are line breaks:
```
--PIT'el,Wrd'/
PRINT'Hello, World!'--/
```
]