Easier communication means faster coding means fewer coders means …

Question

My father who was a really good APLer and taught me all the basics of APL (and much more), passed away on this day, five years ago. In preparation for 50 Years of APL, I found this patent letter (translated for the convenience of those who do not read Danish) for a handwritten logo. It explains a major reason for APL never gaining a large user base – a reason which of course applies to all of this community's amazing golfing languages too:

---

A 3497/77                           Req. 29^th Aug. 1977 at 13

Henri Brudzewsky, engineering consultancy company, Mindevej 28, Søborg,

class 9, including computers, especially APL coded computers,
class 42: IT service agency company, especially during use of APL coded computers.

---

Task

Produce infinitely repeating output of the text EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS with no newlines. You may begin the text with EASIER or FASTER or FEWER.

Answer 1

05AB1E, 25 bytes

[‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘?

Try it online!

Explanation:

[‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘?
[                         Start infinite loop
 ‘æƒËRSˆ¾¥ƒŽÁˆ¾¡ŸÂ ‘   Push the compressed string in uppercase, starting from FEWER, with a trailing space
                        ?  Print without trailing newline

Answer 2

SVG(HTML5), 336 bytes

<svg width=500 height=500><defs><path id=p d=M49,250a201,201,0,0,1,402,0a201,201,0,0,1,-402,0></defs><text font-size="32"><textPath xlink:href=#p>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS</textPath><animateTransform attributeName=transform type=rotate from=360,250,250 to=0,250,250 dur=9s repeatCount=indefinite>

Edit: Some people have found that the font doesn't quite fit for them so here is a version that allows you a few pixels of adjustment:

<p><input type=number value=0 min=0 max=9 oninput=p.setAttribute('d','M250,250m20_,0a20_,20_,0,1,1,-20_,-20_a20_,20_,0,1,1,-20_,20_a20_,20_,0,1,1,20_,20_a20_,20_,0,1,1,20_,-20_'.replace(/_/g,this.value))></p>
<svg width=500 height=500><defs><path id=p d=M250,250m200,0a200,200,0,1,1,-200,-200a200,200,0,1,1,-200,200a200,200,0,1,1,200,200a200,200,0,1,1,200,-200></defs><text font-size="32"><textPath xlink:href=#p>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS</textPath><animateTransform attributeName=transform type=rotate from=360,250,250 to=0,250,250 dur=9s repeatCount=indefinite>

Answer 3

PHP, 76 Bytes

for(;;)echo strtr(EASI0MMUNICATION1FAST0DING1FEW0DERS1,["ER CO"," MEANS "]);

Try it online!

Answer 4

Vim 69 bytes

qqAFEWER CODERS MEANS EASIER COMMUNICATION M<C-n> FASTER CODING M<C-n> <esc>@qq@q

Answer 5

HTML, 122 bytes.

Sorry, can't help myself.

<marquee style="width:5em;word-spacing:5em;">EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS </marquee>

Answer 6

Python 2, 82 81 bytes

-1 byte thanks to Leaky Nun.

I'm probably doing something wrong but it's really late so meh. Note the trailing comma.

while 1:print'FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS',

Try it online!

Another solution, 85 bytes

I can probably golf this further.

while 1:print'%sER CO%s MEANS'*3%('FEW','DERS',' EASI','MMUNICATION',' FAST','DING'),

Try it online!

Answer 7

Jelly, 33 29 bytes

4 bytes thanks to Erik the Outgolfer.

“©%5ÐƬwȮh¬Þ6.⁷ḷḊḥṫɠlḶṀġß»Œu⁶¢

Try it online!

Answer 8

Brachylog, 70 bytes

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "w↰

Try it online!

How it works

"..."w↰
"..."     generate the string "..."
     w    print to STDOUT without trailing newline
      ↰   do the whole thing all over again

Answer 9

HTML/CSS (firefox only), 179 177 183 176 173 bytes

<b id=a>EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS </b>E<a><style>*{margin:0;}a{position:fixed;left:0;right:0;height:1em;background:-moz-element(#a)}

Certianly nowhere near the lowest scores, I just thought it would be fun to get infinite repitition in HTML/CSS, without any JS involved :)

Changelog:

• Removed quotes around id attribute
• added "round" background-repeat to stretch the text so it wraps correctly
• changed to single-line output
• replace width:100% style with right:0 to save 3 bytes

Answer 10

Python 3, 87 bytes

while 1:print(end="FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ")

Try it online!

Answer 11

C (gcc), 92 bytes

main(){for(;printf("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "););}

Try it online!

Answer 12

LOLCODE, 116 bytes

HAI 1
IM IN YR O
VISIBLE "FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "!
IM OUTTA YR O
KTHXBYE

Try it online!

Answer 13

Ruby, 77 bytes

assigning " MEANS " to a variable saved all of 1 byte :-)

loop{$><<"EASIER COMMUNICATION#{m=" MEANS "}FASTER CODING#{m}FEWER CODERS"+m}

Answer 14

JavaScript (ES6), 90 87 bytes

while(1)console.log`EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS `

---

Functioning Alternative, 100 bytes

"Functioning" here meaning "won't crash your browser" (for a while, at least)!

setInterval(_=>console.log`EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS `,1)

Answer 15

Befunge, 73 bytes

" SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF">:#,_

Try it online!

Answer 16

Octave, 86 bytes

while fprintf('FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ')end

Explanation:

This is fairly self-explanatory. The only real "trick" here is to use while fprintf. When fprintf is given a return argument, it will return the number of characters printed, and all non-zero numbers are considered true in Octave, so the loop condition will always be true.

---

I desperately tried to make the more interesting approach shorter, but it turned out to be 9 bytes longer, unfortunately:

while fprintf('FEW%sDERS%sEASI%sMMUNICATION%sFAST%sDING%s',{'ER CO',' MEANS '}{'ababab'-96})end

This tries to insert the strings 'ER CO' and ' MEANS' into the string at the correct locations, using direct indexing where 'ababab'-96 is a shorter version of [1 2 1 2 1 2].

This was a bit shorter (93 bytes), but still longer than the naive approach

while fprintf('FEWER CODERS%sEASIER COMMUNICATION%sFASTER CODING%s',{' MEANS '}{[1,1,1]})end

And another one (89 bytes), using Level River St's approach:

while fprintf(['FEWER CODERS',s=' MEANS ','EASIER COMMUNIDATION',s,'FASTER CODING',s])end

This should work in theory, for one less byte than the original solution, but it fails for some strange reason:

while fprintf"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "
end

This uses the buggy feature that fprintf('abc def') is equivalent to fprintf"abc def". The end must be on the next line, but it's still one byte shorter since two parentheses are skipped.

And one more for 87:

while fprintf('FEWER CODERS%sEASIER COMMUNICATION%sFASTER CODING%s',k=' MEANS ',k,k)end

---

Well, don't say I didn't try :)

Answer 17

Alice, 70 bytes

" SNAEM "k"SREDOC REWEF"e0j"GNIDOC RETSAF"e0j"NOITACINUMMOC REISAE"d&o

Try it online!

Explanation

Unfortunately, reusing the MEANS (with spaces) only saves a single byte over just printing the whole thing in one go. Consequently, extracting the ER CO would actually cost a byte (or probably more, because it would be slightly more expensive to extract another section).

" SNAEM "                Push the code points of " MEANS " in reverse.
k                        If there is a return address on the return address stack (which
                         there isn't right now), pop it and jump there.
"SREDOC REWEF"           Push the code points of "FEWER CODERS" in reverse.
e0j                      Jump to the beginning of the line, pushing the location of the
                         j to the return address stack. Hence, we push the code points
                         of " MEANS " again, but then the k pops the return address and
                         jumps back here.
"GNIDOC RETSAF"          Push the code points of "FASTER CODING" in reverse.
e0j                      Jump to the beginning of the line again.
"NOITACINUMMOC REISAE"   Push the code points of "EASIER COMMUNICATION" in reverse.
d                        Push the stack depth.
&o                       Print that many bytes from the top of the stack.
                         Afterwards the IP wraps around to the first column and the
                         program starts over.

Answer 18

C#, 102 bytes

_=>{for(;;)System.Console.Write("EASIER COMMUNICATION{0}FASTER CODING{0}FEWER CODERS{0}"," MEANS ");};

Answer 19

Pyth, 69 bytes

Wp"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS 

Try it online!

How it works

Wp"...
W       while the following is true: (do nothing)
 p      print the following and return the following
  "...

Answer 20

Lua, 92 bytes

while 1 do io.write("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ")end

Try it online!

Answer 21

Java (OpenJDK 9), 114 bytes

static void f(){while(1>0)System.out.print("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ");}

Try it online! Stop the execution after a few seconds because it does not know when to stop.

Answer 22

C, 86 bytes

f(){printf("FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS ");f();}

See it work online.

Answer 23

bc, 76 bytes

while(1)"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "

Answer 24

MATL, 68 bytes

`'EASIER COMMUNICATION*FASTER CODING*FEWER CODERS*'42' MEANS 'Zt&YDT

Try it online!

Explanation

`                                                     % Do...while
  'EASIER COMMUNICATION*FASTER CODING*FEWER CODERS*'  %   Push this string
  42                                                  %   Push 42 (ASCII for '*')
  ' MEANS '                                           %   Push this string  
  Zt                                                  %   String replacement
  &YD                                                 %   printf to STDOUT
  T                                                   %   Push true as loop condition
                                                      % End (implicit)

Answer 25

Perl 6,  81 80  79 bytes

print ('EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS'),' 'for ^Inf

Try it

loop {print ('EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS'),' '}

Try it

loop {print [~] 'EASIER COMMUNICATION','FASTER CODING','FEWER CODERS'X'MEANS '}

Try it

Answer 26

Axiom, 92 89 bytes

repeat fortranLiteral"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "

insert in one line to Axiom window. Possible there is one function shorter than "fortranLiteral" that not write "\n"

Answer 27

Braingolf, 78 bytes

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "[!@66<1+>]

or

Braingolf, 77 bytes [non-competing]

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "[!&@<1+>]

This one's non-competing as I had to fix 2 bugs regarding using the greedy modifier (&) with the char print operator (@)

Answer 28

Blank, 267 bytes

[70][69][87][69][82][32][67][79][68][69][82][83][32][77][69][65][78][83][32][69][65][83][73][69][82][32][67][79][77][77][85][78][73][67][65][84][73][79][78][32][77][69][65][78][83][32][70][65][83][84][69][82][32][67][79][68][73][78][71][32][77][69][65][78][83][32]{p}

Pushes FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS to the stack, then prints it. Never terminates as no {@}

Also fun fact, I used the following Braingolf script to generate this code

"FEWER CODERS MEANS EASIER COMMUNICATION MEANS FASTER CODING MEANS "l>[<$_<91+2^9-@_ 91+2^7-@l>]"{p}"@3

Answer 29

PowerShell, 100 97 bytes

for(){"EASIER COMMUNICATION","FASTER CODING","FEWER CODERS"|%{Write-Host -NoNewLine "$_ MEANS "}}

Try it online!

---

Older answer:

PowerShell, 100 bytes

while(1){"EASIER COMMUNICATION","FASTER CODING","FEWER CODERS"|%{Write-Host -NoNewLine "$_ MEANS "}}

Try it online!

PowerShell is a little tricky for this because most dignified ways of outputting to the console also insert a new line. Write-Host is required because of this. However, it still demonstrates how pipelining can shorten the coding footprint.

You will need to stop the execution after a short time because it will not return as it is an infinite loop.

Edit: shaved off 3 bytes by changing a while loop to a for loop.

Answer 30

Groovy 79 bytes

m=" MEANS";for(;;)print"EASIER COMMUNICATION$m FASTER CODING$m FEWER CODERS$m "

Uses groovy's string interpolation.

Answer 31

AWK, 85 bytes

BEGIN{for(c=" MEANS ";;)printf"EASIER COMMUNICATION"c"FASTER CODING"c"FEWER CODERS"c}

Try it online!

Apparently I came up with the same shortcut as others. All other substitutions take up too much space. :(

Answer 32

Ly, 75 bytes

1[p"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "&o1]

Try it online!

Explanation:

1[p                                                                      1] # infinitely
   "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "&o   # print the string

Answer 33

C# (.NET Core), 125 bytes

class c{static void Main(){for(;;)System.Console.Write("EASIER COMMUNICATION{0}FASTER CODING{0}FEWER CODERS{0}"," MEANS ");}}

This is a full program rather than just a function like the other C# answer.

Test online

Answer 34

Keg, 69 bytes

{ SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF(,

Explanation:

{#                                                                     Infinite loop
  SNAEM GNIDOC RETSAF SNAEM NOITACINUMMOC REISAE SNAEM SREDOC REWEF#   Pushing the string reversed
                                                                   (, #And outputting it reversed

TIO

Answer 35

Retina, 64 60 bytes

+>(`$
EASI_MMUNICATION@FAST_DING@FEW_DERS@
@
 MEANS 
_
ER CO

Try it online!

Explanation

The program consists of three grouped replacement stages. The group as a whole is applied repeatedly until the output stops changing (which it never will) and the output is printed after each time (rather than just at the end, because there will be no end)

The first stage adds the string EASI_MMUNICATION@FAST_DING@FEW_DERS@ at the end of the input. The input starts out empty, but keeps growing.

The second stage replaces each of those @s with the string MEANS (surrounded by a space on each side).

The third stage replaces the _s with the string ER CO.

Answer 36

Hexadecimal Stacking Pseudo-Assembly Language, 810 bytes

00000020002040000020005340000020004E40000020004140000020004540000020004D40000020002040000020005340000020005240000020004540000020004440000020004F40000020004340000020002040000020005240000020004540000020005740000020004540000020004640000020002040000020005340000020004E40000020004140000020004540000020004D40000020002040000020004740000020004E40000020004940000020004440000020004F40000020004340000020002040000020005240000020004540000020005440000020005340000020004140000020004640000020002040000020005340000020004E40000020004140000020004540000020004D40000020002040000020004E40000020004F40000020004940000020005440000020004140000020004340000020004940000020004E40000020005540000020004D40000020004D40000020004F400000200043400000200020400000200052400000200045400000200049400000200053400000200041400000200045400000140000010000

Try it online!

000000  Label Start:
200020
400000
.
.
.       push letters
140000  print string
010000  jump to start

Answer 37

Whitespace, 415 bytes

(much whitespace)

Try it online!

lssl        label start:
sssttssssstsststtsttstsststttsstttsstsstttssstsssttttsttttsttttsttttsststttsstssststtssssstttsttttsstssttsttssttsttsstsssstssttssssssttttttstttsttsttsttstsstssssssttssststttssttttttstttstssssssttsssttsssssttssttsststttstttttttstststsstsssstttstsstsssstsssstttstttsststsssstssssttttstttssstttssttssstsssstssl
            push base 24 sentence "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "
lsssl       label print:
sssttsssl   24
stsstl      copy 1
stsstl      copy 1
tstt        mod
ssststttl   23
tsst        sub
lsl         dup
ltstl       jz space
ssstttsssl  push 56
tsss        add
lsstl       label space:
ssstsssssl  push 32
tsss        add
tlss        printc
tsts        div
sls         dup
ltsl        jz start
lslsl       jump print

Answer 38

Tcl, 94 bytes

while 1 {puts -nonewline "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "}

Try it online!

Answer 39

Bash 68 bytes

f()(printf "%sER CO%s MEANS " EASI MMUNICATION FAST DING FEW DERS;f)

Try it online

Answer 40

brainfuck, 657 bytes

+[++++[++++>---<]>++.----.>-[--->+<]>--.----------.----.+++++++++++++.--[----->++<]>.+[->++<]>+.[->+++++<]>.--..++++++++.-------.-----.------.--.>-[--->+<]>-.-----------.++++++.-.++[----->++<]>.++++++[->++<]>+.--------.----.+++++++++++++.+++++.+[--->+<]>++++.+++[->++<]>.-----.>-[--->+<]>--.+.[----->+<]>+.+++++++++++++.--[----->++<]>.+[->++<]>+.[->+++++<]>.-----------.+++++.+++++.-------.+[->++++<]>.++++++[->++<]>+.--------.----.+++++++++++++.+++++.+[--->+<]>++++.+++[->++<]>.-.>+[--->++<]>+.++[----->+<]>.+++++++++++++.--[----->++<]>.+[->++<]>+.[->+++++<]>.-----------.+.+++++++++++++.+.+[--->+<]>++++.++++++[->++<]>+.--------.----.+++++++++++++.+++++.]

Try it online!

Answer 41

APL NARS, 152 bytes, 76 chars

f
A:⍞←'EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS '⋄→A

I don't know if there are some leak or the buffer for output is buffered in a way increase its size. Possible i see it wrong but it seems that the size mem in NARS increase, and afther some second the output of the line disappear.

Answer 42

MathGolf, 74 bytes

1{"EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "_q}∟

Try it online!

Explantion:

1                                                                          Loop condition
 {                                                                         Start block
  "EASIER COMMUNICATION MEANS FASTER CODING MEANS FEWER CODERS MEANS "_q   Output the string
                                                                        }∟ Do without popping