[Question]
  [
## Challenge:
In the programming language of your choice, take no input and output your programming language's name.
Fair enough, right?
**Restrictions:**
* You can't use any character that is included in your programming language's name in your code. E.g., if I use Batch, I must not use the chars 'B' 'a' t' 'c' 'h' in my code. Note that this is case sensitive. I can still use the char 'b' because it's different from 'B'.
* You can have "junk output" before or after the name of the language
* Version number doesn't count as part of the name of the language. E.g., I can use the number 3 in the code in my answer if it's in Python 3
* The output of the programming language name is not case sensitive.
* Brute-forcing all possible letter combinations and hoping you get your language name is forbidden.
---
**Example outputs:** (let's say my programming language is called Language) (✔ if valid, else ✖)
* `Language` ✔
* `Body language is a type of non-verbal communication in which physical behavior, as opposed to words, is used to express or convey information. Such behavior includes facial expressions, body posture, gestures, eye movement, touch and the use of space.` ✔
* `Language 2.0 - © 1078 AD some company` ✔
* `foobar` ✖
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") thus shortest code wins.
  
[Answer]
## Outputs to STDERR
[Outputting to STDERR](https://codegolf.meta.stackexchange.com/a/2451/20260) is now at +33/-21 as an allowed default, which is positive but contested. This is a [CW answer to collect answers](https://codegolf.meta.stackexchange.com/q/11211/20260) that just invoke an error in a language where error messages includes the language name.
### [Haskell, 1 byte](https://tio.run/nexus/haskell#@2/4/z8A)
```
1
```
Error:
```
Parse error: naked expression at top level
Perhaps you intended to use TemplateHaskell
```
### [Lua, 1 byte](https://tio.run/nexus/lua#@2/4/z8A)
```
1
```
Error:
```
lua: .code.tio:1: syntax error near <eof>
```
(file name is unimportant)
### Batch, 1 byte
```
~
```
Error:
```
'~' is not recognized as an internal or external command,
operable program or batch file.
```
### [tinylisp, 5 bytes](https://tio.run/##K8nMq8zJLC74/18jWUPT8P9/AA)
```
(c()1
```
Error:
```
Error: cannot cons to Int in tinylisp
```
### R, 1 byte
```
)
```
Error:
```
Error: unexpected ')' in ")"
```
### Java bytecode, 0 bytes
Error:
```
Exception in thread "main" java.lang.ClassFormatError: Truncated class file
```
### Groovy, 1 byte
```
a
```
Note that `a` can be replaced with any other character
Error:
```
groovy.lang.MissingPropertyException: No such property: a ...
```
### MATLAB, 1 byte
```
\
```
Error:
```
Error: Unexpected MATLAB operator.
```
### [PHP, 3 bytes](https://tio.run/nexus/php#@29jb/v/PwA)
```
<?=
```
Error:
```
PHP Parse error:  syntax error, unexpected end of file in /home/runner/.code.tio on line 1
```
### CJam, 1 byte
```
/
```
Error:
```
/
^
RuntimeException: The stack is empty
Java exception:
java.lang.RuntimeException: The stack is empty
    at net.aditsu.cjam.CJam.pop(CJam.java:75)
    at net.aditsu.cjam.Op2.run(Op2.java:10)
    at net.aditsu.cjam.Block.run(Block.java:304)
    at net.aditsu.cjam.CJam.runCode(CJam.java:210)
    at net.aditsu.cjam.CJam.main(CJam.java:240)
```
### [Twig, 2 bytes](https://twigfiddle.com/h1bvzf)
Twig is a template language written in PHP. It's possible that this is a polyglot.
```
{{
{%
{#
```
Error:
```
PHP Fatal error:  Uncaught exception 'Twig_Error_Syntax' with message [...] in [...][...]:n:
Stack trace:
#0 [...]
```
The message varies depending on which program you choose.
### [S.I.L.O.S](https://github.com/rjhunjhunwala/S.I.L.O.S), 2 bytes
```
x+
```
[Try it online!](https://tio.run/nexus/silos#@1@h/f8/AA "S.I.L.O.S – TIO Nexus")
Trivially invokes undocumented behavior. Silos is the name of the language.
### Python, 6 bytes
```
pYTHON
```
As the character restriction is case insensitive, and the output doesn't have to be in the correct case, this is a valid answer. The error message it produces is something like this:
```
Traceback (most recent call last):
  File ".code.tio", line 1, in <module>
    pYTHON
NameError: name 'pYTHON' is not defined
```
[**Try it online!**](https://tio.run/nexus/python3#@18QGeLh7/f/PwA) (outputs to 'debug' tab)
### JavaScript, 10 bytes
```
jAVAsCRIPT
```
This produces the following error message or similar in all environments:
```
ReferenceError: jAVAsCRIPT is not defined
```
### [QBIC](https://codegolf.stackexchange.com/a/108030/44874), 6 bytes
```
?b(12)
```
In 6 bytes, we can put QBIC encountered error: 9 on the screen, signifying an out-of-bounds error.
### ForceLang, 2 bytes
```
()
```
Error produced:
```
Exception in thread "main" lang.exceptions.IllegalInvocationException: null is not a function.
    at lang.ForceLang.parse(ForceLang.java:99)
    at lang.ForceLang.main(ForceLang.java:129)
```
### [Pip, 5 bytes](https://tio.run/##K8gs@P/fsC4hOuH/fwA)
```
1~`[`
```
(Note: this works in the current version as of this writing, [0.17.09.01](https://github.com/dloscutoff/pip/commit/6723e170f5baab521af5a7114ac401dd7b639582). No guarantees the interpreter won't change to handle this error differently in the future.)
Tries to regex match with a syntactically invalid pattern. The error produced will look something like this:
```
Traceback (most recent call last):
  File "/opt/pip/pip.py", line 221, in <module>
    pip(interactive=False)
  File "/opt/pip/pip.py", line 206, in pip
    state.executeProgram(tree, args)
  File "/opt/pip/execution.py", line 56, in executeProgram
    returnVal = self.functionCall(mainFunction, cmdLineArgs)
  File "/opt/pip/execution.py", line 368, in functionCall
    returnVal = self.getRval(returnExpr)
  File "/opt/pip/execution.py", line 235, in getRval
    expr = self.evaluate(expr)
  File "/opt/pip/execution.py", line 213, in evaluate
    result = opFunction(*args)
  File "/opt/pip/execution.py", line 1134, in FIRSTMATCH
    matchObj = regex.asRegex().search(str(string))
  File "/opt/pip/ptypes.py", line 175, in asRegex
    self._compiled = re.compile(pyRegex)
  File "/usr/lib64/python3.6/re.py", line 233, in compile
    return _compile(pattern, flags)
  File "/usr/lib64/python3.6/re.py", line 301, in _compile
    p = sre_compile.compile(pattern, flags)
  File "/usr/lib64/python3.6/sre_compile.py", line 562, in compile
    p = sre_parse.parse(p, flags)
  File "/usr/lib64/python3.6/sre_parse.py", line 855, in parse
    p = _parse_sub(source, pattern, flags & SRE_FLAG_VERBOSE, 0)
  File "/usr/lib64/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/usr/lib64/python3.6/sre_parse.py", line 765, in _parse
    p = _parse_sub(source, state, sub_verbose, nested + 1)
  File "/usr/lib64/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/usr/lib64/python3.6/sre_parse.py", line 523, in _parse
    source.tell() - here)
sre_constants.error: unterminated character set at position 8
```
### [Stax, 2 bytes](https://staxlang.xyz/#c=0u&i=&a=1)
```
0u
```
Error:
```
Stax runtime error: rational divide by zero
```
`zh` also works.
### [ink, 1 byte](http://tio.run/##y8zL/v@/7v9/AA)
```
~
```
`~` at the start of a line marks that the line is a statement to be executed, rather than text to be printed. As of whichever version of inklecate TIO is using, if there's nothing after the `~`, the interpreter crashes with the following error:
```
System.NullReferenceException: Object reference not set to an instance of an object
  at Ink.InkParser.LogicLine () [0x000b1] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.OneOf (Ink.StringParser+ParseRule[] array) [0x0000a] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementAtLevel (Ink.InkParser+StatementLevel level) [0x00009] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser+<>c__DisplayClass134_0.<StatementsAtLevel>b__0 () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.Interleave[T] (Ink.StringParser+ParseRule ruleA, Ink.StringParser+ParseRule ruleB, Ink.StringParser+ParseRule untilTerminator, System.Boolean flatten) [0x00040] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementsAtLevel (Ink.InkParser+StatementLevel level) [0x0004f] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.Parse () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.Compiler.Compile () [0x00033] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.CommandLineTool..ctor (System.String[] args) [0x001a3] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
  at Ink.CommandLineTool.Main (System.String[] args) [0x00000] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
[ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object
  at Ink.InkParser.LogicLine () [0x000b1] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.OneOf (Ink.StringParser+ParseRule[] array) [0x0000a] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementAtLevel (Ink.InkParser+StatementLevel level) [0x00009] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser+<>c__DisplayClass134_0.<StatementsAtLevel>b__0 () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.Interleave[T] (Ink.StringParser+ParseRule ruleA, Ink.StringParser+ParseRule ruleB, Ink.StringParser+ParseRule untilTerminator, System.Boolean flatten) [0x00040] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementsAtLevel (Ink.InkParser+StatementLevel level) [0x0004f] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.Parse () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.Compiler.Compile () [0x00033] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.CommandLineTool..ctor (System.String[] args) [0x001a3] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
  at Ink.CommandLineTool.Main (System.String[] args) [0x00000] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
```
### [Rust, 0 bytes](https://tio.run/##KyotLvkPBAA)
```
```
Error:
```
error[E0601]: `main` function not found in crate `code`
  |
  = note: consider adding a `main` function to `code.tio`
error: aborting due to previous error
For more information about this error, try `rustc --explain E0601`.
```
### [sed, 1 byte](https://ato.pxeger.com/run?1=m724ODVlwYKlpSVpuhYLHSE0lAsTBgA)
```
A
```
Error:
```
sed: file /ATO/code line 1: unknown command: `A'
```
### [flat assembler, 0 byte](https://tio.run/##SywuTs1NyqnUTUsszv0PBAA)
Error:
```
flat assembler  version 1.73.16  (16384 kilobytes memory, x64)
1 passes, 0 bytes.
```
### GolfScript, 1 byte
```
\
```
Error:
```
/opt/golfscript/golfscript.rb:118:in `block in to_gs': undefined method `to_gs' for nil:NilClass (NoMethodError)
    from /opt/golfscript/golfscript.rb:118:in `each'
    from /opt/golfscript/golfscript.rb:118:in `inject'
    from /opt/golfscript/golfscript.rb:118:in `to_gs'
    from (eval):1:in `block in initialize'
    from /opt/golfscript/golfscript.rb:306:in `go'
    from (eval):1:in `block in initialize'
    from /opt/golfscript/golfscript.rb:306:in `go'
    from (eval):1:in `block in initialize'
    from /opt/golfscript/golfscript.rb:306:in `go'
    from /opt/golfscript/golfscript.rb:500:in `<main>'
```
### [Thunno, 0 bytes](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhZoFJQGAA)
```
```
Error (for Thunno v1.2.1):
```
Thunno, v1.2.1
```
### [Vyxal, 2 bytes](https://ato.pxeger.com/run?1=m720rLIiMWfBgqWlJWm6FovP7a5YUpyUXAzlw8QB)
```
λx
```
Error:
```
Traceback (most recent call last):
  File "/usr/local/bin/vyxal", line 8, in <module>
    sys.exit(cli())
  File "/usr/local/lib/python3.10/site-packages/vyxal/main.py", line 470, in cli
    execute_vyxal(file_name, flags, inputs)
  File "/usr/local/lib/python3.10/site-packages/vyxal/main.py", line 430, in execute_vyxal
    vy_print(output, ctx=ctx)
  File "/usr/local/lib/python3.10/site-packages/vyxal/elements.py", line 7253, in vy_print
    res = safe_apply(lhs, *args, ctx=ctx, arity_override=override)
  File "/usr/local/lib/python3.10/site-packages/vyxal/helpers.py", line 983, in safe_apply
    ret = function(
  File "<string>", line 10, in _lambda_36f6fb46b5889e1e4e91c1f138c09b37
  File "<string>", line 10, in _lambda_36f6fb46b5889e1e4e91c1f138c09b37
  File "<string>", line 10, in _lambda_36f6fb46b5889e1e4e91c1f138c09b37
  [Previous line repeated 982 more times]
  File "<string>", line 8, in _lambda_36f6fb46b5889e1e4e91c1f138c09b37
  File "/usr/local/lib/python3.10/site-packages/vyxal/LazyList.py", line 184, in __len__
    next(self)
  File "/usr/local/lib/python3.10/site-packages/vyxal/LazyList.py", line 198, in __next__
    item = vyxalify(next(self.raw_object))
  File "/usr/local/lib/python3.10/site-packages/vyxal/helpers.py", line 1488, in vyxalify
    return sympy.nsimplify(value, rational=True)
  File "/usr/local/lib/python3.10/site-packages/sympy/simplify/simplify.py", line 1436, in nsimplify
    return sympify(as_int(expr))
  File "/usr/local/lib/python3.10/site-packages/sympy/core/sympify.py", line 383, in sympify
    return conv(a)
  File "/usr/local/lib/python3.10/site-packages/sympy/core/cache.py", line 72, in wrapper
    retval = cfunc(*args, **kwargs)
RecursionError: maximum recursion depth exceeded in comparison
```
[Answer]
# SmileBASIC, 11 bytes
```
sPsET.,1474
```
Equivalent to `SPSET 0,1474`. Sets sprite 0 to definition 1474, which is the SmileBASIC logo.
[![Screenshot](https://i.stack.imgur.com/z67zA.jpg)](https://i.stack.imgur.com/z67zA.jpg)
[Answer]
# R, 1 byte:
```
T
```
`T` is an alias for the constant `TRUE`. So the output for the above is:
```
[1] TRUE
```
Since junk is allowed around the name, the “R” in there is the language name.
([As noted in a comment elsewhere](https://codegolf.stackexchange.com/questions/107964/output-programming-language-name?page=2&tab=oldest#comment262884_108035), pretty much any single letter and many glyphs will work equally well because they trigger the message “Error: …”, which contains “r”.)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 1 byte
```
Y
```
Output is through STDERR, which is [allowed by default](http://meta.codegolf.stackexchange.com/a/2451/36398).
The output from the offline compiler is
```
Error using matl_parse (line 339)
MATL error while parsing: Y not recognized at position 1
Error in matl (line 234)
    S = matl_parse(s, useTags); 
```
Or [try it online!](https://tio.run/nexus/matl#@x/5/z8A "MATL – TIO Nexus") (expand "debug" section).
[Answer]
# HTML, ~~24~~ 20 bytes
```
&#72;&#84;&#77;&#76;
```
---
# HTML, 16 bytes
[As pointed out by @Bob](https://codegolf.stackexchange.com/questions/107964/output-programming-language-name/107990?noredirect=1#comment262780_107990), modern browsers will recognize HTML entities without semicolons, though it's technically invalid HTML. Of course, it's perfectly valid for code golf.
```
&#72&#84&#77&#76
```
---
# HTML, 4 bytes
And of course, the uninteresting answer.
```
html
```
---
Also, see my [CSS answer](https://codegolf.stackexchange.com/a/108001/47097).
[Answer]
# Vim, 0 bytes
When you start Vim, the editor displays a splash screen which looks like this:
[![Vim splash screen](https://i.stack.imgur.com/j9wr6.png)](https://i.stack.imgur.com/j9wr6.png)
You can see it says `Vim` here:
[![Vim splash screen with vim highlighted](https://i.stack.imgur.com/Cax5C.png)](https://i.stack.imgur.com/Cax5C.png)
Previous answer:
# Vim, 1 byte
```
<Ctrl-C>
```
In Vim 8, pressing will display `Type :quit<Enter> to exit Vim` at the last line. I'm not completely sure if this counts.
[Answer]
# Python, 15 bytes
## Python 2 (15)
```
exec"\150elp()"
```
It concatenates the strings uses the octal `150` which is `h` and `"elp()"` and runs the result. This prints the `help()` command which says `"Welcome to Python 3.5's help utility!"`, meeting the requirements.
## Python 3 (17)
```
exec("\150elp()")
```
[Try it online!](https://tio.run/nexus/python2#@6@sEFBZkpGfp2DMpayQWpGarKEUY2hqkJpToKGppMnFBZc34uICSSPJ/v8PAA)
[Answer]
# C, 0 bytes.
```
/usr/lib/gcc/i586-linux-gnu/5/../../../i386-linux-gnu/crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: error: ld returned 1 exit status
```
[Try it online!](http://ideone.com/oYZvTj)
[Answer]
# Huh?, 0 bytes
(no, there's nothing in that code block)
[The language](https://esolangs.org/wiki/Huh%3F) is named for its output, so...
In [the implementation I checked](https://github.com/kade-robertson/pythuhn/blob/master/pythuhn.py), the interpreter takes the length mod 8 of each line of a given file, and switches depending on the result. For zero, it prints `Huh?`. Since it strips trailing newlines, you could also do a 1 byte (`\n`) version.
Note that it's not outputting to stderr or caseswapping or any other trickery. It's just that Huh?'s very confused interpreter finally came in handy.
[Answer]
## C, ~~15~~ ~~14~~ 5 Bytes
Compiled C on a Linux machine with a German locale:
`main;`
It will try to call the variable `main` which is not allowed because `main` is stored in the bss section which has the NX bit set, therefore generates a SIGSEGV and prints `Speicherzugriffsfehler` (german for Segmentation fault) on stderr.
Stolen from <https://stackoverflow.com/a/1770717/6082851>
---
**Old answer with 14 Bytes**
Compiled C on a Linux machine with the C locale on AMD64, compiled with gcc:
`main(a){a/=0;}`
This will create a division by zero exception and print `Floating point exception` on stderr. Not sure about other implementation, architectures or compilers since it uses UB.
---
**Old answer with 15 Bytes**
Compiled C on a Linux machine with a German locale:
`main(){main();}`
It will run to a stack overflow and print `Speicherzugriffsfehler` (german for Segmentation fault) on stderr.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 2 bytes
```
¬U
```
[Try it online!](https://tio.run/nexus/v#@39oTej//wA "V – TIO Nexus")
The obvious answer is:
```
év~
```
[Try it online!](https://tio.run/nexus/v#@394ZVnd//8A "V – TIO Nexus")
Which is "Insert the letter 'v', and toggle case". However, since you allow for junk output before/after the language name, this works too.
The `¬` command takes two characters for input, and inserts every ASCII character between them. If we don't supply the second character, it automatically defaults to `ÿ` (ASCII 0xff), so this program inserts every character in the latin1 encoding between `U` and `ÿ`.
[Answer]
## [brainfuck](https://esolangs.org/wiki/Brainfuck), 54 bytes
```
+[[-<]-[->]<-]<.<<<<.>>>>-.<<-.<.>>.<<<+++.>>>---.<++.
```
Outputs `brainfuck`, assuming an 8-bit tape open on the left. [Try it online!](https://tio.run/nexus/brainfuck#FYiBCQAwCMMOKtkFxUfE/89wNRAIWXXjoakx4@fwKpCM6XuS7kJWcvcD "brainfuck – TIO Nexus")
As always, partial credits go to [@primo's Hello, World! answer](https://codegolf.stackexchange.com/a/68494/21487).
### Alternatives with different casing
**Brainfuck** (62 bytes):
```
+[<-[-<]-[->]<<]<---.<<<<<<--.>>>-.<+.<.>---.<<+++.>>---.<---.
```
**BrainFuck** (68 bytes):
```
-[[-<]->+[->]<-]<<.<<<<<--.>>+.<-.+++++.>>>------.<<<<+++.>>++.<---.
```
[Answer]
# [Poetic](https://mcaweb.matc.edu/winslojr/vicom128/final/index.html), 229 bytes
```
why?w-h-y?always a war,many flaws,a sham,a fraud,a sad day
luxury a la shahs,a day a la Buddha?ah,many days usually always a burn
a husband hungry?uh-huh
awful suburbs,always a handful
sadly,a man runs harshly away
hardly unusual
```
[Try it online!](https://mcaweb.matc.edu/winslojr/vicom128/final/tio/index.html?NY7BDcQwCAT/roICkhosXSdroRwP4ocR8lF9DifKCy077DIl6txljwqdCCPQxNhO9KBDMW0DmeDMcQw4LwkmRhT1n4/IA70RWWjun8XHmQUV8kTxinZzqCbwNjUfvYDEraFzzv4dUV12cSmYhyuZJ9Qy@r2RJNMo@YVGNmY8De@WxjBZ6QmWFGmT97vzuhr4Dw)
Prints `Poetic`.
This was an interesting challenge. Not only did I have to write the shortest program that prints `Poetic`, but I challenged myself to create a somewhat coherent series of sentences without using `p`, `o`, `e`, `t`, `i`, or `c` (in keeping with the spirit of the language). That makes this program a "lipogram".
[Answer]
## Python 2, 2 bytes, 1 character
```
è
```
output...:
[![output](https://i.stack.imgur.com/oDhlk.png)](https://i.stack.imgur.com/oDhlk.png)
[Answer]
# Python, ~~27~~ ~~53~~ ~~49~~ ~~48~~ ~~45~~ 31 bytes
-3 bytes from @wizzwizz4
```
exec'IM\x50ORT THIS'.swapcase()
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728oLIkIz_PaMGCpaUlaboW-1MrUpPVPX1jKkwN_INCFEI8PIPV9YrLEwuSE4tTNTQhqqCKYZoA)
Prints the following text, which has "Python" on the first line.
```
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
```
[Answer]
# MATLAB, 3 bytes
```
ver
```
Output is as follows. Irrelevant info has been replaced by `[...]`). Some parts of the output may change depending on version, installed toolboxes etc.
```
-----------------------------------------------------------------------------------------
MATLAB Version: 8.6.0.267246 (R2015b)
MATLAB License Number: [...]
Operating System: [...]
Java Version: Java 1.7.0_60-b19 with [...]
-----------------------------------------------------------------------------------------
MATLAB                                                Version 8.6         (R2015b)
Communications System Toolbox                         Version 6.1         (R2015b)
Curve Fitting Toolbox                                 Version 3.5.2       (R2015b)
[...]
Wavelet Toolbox                                       Version 4.15        (R2015b)
```
[Answer]
# [><>](https://esolangs.org/wiki/Fish), ~~12~~ 10 bytes
```
"2,:o:2-o|
```
This will continually print ><> until the interpreter runs out of space.
[Try it online!](https://tio.run/nexus/fish#@69kpGOVb2Wkm1/z/z8A "><> – TIO Nexus")
12 byte version below for those who like a clean output. Recommended by Aaron (no error, 1 output)
```
":3+:o$1+oo;
```
[Answer]
# [C](http://savannah.nongnu.org/projects/tinycc), 1 byte
```
]
```
Output:
```
.code.tio.c:1: error: declaration expected
```
[Try it online!](https://tio.run/##S9YtSU7@/z/2/38A "C (tcc) – Try It Online")
[Answer]
# JAVA, 1 byte
```
1
```
The output to stderr is:
```
Main.java:1: error: class, interface, or enum expected
1
^
1 error
Error: Could not find or load main class Main
Command exited with non-zero status 1
    Command being timed: "/srv/wrappers/java-openjdk"
    User time (seconds): 1.40
    System time (seconds): 0.80
    Percent of CPU this job got: 40%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:05.40
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 44564
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 205
    Minor (reclaiming a frame) page faults: 11301
    Voluntary context switches: 2666
    Involuntary context switches: 1677
    Swaps: 0
    File system inputs: 78312
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 1 
```
[Answer]
# CSS, 25 bytes
```
:after{content:'\43\53\53
```
Note that extra markup is added to Stack Overflow snippets, causing "CSS" to be displayed more than once. Open an `.html` file with contents 
```
<style>:after{content:'\43\53\53
```
to see the result as intended.
[Answer]
# J, 2 bytes
```
   a.
┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~��������������������������������������������������������������������������������������������������������������������������������
```
`a.` returns the alphabet of the J language — a built-in list of all bytes.
## My original: 4 bytes
```
   %:_1
0j1
```
This just seems pretty cool to me. The square root (`%:`) of negative 1 (`_1`) is *i* (`0j1`).
[Answer]
# bash CLI, 9
```
printf $0
```
---
If you want an actual script and not just a command at the interactive command line, then you can do this:
# bash, 13
```
printf $SHELL
```
Outputs `/bin/bash`
[Answer]
# brainfuck, 105 Bytes
```
--[----->+<]>----.[--->+<]>----.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.
```
Try it online [here](https://copy.sh/brainfuck/?c=LS1bLS0tLS0-KzxdPi0tLS0uWy0tLT4rPF0-LS0tLS4rKytbLT4rKys8XT4rKy4rKysrKysrKy4rKysrKy4tLS0tLS0tLS4tWy0tLT4rPF0-LS0uK1stPisrKzxdPisuKysrKysrKysu)
[Answer]
## BASIC (ZX Spectrum), ~~4~~ 2 bytes
*crossed out 4 is still regular 4*
Saved 2 bytes thanks to @ShaunBebbers.
```
0õ
```
Note: In the ZX Spectrum character set, these bytes display as
```
0 PRINT
```
When you enter this in, the Spectrum starts by parsing an optional number followed by a line of code. Normally the line number is `1..9999` which causes the code to be added to the stored program. However if no line number is supplied then the code is executed immediately instead. Unfortunately a bug in the Spectrum means that it mistakes a line number of zero for no line number at all, but it still tries to execute the zero as part of the line of code, which is illegal, thus causing the error.
The previous 4-byte version generates a true error rather than relying on an interpreter bug:
```
õ°""
```
Note: In the ZX Spectrum character set, these bytes display as
```
PRINT VAL ""
```
which outputs
```
C Nonsense in BASIC, 0:1
```
because the empty string is not a valid numeric expression. (I could of course have used any statement that takes a single integer.) If this answer is unacceptable, then for 6 bytes you can write a program consisting of a single line with one of the keywords that accepts no arguments, then use `POKE` to replace it with an illegal keyword, then attempt to `RUN` the program.
[Answer]
# dc, 6
```
25699P
```
Outputs `dc`.
[Try it online](https://tio.run/nexus/dc#@29kamZpGfD/PwA).
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 8 bytes
```
'IWR C80
```
Takes the character `I` and `WR`aps it in `C`hr(`80`), resulting in `PIP`. [Try it online!](https://tio.run/nexus/pip#@6/uGR6k4Gxh8P8/AA)
Using the `I` feels a bit like cheating, so here are [two 9-byte solutions](https://tio.run/nexus/pip#@x/NpVDlYBEeVOVgaMqloFFloR1nbmCuyRX7//9/3RwA) that don't use any of `PpIi`:
```
z@8WRz@15
(z8+^707)
```
Both output `pip`. I'm particularly pleased with the second one:
```
    ^707   Split 707 into a list of characters        [7;0;7]
  8+       Add 8 to each one                          [15;8;15]
(z      )  Use list to index into lowercase alphabet  ["p";"i";"p"]
           By default, lists are printed without a separator
```
For proper capitalization, we need a [10-byte solution](https://tio.run/nexus/pip#@6/uGR6k4GxhEFbBxWWt4JdfkmqlEAYTVCjOyC/NSVHISCxLVSjPL8pOTdFRSCotUUgEkukKBUWpZal5JakpCplAoRKFkoxUhZLM3FSF/DQwOzkjMScnNS89Ve//fwA):
```
'IWR C80Vx
```
How this one works is left as an exercise for the reader. ;^)
[Answer]
# C#, ~~60~~ 67 bytes
```
class P{static void Main(){System.\u0043onsole.Write("\x43\x23");}}
```
[Answer]
# Forth, 5 bytes
```
WORDS
```
[**Try it online**](https://tio.run/nexus/forth-gforth#@x/uH@QS/P8/AA)
Prints a list of every word in the language. `Forth` happens to be in the list (first word on line 125), though I don't know what it does.
[Answer]
# Excel, 35
Closing parens already discounted.
Simple enough:
* `A1` - `=RIGHT(0=1)` - `E` from `FALSE`
* Output - `=A1&ROMAN(90)&A1&ROMAN(50)` - `EXCEL`
`ROMAN(90)` = `XC`, `ROMAN(50)` = `L`
[Answer]
# [R](https://www.r-project.org/), 11 bytes
```
cat("\x52")
```
[Try it online!](https://tio.run/nexus/r#@5@cWKKhFFNhaqSk@f8/AA "R – TIO Nexus")
]