[Question]
  [
**Closed**. This question needs to be more [focused](/help/closed-questions). It is not currently accepting answers.
 
 
Closed 7 years ago.
**Locked**. This question and its answers are [locked](/help/locked-posts) because the question is off-topic but has historical significance. It is not currently accepting new answers or interactions.
 
 
Can you write an [aphorism](http://en.wikipedia.org/wiki/Aphorism) in at most 4 lines of code ?
Code should read as much as possible as an aphorism in plain English and should return the boolean `true`.
Language: of choice. 
Criteria for accepted answer: Most votes in 180 ~~30~~ days. (8th of July 2014) 
Originality: can be an old aphorism but a creative one would be much more appreciated.
  
[Answer]
# Python
```
import this
love = this
this is love, love is not True or False, love is love
# (True, True, True)
```
Okay, this returns a tuple of Truths, but that itself evaluates as True anyway.
[Answer]
## Forth
```
2 : b or ! 2 ." b" ;
: that s" the questi" on ;
```
[Answer]
# C:
You'll have to squint a bit to read this one :-)
```
int x(){ int __,L        ;
     return (__ |__ ||__ |__ ,__,__ ,__ ,__ ,__  ,
             __||  1||__ |  1L/L|__||__|1/__|  1L)
                                ;   }
```
You might notice a potential division-by-zero error on line 3, but this is never executed because the expression evaluates as `true` before the calculation is performed.
[Answer]
It's difficult to avoid string literals, comments and tricks fo this kind, but I tried to keep them to a mininum. Also, the first line makes no sense. Well, I had `fun` doing it
## F#
```
(fun () -> (fun (_) -> // fun fun? wtf
try not <| failwith("me") ; (*but*) with |Failure((*co*)me(*s*)) -> true)("learning"))()
// "Try not to fail with me, but with failure comes true learning
```
I could also do some declaration abusing, but I ended up not finding a way to return true:
```
let the,bodies,hit_the=floor(0.0),(),()
```
or
```
let the_games=bigint() //pun intended
```
I really need to stop with the puns.
[Answer]
# C
No string literals or comments:
```
Better(to,re);main(silent){and();}be(thought,a,fool){}
than(to,open,your,mouth);and(){}remove(all,doubt);
```
Split over two lines, but one would work fine as well.
When compiled using gcc on Linux (x86-64), this produces an executable which exits with success (exit code 0), the same as the `true` Unix utility; this being how I choose to interpret the requirement of returning boolean `true` in a non-scripting language. 
Note: notwithstanding the abuse of the "implicit int" rule, the principal trick behind this program is that while a C program that falls off the end of `main` without a `return` statement will usually result in a non zero exit code, by calling another function we can set the `EAX` register which is then used as the exit code of the program. This is of course totally undefined behaviour and utterly non portable. 
[Answer]
# Python
```
war=peace=freedom=slavery=ignorance=strength=0
war is peace|freedom is slavery|ignorance is strength
Power=a=means=it=an=end=0
Power is not (a, means, it is (an, end))
```
# JavaScript
```
You=true;function BigBrother(){};BigBrother.isWatching=function(y){return y};
BigBrother.isWatching(You)
```
[Answer]
# C#:
```
short life = 0;
return (life is short);
```
"Life is short" (Hippocrates)
[Answer]
# Ruby
```
class String
  def before(b) self < b end
end
```
A bit lengthy, but gets us a few aphorisms:
```
"age".before("beauty")
"business".before("pleasure")
"pearls".before("swine")
```
And (stretching slightly):
```
dont = []; y = 1
dont.count + y or ('chickens'.before('they hatch'))
```
[Answer]
# Scala
```
Some apply Double forall _; None isEmpty
```
[Answer]
# CoffeeScript
```
2 * @wrong isnt @right
```
=> true
[Answer]
# C++
```
bool life = true;
bool fair = false;
assert(life != fair);
```
[Answer]
# Python
```
love=[True];all,fair,war=love*3
all is fair in love and war
```
[Answer]
An aphorism about http verbs, in
## Ruby
```
puts do
something idempotent but are considered to be unsafe
because if the value at the beginning of a chain of calls is one possibly the value at the
end != 1
```
[Answer]
## C
```
if ((ifs && ands) == (pots && pans))
    work_for_tinkers_hands = FALSE;
```
[Answer]
# Javascript
```
function be(who) {
   if (who == 'thine own self') {
      return true;
   }
}
```
An approximation of "To thine own self be true."
I'm kind of fudging with the requirements, since it only returns true in one particular case ... but I'm hoping you'll let it slide because the return value is actually part of the aphorism.
[Answer]
# C
```
int main(int fear, int* computers){ int
    i; do { !fear; computers[i]; fear; "the lack of them";
} while();return true;}
```
*I do not fear computers, I fear the lack of them.*
-Isaac Asimov
[Answer]
# C
```
main(int I,char **think) {char *a="there"; for (;--I;) a['m'];}
```
[Answer]
I got a wonderful error while attempting this:
It's very much inspired by Darren Stone's answer.
> 
> TypeError: Cannot use 'in' operator to search for 'tis nobler' in mind to suffer the The Slings and Arrows of outrageous fortune
> 
> 
> 
# Javascript
```
[2].be || ! [2].be ; this.is, "the question"
```
It returns an implicit true.
Slightly less terse, with a question mark:
```
[2].be || ! [2].be? is = this: !"the question"
```
[Answer]
# PHP
```
$all = array('not well', 'not well', 'not well', 'well'); 
$end = array_pop($all);
$all = ($end == 'well') ? $end : 'not well';
return true;
```
"All's well that ends well."
[Answer]
# Q
`any bird:`int$"hehand"=2^`int$"hebush"`
and
`(./) 2_iscomp:any 3,'s:"a",'"crowd"`
[Answer]
# PHP
An apple a day...
```
$aphorism = function(){
    for($day=1;$day<=365;$day++) $apple++;
    return ($apple==365) ? true : 'doctor';
};
```
[Answer]
# Common Lisp
```
(Do ((as)) ('(I say no)t) as I do)
(time (and 'tide (wait-for 'no-man))) ;requires sbcl
```
[Answer]
A bit lazy, but my take.
# Python:
```
life = short = True; art = long = True; life=art
life is short and art is long
```
# JavaScript:
```
The = word = 'Yoga'
has = been = 'vulgarized'
and = does = not=  mean = anything =Date.now() ,!''
//Swami Rama 
```
[Answer]
# Lua
```
-- all search is in vain
function search() end
-- only the void is true
function void() return function() return true end, true end
-- and what remains is to
for ever in void() do repeat search("light") until true end
return true
```
[Answer]
# JavaScript
```
return (Do || !Do) || (there == !try);
```
```
return 2 * be || !(2 * be);
```
[Answer]
## R
```
the_whole <- c(-1,-1)
the_part <- -1
the_whole > sum(the_part,the_part)
```
-Socrates
[Answer]
## [Simply-Basic 84](http://timtechsoftware.com/?page_id=1274 "Simply-Basic 84")
```
Label 1;a random number between 0 and 1~should be stored in~A
If A is equal to 1 Then Display A End;Stop&Else,Go to label 1
:End; Otherwise destroy quantum transmitters internationally.
Since quantum transmitters are gone, power lost. KA-POW, yes?
```
[Answer]
# Prolog
```
waste(not).
want(X) :-
    waste(X).
```
[Answer]
**Python**
```
be = that = the = question = 1
2 - be or not 2 - be
that is the & question
```
[Answer]
**Ruby**
Not the most elegant solution, but very easy to read
```
def you_know_meaning(x) true end
!!!("aphorism" != "aphorism" unless you_know_meaning "aphorism")
=> true
```
]