[Question]
  [
This challenge is straightforward, but hopefully, there are plenty of avenues you can approach it:
**You need to print/return a valid JSON *object* of at least 15 characters, not counting unessential whitespace.** Your program should work without any input.
In the interest of clarity, a JSON object starts and ends with curly braces `{}`, and contains zero or more key:value pairs separated by commas. The full JSON specification can be found at [json.org](http://www.json.org/), and the output of your code must pass [this validator](http://jsonlint.com/#).
Therefore, any of the following would **not** be valid:
```
4                               //Too short, not an object
"really, really long string"    //A string, not an object
["an","array","of","values"]    //An array is not a JSON object
{"this":4      }                //You can't count unessential whitespace
{"1":1,"2":3}                   //Too short
{"a really long string"}        //Not valid JSON, it needs a value
{'single-quoted':3}             //JSON requires double-quotes for strings
```
However, the following *would* be valid:
```
{"1":1,"2":2,"3":3,"4":4}       //Long enough
{"whitespace      ":4}          //This whitespace isn't unessential
```
Non-programming languages are allowed on this challenge. You may return a string from a function, or print it out. This is a [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so answer it with as little code as possible!
  
[Answer]
## Python 2, 14 bytes
```
print{`str`:1}
```
Outputs:
```
{"<type 'str'>": 1}
```
The backticks get the string representation in Python 2. Usually, this outputs inside creates single quotes, which Python recognizes as delimiting a string, but JSON doesn't. But Sp3000 observes that when stringifying a type, the type description already contains single quotes, which forces the outer quotes to be double quotes.
[Answer]
# jq, 6 characters
(3 characters code + 3 characters command-line option.)
```
env
```
CW because I am sure this is not the kind of answer you intended to allow.
Sample run:
```
bash-4.3$ jq -n 'env'
{
  "GIT_PS1_SHOWDIRTYSTATE": "1",
  "TERM": "xterm",
  "SHELL": "/bin/bash",
  "GIT_PS1_SHOWUNTRACKEDFILES": "1",
  "XTERM_LOCALE": "en_US.UTF-8",
  "XTERM_VERSION": "XTerm(322)",
  "GIT_PS1_SHOWSTASHSTATE": "1",
  "GIT_PS1_SHOWUPSTREAM": "auto",
  "_": "/usr/bin/jq"
}
```
(Output obviously shortened.)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“Ɠɼ'ẸẠḌȷżÑ»
```
[Try it online!](http://jelly.tryitonline.net/#code=4oCcxpPJvCfhurjhuqDhuIzIt8W8w5HCuw&input=)
### Output
```
{"Llanfairpwllgwyngyllgogerychwyrndrobwllllantysiliogogogoch":0}
```
[Answer]
# Notepad, 7 keystrokes
If you have a Windows computer with the Notepad program, type this:
`{``"``F5``"``:``0``}`
On my Windows 7 computer, at least, this gives you something like:
```
{"3:42 PM 10/25/2016":0}
```
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 20 bytes
```
v->"{\"\":"+1/.3+"}"
```
[Try it online!](https://tio.run/##LYyxDoIwGIT3PsWfTqBSY9xEGd2cSFzEoYKQYmkb@peEEJ69VmS63N131/KBJ2318aIzukdog2cOhWS1UyUKrdgmJcS4lxQllJJbCzcuFEwEYE0tcgwyaFFBF7oox16o5vEE3jc2XlCA6/p3vgdu90cyqOECfkgyOhW0oCe6PezZcUtn6tNllY8W3x3TDpkJC5Qqqhk3Ro6RclLG8Q@byey/ "Java (JDK 10) – Try It Online")
## Output
```
{"":3.3333333333333335}
```
[Answer]
# JavaScript, ~~17~~ 15 bytes
Thanks to @Neil for this one. Call with no input.
```
_=>`{"${_}":0}`
```
Outputs `{"undefined":0}`
### Old version, 16 bytes
Thanks to @kamoroso94 for -1 on this version
```
_=>`{"":${9e9}}`
```
Outputs `{"":9000000000}`
[Answer]
# PHP, ~~14~~ 13 bytes
```
{"":<?=M_E?>}
```
Prints a ~~nice~~ mathsy object ~~that one could almost pretend is useful~~:
```
{"":2.718281828459}
```
Uses the fact that php prints anything outside the tags verbatim to save on some quotation marks, `M_E` was the shortest long enough constant I could find.
edit: saved one byte thanks to Lynn. Sadly it's no longer a 'nice' mathsy object.
[Answer]
## Brainfuck, 50 bytes
```
+[+<---[>]>+<<+]>>+.>>>--.<+++<[->.<]>>.<+.-.<<++.
```
Outputs `{"999999999999999999999999999999999999999999999999999999999999999999999999999999999":9}`. Assumes an interpreter that has 8-bit cells and is unbounded on the left. [Try it online!](http://brainfuck.tryitonline.net/#code=K1srPC0tLVs-XT4rPDwrXT4-Ky4-Pj4tLS48KysrPFstPi48XT4-LjwrLi0uPDwrKy4&input=)
[Answer]
# Pyth - 5 bytes
Prints `{"'abcdefghijklmnopqrstuvwxyz'": 10}`.
```
XH`GT
```
[Try it online here](http://pyth.herokuapp.com/?code=XH%60GT&debug=0).
[Answer]
# Jolf, 9 bytes
```
"{¦q:¦q}"
```
Outputs: `{"{¦q:¦q}":"{¦q:¦q}"}`. [Try it here!](http://conorobrien-foxx.github.io/Jolf/#code=InvCpnE6wqZxfSI)
```
"{¦q:¦q}"
"{  :  }"  raw string
  ¦q       insert the source code here
     ¦q    and here
```
[Answer]
# Pyth, 7 bytes
```
.d],`G0
```
Creates a dictionary containing a single key `"'abcdefghijklmnopqrstuvwxyz'"` and value `0`:
```
.d         Dictionary from:
  ]         The single-element list containing:
   ,         The two-element list containing:
    `G        The representation of the alphabet (the key)
      0       and 0 (the value)
          Implicitly print the stringification of this.
```
[Answer]
# ///, ~~15~~ 14 characters
```
/a/{":1234}/aa
```
(At least the output is ~~1~~ 2 characters longer than the code.)
[Try it online!](http://slashes.tryitonline.net/#code=L2EveyI6MTIzNH0vYWE&input=)
Thanks to:
* [ETHproductions](https://codegolf.stackexchange.com/users/42545/ethproductions) for reusing the object delimiters as part of key (-1 character)
Sample run:
```
bash-4.3$ slashes.pl <<< '/a/{":1234}/aa'
{":1234}{":1234}
```
Just to make it more readable:
```
bash-4.3$ slashes.pl <<< '/a/{":1234}/aa' | jq ''
{
  ":1234}{": 1234
}
```
[Answer]
## Batch, 16 bytes
Prints `{"Windows_NT":0}`.
```
@echo {"%OS%":0}
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 9 bytes
Unfortunately, 05AB1E doesn't have a dictionary object so we have to construct our own.
```
’{"èÖ":7}
```
[Try it online!](http://05ab1e.tryitonline.net/#code=4oCZeyLDqMOWIjo3fQ&input=)
**Output**
```
{"dictionaries":7}
```
[Answer]
# R, 19 bytes
```
cat('{"',lh,'":1}')
```
Becomes a bit longer because the need to escape quotes `\"`. Furthermore, `lh` is one of the built-in datasets in `R` and is (to my knowledge) the object with the shortest name that contains the 9 characters needed to fill the length of the key. (edit: turns out `pi` does the trick as well with the standard option and I was beaten by @JDL who was clever enough to escape using single quotes rather than the extra backslashes)
The description of `lh` in the R-documentation is:
> 
> A regular time series giving the luteinizing hormone in blood samples at 10 mins intervals from a human female, 48 samples.
> 
> 
> 
which is a rather unexpected name of a key, but hey, it works and produces the output:
```
{" 2.4 2.4 2.4 2.2 2.1 1.5 2.3 2.3 2.5 2 1.9 1.7 2.2 1.8 3.2 3.2 2.7 2.2 2.2 1.9 1.9 1.8 2.7 3 2.3 2 2 2.9 2.9 2.7 2.7 2.3 2.6 2.4 1.8 1.7 1.5 1.4 2.1 3.3 3.5 3.5 3.1 2.6 2.1 3.4 3 2.9 ":1}
```
The answer can be compared to just padding the key with "random" letters to make the output at least 15 characters (24 bytes):
```
cat("{\"HeloWorld\":1}")
```
[Answer]
## PowerShell ~~22~~ ~~20~~ 14 Bytes
```
'{"":'+1tb+'}'
```
Output
```
{"":1099511627776}
```
Using the constant defined for 1TB in bytes to reach the character limit and the value of a static integer to make for valid json. Thanks to TimmyD for reducing the characters by 5 by removing some redundancy.
---
### Earlier Post 40 Bytes
```
"{$((1..9|%{'"{0}":{0}'-f$_})-join",")}"
```
Output
```
{"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}
```
Takes a integer array and creates a key-value pair for each. Join with commas and wrap with a set of curly braces.
[Answer]
# [V](http://github.com/DJMcMayhem/V), 9 bytes
```
i{"¹*":0}
```
[Try it online!](http://v.tryitonline.net/#code=aXsiwrkqIjowfQ&input=)
Very straightforward. Enters insert mode, enters the following text:
```
{"*********":0}
```
The reason this is so short is because `¹` repeats the following character 9 times.
[Answer]
## Retina, 11 bytes
```
 
{"9$*R":1}
```
### Output
```
{"RRRRRRRRR":1}
```
**Note:** the leading newline is significant as nothing is replaced with the resultant output, I've used a non-breaking space to illustrate this!
[Try it online!](http://retina.tryitonline.net/#code=CnsiOSQqUiI6MX0&input=)
[Answer]
# [Dyalog APL](https://www.dyalog.com/), 9 [bytes](http://meta.codegolf.stackexchange.com/a/9429/43319)
```
⎕JSON⎕DMX
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM9oCgzr@T/o76pXsH@fkDKxTcCJPwfLA4A "APL (Dyalog Unicode) – Try It Online")
In a clean workspace on my PC the result is
`{"Category":"","DM":[],"EM":"","EN":0,"ENX":0,"HelpURL":"","InternalLocation":["",0],"Message":"","OSError":[0,0,""],"Vendor":""}`
`⎕JSON` convert to JSON
`⎕DMX` the (universally available) **D**iagnostic **M**essage E**x**tended object
[Answer]
# [Japt](https://github.com/ETHproductions/japt) `-Q`, 1 byte
```
M
```
[Try it online!](https://ethproductions.github.io/japt/?v=2.0a0&code=TQ==&input=LVE=)
The output is `{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}`.
### How it works
`M` is a shorthand for JS's `Math` object, with one-char aliases to existing functions/constants and some extra functions/constants. The constants shown here are:
* `M.P = Math.PI`
* `M.Q = Golden Ratio = (Math.sqrt(5)+1)/2`
* `M.T = Math.PI * 2`
And the boring part: [the `-Q` flag applies `JSON.stringify` to the output value](https://github.com/ETHproductions/japt/blob/90d14016a5a4675c8c20243cb63ccbcea830c0b6/src/japt.js#L2122). Some of the properties are lost (e.g. `Math.E` and `Math.SQRT2`), but we still have the above three values and the result is well over 15 characters.
[Answer]
# brainfuck, 83 bytes
```
--[-->+++++<]>.+[---->+<]>+++.>-[>+<-----]>.........<<.[----->+<]>.>.>--[-->+++<]>.
```
Outputs `{"333333333":3}`
There is likely another shorter solution, but I have not yet found it.
Explanation:
```
--[-->+++++<]>. {
+[---->+<]>+++. "
>-[>+<-----]>.  3
........
<<.             "
[----->+<]>.    :
>.              3
>--[-->+++<]>.  }
```
[Try it online](https://copy.sh/brainfuck/?c=LS1bLS0-KysrKys8XT4uIHsKK1stLS0tPis8XT4rKysuICIKPi1bPis8LS0tLS1dPi4gIDMKLi4uLi4uLi4KPDwuICAgICAgICAgICAgICIKWy0tLS0tPis8XT4uICAgIDoKPi4gICAgICAgICAgICAgIDMKPi0tWy0tPisrKzxdPi4gIH0$)
[Answer]
### PHP, 19 bytes
```
<?='{"'.(9**9).'":1}';
```
Output: `{"387420489":1}`
<https://eval.in/665889>
Thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for the tips!
[Answer]
# Perl 5, 16 15 bytes
Uses [the unix timestamp of the moment the program was started](http://perldoc.perl.org/perlvar.html#BASETIME) as the content of a one-element object. **It gives valid output if you run it later than 10:46:39 on 3rd of March 1973**. But since we can't go back in time that seems legit.
```
say"{\"$^T\":1}"
```
Uses the [FORMAT\_TOP\_HANDLE variable `$^`](http://perldoc.perl.org/perlvar.html#FORMAT_TOP_NAME) which defaults to `STDOUT_TOP`.
```
say"{\"$^\":1}";
```
Run with `-E` flag at no additional cost.
```
perl -E 'say"{\"$^\":1}";'
```
Outputs is 16 bytes long.
```
{"STDOUT_TOP":1}
```
[Answer]
# Java 7, 36 bytes
```
String c(){return"{\"a\":"+1e6+"}";}
```
# Java 8, 21 bytes
```
()->"{\"a\":"+1e6+"}"
```
**Ungolfed & test code:**
[Try it here.](https://ideone.com/p0m9uT)
```
class M{
  static String c(){
    return "{\"a\":" + 1e6 + "}";
  }
  public static void main(String[] a){
    System.out.println(c());
  }
}
```
**Output (length 15):**
```
{"a":1000000.0}
```
[Answer]
# JavaScript (ES6) + jQuery, 15 bytes
Because jQuery.
```
_=>`{"${$}":0}`
```
Outputs `{"function (a,b){return new n.fn.init(a,b)}":0}` when called. Try it here:
```
f=_=>`{"${$}":0}`
alert(f())
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
```
[Answer]
# Windows batch, 10 bytes
```
{"%OS%":5}
```
The environment variable `OS` contains the string `Windows_NT` (On all Windows operating systems since 2000, according to [this](https://stackoverflow.com/questions/2788720/environment-variable-to-determine-the-os-type-windows-xp-windows-7) question on Stack Overflow)
[Answer]
# R, 19 bytes
This works in British English locale; it may require +2 bytes in others. (Edit: it probably doesn't --- see comments.)
```
cat('{"',pi,'":1}')
```
I was hoping for something clever (perhaps plucking a line of code out of a pre-existing function like `q`) but couldn't find anything. The result:
```
{" 3.141593 ":1}
```
Note that you don't have to escape double quotes in R if you use single quotes to quote the string (and vice-versa). This behaviour is locale-dependent though. I would expect it to work in a US English locale as well though.
This also requires that your default `digits` option is at least six (which is the factory-fresh default) and that `scipen` is at least `-digits` (the factory-fresh default is zero).
[Answer]
# HQ9+, 15 bytes
```
{"Quineland":0}
```
Outputs itself. I thought an 8-byte answer would be possible, like so:
```
{":11QQ}
```
This outputs `{":11QQ}{":11QQ}`, which is *almost* valid JSON, but `11QQ` is not a valid value.
HQ9+ is [not a valid programming language](http://meta.codegolf.stackexchange.com/questions/2028/what-are-programming-languages/2073#2073) by PPCG standards, but the OP has allowed non-programming languages.
[Answer]
# Bash, 18 bytes
`echo {\"$PATH\":1}`
This works on Mac and Linux, unless your $PATH isn't set. 
[Answer]
## Ruby, 19 bytes
```
puts'{"1":'+9**9+?}
```
Output:
```
{"1":387420489}
```
]