explain xkcd - User contributions [en]

1537: Types

2015-06-12T22:04:08Z

141.101.98.29: /* Explanation */

{{comic
| number = 1537
| date = June 12, 2015
| title = Types
| image = types.png
| titletext = colors.rgb("blue") yields "#0000FF". colors.rgb("yellowish blue") yields NaN. colors.sort() yields "rainbow"
}}

==Explanation==
{{incomplete|Title text not explained. More details before the list.}}

This comic is a series of programming jokes about a ridiculous new programming language, perhaps inspired by [https://www.destroyallsoftware.com/talks/wat Gary Bernhardt's CodeMash 2012 lightning talk] on Javascript's unpredictable typing. The (highly technical) audience is unable to correctly guess the results of adding various Javascript types and roars with laughter when they're revealed.

Most regular programming languages distinguish a number of types, e.g. integers , strings, lists,... All of which have different behaviours. The operation "+" is conventionally defined over more than one of these types. Applied to two integers, it returns their addition, but applied to two strings (denoted by being enclosed in quotes) it concatenates them:

<code>> 2 + 3

5

> "123" + "abc"

"123abc"</code>

While these behaviours are standard, conventional, and intuitive, there is a huge amount of variation among programming languages when you apply an operation like "+" to different types. One logical approach is to always return an error in all cases of type mixing, but it is often practical to allow some case mixing, since it can hugely simplify an operation. Variation and lack of a clearly more intuitive behaviour leads some languages to have weird results when you mix types.

# <code>2 + "2"</code> uses the <code>+</code> operator on a number and a string. In a normal language, this would result either the number <code>4</code> (addition), or <code>"22"</code> (string concatenation); however, the new language converts the string to an integer, adds them to produce <code>4</code> and converts back to a string. Alternately, it is adding 2 to the ASCII value of the character <code>"2"</code>, which (interpreted as a string) is <code>"4"</code>. This is (somewhat) consistent with the behavior for item 4.
# <code>"2" + []</code> adds a string to an array (a list), this time. This first inexplicably converts the string to a number again, and then it literally adds the number to the list by appending it (this would make sense if it was <code>[] + 2</code>, but usually not the other way around). And then the result (the entire array) is converted to a string again.
# <code>(2/0)</code> divides <code>2</code> by <code>0</code> and quite reasonably results in <code>NaN</code> (not a number).
# <code>(2/0)+2</code> adds <code>2</code> to <code>NaN</code>. <code>2</code> is "added" to the string <code>"NaN"</code> (again, the number is converted to a string for apparently no reason), which produces <code>"NaP"</code>, as if <code>2</code> was added to <code>"N"</code> to produce <code>"P"</code> (as per alphabetical order or ASCII encoding; <code>N</code> is <code>01001110</code>, and adding 2 to this results in <code>01010000</code> which is <code>P</code>).
# <code>""+""</code> looks like it is concatenating (adding) an empty string (i.e. <code>""</code>) to another empty string, which should produce an empty string. However, the entire thing is treated as one string (with the start quote being the first one and the end quote being the very last one), which produces the egregious '<code>"+"</code>'.
# <code>[1,2,3]+2</code> seems to test whether it's sound to append <code>2</code> to the list <code>[1,2,3]</code>, and concludes that it doesn't fit the pattern, returning the boolean value <code>false</code>. It could conceivably also be the result of an attempt to add <code>2</code> to the ''set'' <code>[1,2,3]</code>, which already contains that element (although <code>{1,2,3}</code> would be a more common notation for sets).
# <code>[1,2,3]+4</code> returns <code>true</code> for much the same reason.
# <code>2/(2-(3/2+1/2))</code> is a floating point joke. Floating point numbers are notoriously imprecise. With precise mathematics, <code>(3/2+1/2)</code> would be exactly 2, hence the entire thing would evaluate to <code>2/0</code> or <code>NaN</code> in Randall's new language. However, the result of <code>(3/2+1/2)</code> is "just slightly off," which makes the result "just slightly off" of <code>NaN</code> (which would be ridiculous in a real language). The ironic thing is that fractions with 2 in the denominator are ''not'' the kind of numbers that typically suffer from floating point impreciseness. Additionally, if there was indeed a rounding error, the actual calculation becomes something like <code>2/0.0000000000000013</code>, which should not return a <code>NaN</code> since it is not division by zero.
# <code>range(" ")</code> normally wouldn't make any sense. However, the new language appears to interpret it as ASCII, and in the ASCII table, character #32 is space, #33 is <code>!</code>, and #34 is <code>"</code>. So, instead of interpreting <code>" "</code> as a string, it seems to be interpreted as <code>34, 32, 34</code> (in ASCII), and then <code>range</code> appears to transform this into <code>34, 33, 32, 33, 34</code> (the "ranges" between the numbers), which, interpreted as ASCII, becomes <code>['"', '!', ' ', '!', '"']</code>.
# <code>+2</code> refers to the Chinese/Japanese (Kanji) number system, where the plus sign is instead the symbol <code>十</code>. In Chinese, this symbol represents the number ten, and if you translate the <code>2</code> into Chinese, you get <code>二</code>. Therefore, in full Chinese the code is <code>十二</code> is equivalent to the number <code>12</code>
# <code>2+2</code> would normally be <code>4</code>. However, the interpreter takes this instruction to mean that the user wishes to increase the actual value of the number <code>2</code> (aka the "literal value") by <code>2</code> for the remainder of the program, making it <code>4</code> and then reports that the work is "Done". The result can be seen in the subsequent lines where all <code>2</code>s are replaced by <code>4</code>s. This could be a reference to languages like Fortran where [http://everything2.com/title/Changing+the+value+of+5+in+FORTRAN literals could be assigned new values].
# <code>range(1,5)</code> would normally return <code>[1, 2, 3, 4, 5]</code>. However, since the value of <code>2</code> has been changed to <code>4</code>, it returns <code>[1, 4, 3, 4, 5]</code>, and this even affects the line number (which is 14 instead of 12).
# <code>floor(10.5)</code> should return <code>10</code> (the "floor" of a decimal number is that number rounded down). However, it instead returns {{w|ASCII art}} of the number on a "floor."

The title text contains three further examples relating to color. <code>color.rgb("blue")</code> returns the hexadecimal code for pure blue (as would be used in HTML, for example), which is how a real programming language might work. The lookup for "yellowish blue" returns "NaN" (Not a Number) again, which makes sense at one level because there is no such color as "yellowish blue" (yellow and blue make green). However a more typical result would have been a failure indicating that the color database does not include the name, in the same way that a typo such as "bluw" would. Similarly sorting the colors would normally produce some defined ordering, such as alphabetical, but in this language it generates the string "rainbow". It seems that Randall's new language understands color theory in an unusually deep way.

==Transcript==
My new language is great, but it has a few quirks regarding type:
<pre>
[1]> 2+"2"
=> "4"
[2]> "2"+[]
=> "[2]"
[3] (2/0)
=> NaN
[4]> (2/0)+2
=> NaP
[5]> ""+""
=> '"+"'
[6]> [1,2,3]+2
=> FALSE
[7]> [1,2,3]+4
=> TRUE
[8]> 2/(2-(3/2+1/2))
=> NaN.0000000000000013
[9]> range(" ")
=> ('"','!'," ","!",'"')
[10]> +2
=> 12
[11]> 2+2
=> DONE
[14]> RANGE(1,5)
=> (1,4,3,4,5)
[13]> FLOOR(10.5)
=> |
=> |
=> |
=> |
=> |___10.5___
</pre>

The alt text for the image starts out with colors.rgb("blue") yields "#0000FF". Again, it just took a string, turned it into a variable, and made it a string again. However, the .rgb function shouldn't be returning a hex code for the color!
It then transitions into colors.rgb("yellowish blue") yields "NaN". Seeing how it returned a hex code for the last one, attempting to get the RGB value of an [https://en.wikipedia.org/wiki/Impossible_color impossible color] would predictably cause it to return NaN.
Finally, colors.sort() yields "rainbow". It just got stuffed through a prism, which sorted the colors into a rainbow!
{{comic discussion}}

Talk:1537: Types

2015-06-12T19:13:35Z

141.101.98.29:

Relevant: WAT talk https://www.destroyallsoftware.com/talks/wat

Are (6) and (7) about completing sequences?

If the sequence was [1, 2, 3, ?] we would expect the ? to be a placeholder for 4. So [1, 2, 3]+2 is wrong := FALSE. But [1, 2, 3]+4 is correct := TRUE.

"+2 appears to be applying a unary + to the number 2" : or it adds the number of the line, 10, to 2 => 12. Also, the eleventh line, "2+2" may add 2 to all the following 2, explaining line 12. (that theory is from a friend of mine) [[User:Seipas|Seipas]] ([[User talk:Seipas|talk]]) 12:17, 12 June 2015 (UTC)
: Also, for the lines 6 and 7, the operation "[1,2,3]+x" may add x to the set [1,2,3] and return true if the operation succeeded or false if not. Adding 2 to the set [1,2,3] returns false because 2 is already in [1,2,3]. [[User:Seipas|Seipas]] ([[User talk:Seipas|talk]]) 12:23, 12 June 2015 (UTC)

Yellowish Blue: http://www.livescience.com/17948-red-green-blue-yellow-stunning-colors.html is NaN!

''"The ironic thing is that fractions with 2 in the nominator are not the kind of numbers that typically suffer from floating point impreciseness."''
- This is not technically correct. Should read "fractions with 'power of 2' in the '''de'''nominator. However, the 3/2 would cause precision errors.
: I don't know proper English wording for things, but 3/2=3*2^-1, so it would be represented exactly under IEEE-754 too. [[Special:Contributions/141.101.89.217|141.101.89.217]] 13:58, 12 June 2015 (UTC)

Is there more to this comic, a fixed set of rules that can tie all the examples together, or does each line make its own joke independently? [[Special:Contributions/108.162.219.5|108.162.219.5]] 12:54, 12 June 2015 (UTC)

== "normally" ==

<blockquote>This would make sense if it was <code>[] + 2</code></blockquote>

It really wouldn't. Javascript returns <code>"2"</code> (god knows why) and Python gives an error. Don't really feel like testing many other languages, but I also think it's not really a logical assumption to make at all. Can't think of a reason for <code>[] + 2</code> to return <code>[2]</code>... ever. It ''might'' make a little bit of sense in Randall's oddly typed language, but not in any sane one. --[[User:TotempaaltJ|TotempaaltJ]] ([[User talk:TotempaaltJ|talk]]) 12:35, 12 June 2015 (UTC)

: Javascript first converts <code>[]</code> (the empty array) to the empty string (using the rule "stringify each element and join with a comma"), then treats the operation as <code>"" + 2</code>, which results in conversion of the other operand to string and then concatenation. [[Special:Contributions/141.101.97.214|141.101.97.214]] 12:46, 12 June 2015 (UTC)

line 4: asci code of N + 2 = asci code of P [[User:SirKitKat|sirKitKat]] ([[User talk:SirKitKat|talk]]) 13:07, 12 June 2015 (UTC)

My favourite xkcd in a while. =8o) Of the list I got a good laugh out of numbers 8 and 13. [[User:Jarod997|Jarod997]] ([[User talk:Jarod997|talk]]) 13:11, 12 June 2015 (UTC)

I think a lot of this is his joke about programming languages loving the number 4. 2 + "2" = "4", [1,2,3] + 4 = true, 2+2 = DONE, and the range one all seem to support this. Also reminds me of this: http://xkcd.com/221/

Why isn't yellowish blue just green? [[User:Djbrasier|Djbrasier]] ([[User talk:Djbrasier|talk]]) 16:18, 12 June 2015 (UTC)

line 4: I read NaP as Not a Problem. [[Special:Contributions/141.101.104.12|141.101.104.12]] 17:00, 12 June 2015 (UTC)

Line 3 is missing its prompt. There does not appear to be any relevance to the joke, nor has anyone yet explained why it should be missing. Typo? [[Special:Contributions/108.162.221.183|108.162.221.183]] 17:10, 12 June 2015 (UTC)

Note that some programming languages avoid the problem of overloaded '+' operator between operands of vividly different types by using other symbols for string concatenation (be it "a"~"b" or "a"."b") and numerical addition. The real WTF is abusing '+' for string concatenation, which has very different properties from numerical addition, not being symmetrical for example: concat("aa", "bb") == "aabb", while concat("bb", "aa") == "bbaa" != "aabb". --[[User:JakubNarebski|JakubNarebski]] ([[User talk:JakubNarebski|talk]]) 17:38, 12 June 2015 (UTC)

Series of comics? I don't recall any others about Randall's new programming language... [[Special:Contributions/141.101.98.29|141.101.98.29]] 19:13, 12 June 2015 (UTC)

Talk:1535: Words for Pets

2015-06-08T17:00:01Z

141.101.98.29:

I skipped the first step by naming my cat "Cat". On the plus side, even in the third year I was still mostly calling her by her name. --[[Special:Contributions/108.162.254.134|108.162.254.134]] 08:06, 8 June 2015 (UTC)

Not sure this is relevant enough to include, but there's [http://tvtropes.org/pmwiki/pmwiki.php/Main/ADogNamedDog a trope about that] [[Special:Contributions/188.114.111.224|188.114.111.224]] 11:39, 8 June 2015 (UTC)

I interpreted this slightly differently. In the first year, the pet is fresh and new, and you put the effort in to call it by its name. As time goes on, you get sloppier about it. In addition, I believe he missed a ring from it: Expletives. Within a year of having a new cat, I was calling it more by expletives than its name. [[User:Drmouse|Drmouse]] ([[User talk:Drmouse|talk]]) 14:24, 8 June 2015 (UTC)

I disagree with the explanation. The comic is about words used to refer to the pet, i.e. to name the pet when talking to someone else, not to talk to the pet. For instance "I forgot to feed Lassie" might later become "I forgot to feed the dog", then "I forgot to feed the damn thing" or whatever. Am I the only one to understand "refer" like this?
Zetfr 16:53, 8 June 2015 (UTC)
:In my household at least, we use the animal's species as its name. For example, instead of "Have you fed Lassie?", we may say " Have you fed Dog?". I think is what Randall is implying. [[Special:Contributions/141.101.98.29|141.101.98.29]] 17:00, 8 June 2015 (UTC)

797: debian-main

2014-10-14T16:42:05Z

141.101.98.29: /* Explanation */

{{comic
| number = 797
| date = September 24, 2010
| title = debian-main
| image = debian_main.png
| titletext = dpkg: error processing package (--purge): subprocess pre-removal script returned error exit 163: OH_GOD_THEYRE_INSIDE_MY_CLOTHES
}}

==Explanation==
{{w|Debian}} is a Linux distribution most notable for introducing {{w|Advanced Packaging Tool|APT}} (Advanced Packaging Tool). APT is a tool that functions as an automated general software installer for Linux systems; all one has to do is tell it what software package they would like to install, and the program will automatically fetch the software and all of its dependencies (other packages that a program relies on, such as a library for processing ZIP archives) from a central ''repository''. It will also automatically handle upgrades by automatically checking if the repository version of a package is higher than the currently installed version, and it can even handle the use of multiple repositories and linking between them; for example, if a piece of software is deemed worthy of inclusion in Debian's main repository, but as a stable release, the software developers can provide their own repository to provide a more experimental version for users who want it, and once that repository is added to APT's source list, APT will automatically realize that it should use the experimental version, since it has a higher version than that of the main repository. Although this wasn't the first package management system for easy Linux installation (that honor goes to {{w|RPM Package Manager|RPM}}), it is the first one that seamlessly integrated online installation and upgrades into the mix.

debian-main is Debian's main repository, included by default in all Debian installations. It's what you might call the "canon" of Debian, containing only those packages that have been approved by official Debian developers. Thus, getting a package on debian-main means that it, theoretically, conforms to a standard of quality.

In this case, however, the Debian developers seem to have not noticed that one of the dependencies for the package is "locusts." {{w|Locust}}s are real insects, the migratory forms of several grasshopper species, that are best known for breeding extremely quickly, swarming, and devouring all green plant matter they come across, resulting in crop devastation (some consider this a plague). In some parts of the world they are also considered a delicacy. [[Cueball]] probably does not appreciate this as they crawl over his body searching for food, apparently spontaneously generated by APT as it saw that it needed "locusts" to install the package.

The title text is an error line from <code>dpkg</code>, the program used to install/remove APT packages. Every package contains several scripts (although some of them may be empty) that are run on various events related to that package; these are used to perform any setup/cleanup tasks the package needs. This line is an error line indicating that one of those scripts has failed. The relevant portions are:

*<code>error processing package (--purge)</code>: --purge is the option to purge a package completely from the system. This means that the program itself, all related data files, and all configuration files are removed from the system. So, the user was attempting to completely remove the locusts from the system without leaving a trace.
*<code>subprocess pre-removal script</code>: The pre-removal script is the code run before actually removing a piece of software. Mostly, this allows long-running software (such as webservers) to stop themselves before removing anything, to avoid corrupting the hard disk. That means the error came while the computer was preparing to get rid of the locusts.
*<code>returned error exit 163</code>: "Returned error" means just what it says, the script returned an error. "Exit" means that the error was a result of calling the <code>exit()</code> function with a non-zero value, specifically the value 163. The exact value has no real significance other than signifying to a user or other application that understands what the code means; neither <code>dpkg</code> nor the Linux kernel itself treat any exit value specially, apart from checking whether the value is 0 (which means no error).
*<code>OH_GOD_THEYRE_INSIDE_MY_CLOTHES</code>: This is the message returned along with the error. This seems to be the computer indicating that it is unwilling to go any further with the deletion because the locusts are crawling under its clothes.

==Transcript==
:AAAAAAAA
:[A swarm of insects cover Cueball and his computer. He is leaning back on their chair, flailing to get away.]

:My package made it into Debian-main because it looked innocuous enough; no one noticed "locusts" in the dependency list.

==Trivia==
*This is fixed in [http://packages.debian.org/changelogs/pool/main/m/mingetty/current/changelog#versionversion1.07-2 Debian's mingetty 1.07-2] and above.
{{comic discussion}}
[[Category:Comics featuring Cueball]]
[[Category:Linux]]

797: debian-main

2014-10-14T16:40:43Z

141.101.98.29: /* Explanation */

{{comic
| number = 797
| date = September 24, 2010
| title = debian-main
| image = debian_main.png
| titletext = dpkg: error processing package (--purge): subprocess pre-removal script returned error exit 163: OH_GOD_THEYRE_INSIDE_MY_CLOTHES
}}

==Explanation==
{{w|Debian}} is a Linux distribution most notable for introducing {{w|Advanced Packaging Tool|APT}} (Advanced Packaging Tool). APT is a tool that functions as an automated general software installer for Linux systems; all one has to do is tell it what software package they would like to install, and the program will automatically fetch the software and all of its dependencies (other packages that a program relies on, such as a library for processing ZIP archives) from a central ''repository''. It will also automatically handle upgrades by automatically checking if the repository version of a package is higher than the currently installed version, and it can even handle the use of multiple repositories and linking between them; for example, if a piece of software is deemed worthy of inclusion in Debian's main repository, but as a stable release, the software developers can provide their own repository to provide a more experimental version for users who want it, and once that repository is added to APT's source list, APT will automatically realize that it should use the experimental version, since it has a higher version than that of the main repository. Although this wasn't the first package management system for easy Linux installation (that honor goes to {{w|RPM Package Manager|RPM}}), it is the first one that seamlessly integrated online installation and upgrades into the mix.

debian-main is Debian's main repository, included by default in all Debian installations. It's what you might call the "canon" of Debian, containing only those packages that have been approved by official Debian developers. Thus, getting a package on debian-main means that it, theoretically, conforms to a standard of quality.

In this case, however, the Debian developers seem to have not noticed that one of the dependencies for the package is "locusts." {{w|Locust}}s are a real insect, the migratory forms of several grasshopper species, that are best known for breeding extremely quickly, swarming, and devouring all green plant matter they come across, resulting in crop devastation (some consider this a plague). In some parts of the world they are also considered a delicacy. [[Cueball]] probably does not appreciate this as they crawl over his body searching for food, apparently spontaneously generated by APT as it saw that it needed "locusts" to install the package.

The title text is an error line from <code>dpkg</code>, the program used to install/remove APT packages. Every package contains several scripts (although some of them may be empty) that are run on various events related to that package; these are used to perform any setup/cleanup tasks the package needs. This line is an error line indicating that one of those scripts has failed. The relevant portions are:

*<code>error processing package (--purge)</code>: --purge is the option to purge a package completely from the system. This means that the program itself, all related data files, and all configuration files are removed from the system. So, the user was attempting to completely remove the locusts from the system without leaving a trace.
*<code>subprocess pre-removal script</code>: The pre-removal script is the code run before actually removing a piece of software. Mostly, this allows long-running software (such as webservers) to stop themselves before removing anything, to avoid corrupting the hard disk. That means the error came while the computer was preparing to get rid of the locusts.
*<code>returned error exit 163</code>: "Returned error" means just what it says, the script returned an error. "Exit" means that the error was a result of calling the <code>exit()</code> function with a non-zero value, specifically the value 163. The exact value has no real significance other than signifying to a user or other application that understands what the code means; neither <code>dpkg</code> nor the Linux kernel itself treat any exit value specially, apart from checking whether the value is 0 (which means no error).
*<code>OH_GOD_THEYRE_INSIDE_MY_CLOTHES</code>: This is the message returned along with the error. This seems to be the computer indicating that it is unwilling to go any further with the deletion because the locusts are crawling under its clothes.

==Transcript==
:AAAAAAAA
:[A swarm of insects cover Cueball and his computer. He is leaning back on their chair, flailing to get away.]

:My package made it into Debian-main because it looked innocuous enough; no one noticed "locusts" in the dependency list.

==Trivia==
*This is fixed in [http://packages.debian.org/changelogs/pool/main/m/mingetty/current/changelog#versionversion1.07-2 Debian's mingetty 1.07-2] and above.
{{comic discussion}}
[[Category:Comics featuring Cueball]]
[[Category:Linux]]

Talk:249: Chess Photo

2014-08-16T22:16:27Z

141.101.98.29:

I've seen pictures of people doing this before I met xkcd, and I just read the confirmation at knowyourmeme.com that Randall started this. This is friggin' amazing.[[Special:Contributions/108.162.210.235|108.162.210.235]] 15:07, 17 November 2013 (UTC)

Comics Missing!--[[Special:Contributions/108.162.250.8|108.162.250.8]] 10:38, 5 December 2013 (UTC)
:Could you compile these at the community portal? I'll see what I can do about this. '''[[User:Davidy22|{{Color|#707|David}}y²²]]'''[[User talk:Davidy22|<tt>[talk]</tt>]] 11:16, 5 December 2013 (UTC)
::It's 5 in the morning, and this fixed now. '''[[User:Davidy22|{{Color|#707|David}}y²²]]'''[[User talk:Davidy22|<tt>[talk]</tt>]] 13:03, 5 December 2013 (UTC)

The last sentence has always been upsetting me and never found the time to comment/correct: Blindfold chess doesn't require any actual blindfold, it's just called that way because the two players don't need a board and just communicate their moves. Therefore, the "blindfold" is not redundant, it is rather the simplest way to play chess on a roller coaster. --[[46.5.2.144]] 22:07, 16 August 2014 (UTC)