Brainfuck је езотеричан програмски језик који је 1993. године направио Урбан Милер (нем. Urban Müller), а познат је по свом минимализму.
Име језика потиче од енглеске фразе "brainfuck", која се односи на ствар толико компликовану и необичну да превазилази границе разумевања. Име овог програмског језика се често за потребе правописа не третира као властита именица, већ је обичај да се пише великим почетним словом само у случајевима где би се и заједничка именица писала на тај начин (на пример, на почетку реченице).

Језик се састоји од само 8 једноставних команди и инструкционог показивача. Он не разликује типове података, већ све посматра као целе бројеве и подржава само две аритметичке операције, и то додавање јединице и одузимање јединице. Овакве инструкције у великој мери осликавају команде Тјурингове машине, те се лако доказује да је brainfuck Тјуринг-потпун и да може израчунати све што и класичнији програмски језици. Међутим, brainfuck од програмера захтева да подели команде на микроскопски ситне кораке и није намењен практичној употреби, већ као изазов за програмере.

Историја

1992. је швајцарски студент физике, Урбан Милер, преузео малу онлине архиву Амига софтвера.^[1] Архива је убрзо постала популарна и почела је да се шири свуда по свету. Данас је то највећа Amiga архива позната под именом Aminet. У овој архиви се појавила прва имплементација brainfuck језика.

Милер је дизајнирао brainfuck са циљем да га имплементира у облику најмањег могућег компајлера,^[2] инспирисан 1024-битним компајлером за FALSE програмски језик.^[3] Милеров оригинални компајлер је имплементиран у машинском језику и преведен је у бинарни фајл величине 296 бајта. Окачио је први brainfuck компајлер на Aminet 1993. године. Програм је долазио са 'readme' датотеком, која је укратко описивала језик и изазивала читаоца поруком: "Ко може испрограмирати било шта корисно овиме? :)". Милер је такође укључио и преводиоца и неке комплексније примере. Друга верзија компајлера је била још краћа и заузимала је само 240 бајта.^[4]

Како је Aminet растао, тако је компајлер постајао популаран широм Amiga заједнице и временом је имплементиран и на другим платформама. Временом је и писање најкраћег,^[5] али и најобимнијег^[6] интерпретера постало изазов за себе, тако да данас постоје бројне именоване и неименоване имплементације овог језика.

P", brainfuck-ов званични "родитељски" језик

Изузев своје две улазно-излазне команде, brainfuck је мала варијација програмског језика P'', који је направио Корадо Бом (ita. Corrado Böhm) 1964. године и који је експлицитно заснован на Тјуринговој машини. У ствари, користећи 6 симбола еквивалентних brainfuck наредбама +, -, <, >, [, ], Бом је пружио експлицитан програм за сваку од основних функција које заједно служе за израчунавање било које израчунљиве функције. Први програми у језику који се може сматрати brainfuck-овим родитељским језиком су се појавили у Бомовом раду из 1964. године и они су били довољни за доказивање Тјурингове потпуности.^[7]

The Infinite Abacus: Brainfuck-ов "пра-родитељски" језик

Јоаким Ламбек (eng. Joachim Lambek) је 1961. године представио "бесконачни абакус",^[8] математичку и рачунарску алатку са експлицитним меморијским адресирањем, без стека и без условног скока. Ова алатка се састоји од бесконачног броја ћелија и две инструкције:

• X+ = увећање ћелије X;

• X- else jump T = смањење X ако је тачно, иначе скочи на Т.

Доказао је да бесконачни абакус може израчунати било коју израчунљиву рекурзивну функцију, програмирањем Клинијевих основних μ-рекурзивних функција.

Његову машину симулирала је Мелзакова машина^[9] за израчунавање модела помоћу аритметике, а не логике која имитира оператера који помера облутке по абакусу. Овакав модел није могао да подржи рад са означеним бројевима, те отуда услов да сваки број мора бити позитиван. Мелзак, чији једноинструкцијски рачунар је очигледно еквивалентан бесконачном абакусу, даје програме за множење, проналажење највећег заједничког делиоца, н-тог простог броја, представљање у бази b и сортирање по величини. На овај начин је показано да и оваква машина може да симулира произвољну Тјурингову машину.

Не би било тешко заменити директно адресирану меморију стеком и двема инструкцијама < и > и тако добити језик који наличи brainfuck-у.

Дизајн језика

Brainfuck се састоји од осам команди, приказаних у табели испод. Један програм чини низ ових команди, које могу бити раздвојене произвољним карактерима. Произвољни карактери се игноришу, док се команде извршавају секвенцијално уз изузетке попут скокова који прескачу неки део кода или враћају инструкцијски показивач уназад. Инструкцијски показивач иницијално показује на прву команду, а свака команда на коју она указује се извршава, након чега се, осим у случају скокова, програм помера на следећу команду. Програм се прекида када се показивач помери иза последње команде.

Brainfuck користи једноставан машински модел који се састоји од програма и инструкцијског показивача, као и низа од најмање 30000 једнобајтних ћелија иницијализованих на нулу и покретног показивача података иницијализованог да показује на први (најлевљи) бајт низа. Овакав меморијски модел је користила оригинална имплементација, и дан данас је најчешће у употреби. Низ једнобајтних ћелија је еквивалент траци у Тјуринговој машини, при чему је највећа разлика то што Тјурингова машина има неограничен број ћелија на располагању. За улаз и излаз се користе два тока бајтова (најчешће повезаних са тастатуром и монитором, при чему се карактери кодирају у ASCII кодирању).

Команде

Осам команди brainfuck језика се састоје од по једног карактера:

(Алтернативно, ] наредба може бити преведена као безусловни скок на одговарајућу [ наредбу и обрнуто; програми ће имати исту функцију и понашати се идентично, али спорије, због непотребног двоструког претраживања.)

[ и ] се понашају као заграде: сваки [ одговара тачно једном ] и обрнуто. [ је увек прва и не може постојати неупарена [ или ] између ње и одговарајуће ].

Brainfuck програми могу бити преведени у C коришћењем следећих замена, под претпоставком да је ptr (од енг. pointer, у значењу показивач) типа char* и иницијално указује на низ анулираних бајтова:

char array[INFINITELY_LARGE_SIZE] = 0;
char *ptr=array;

++ptr;

--ptr;

++*ptr;

--*ptr;

putchar(*ptr);

*ptr=getchar();

while (*ptr) 

Као што само име сугерише, brainfuck програми су тешко разумљиви. Ово је делом зато што сваки мало комплекснији задатак захтева дугачак низ команди, а делом зато што текст програма не даје директне индикације стања програма. Ови разлози, као и неефикасност brainfuck језика и ограничене улазно-излазне могућности су су главни разлог зашто се језик не користи за озбиљније и комплексније програме. Без обзира на то, као и сваки Тјуринг-потпун језик, brainfuck у теорији може израчунати било коју израчунљиву функцију или симулирати било који рачунарски модел, ако му је дат приступ неограниченој количини меморије.^[10] Написани су разноврсни brainfuck програми.^[11] Иако су програми у овом језику тешки и за писање, посебно они комплекснији, тривијално је написати интерпретер или компајлер за овај језик у неком типичнијем језику, попут језика C, због једноставности самог језика. Постоје чак и преводиоци за овај језик који су писани у самом brainfuck језику.^[12]

Brainfuck је прави пример такозваног Тјуринг тарпита: може се користити за писање било којег програма, али није практично то учинити због тога што језик пружа само минимум могућности које су неопходне за Тјуринг-потпуност, али не и много простора за апстрактно размишљање и стога програми умеју бити изузетно дугачки и компликовани.

Примери

Hello World!

Следећи програм исписује "Hello World!" и нову линију на екрану:

[ Ovaj program ispisuje "Hello World!" i novu liniju na ekran. Njegova
 dužina je 106 (izvršenih) karaktera koji čine program.[Nije najkraći.]

 Ova petlja je "inicijalna petlja za komentare", jednostavan način za 
 dodavanje komentara BF programu tako da ne mora da se vodi računa o 
 komandnim karakterima. Svi ".", ",", "+", "-", "<" i ">" karakteri su 
 jednostavno ignorisani, a "[" i"]" karakteri samo treba da budu balansirani.
 Ova petlja i komande u njoj su ignorisane pošto je podrazumevana vrednost
 prve ćelije na koju pokazuje pokazivač podataka iznosi 0; 0 vrednost
 znači da se nikad ne ulazi u ovu petlju.
]
++++++++ Postavi Ćeliju #0 na 8
[
>++++ Dodaj 4 na Ćeliju #1; ovo će uvek postaviti Ćeliju #1 na 4
[ pošto se u petlji ova ćelija anulira
>++ Dodaj 2 na Ćeliju #2
>+++ Dodaj 3 na Ćeliju #3
>+++ Dodaj 3 na Ćeliju #4
>+ Dodaj 1 na Ćeliju #5
<<<<- Umanji za jedan brojač petlje u Ćeliji #1
] Vrti petlju dok Ćelija #1 nije 0; broj iteracija je 4
>+ Dodaj 1 u Ćeliju #2
>+ Dodaj 1 u Ćeliju #3
>- Oduzmi 1 od Ćelije #4
>>+ Dodaj 1 u Ćeliju #6
[<] Vrati se u prvu ćeliju koja je 0 na koju naiđeš; ovo
 će biti Ćelija #1 koja je anulirana u prethodnoj petlji
<- Umanji za jedan brojač petlje u Ćeliji #0
] Vrti petlji dok god Ćelija #0 nije 0; Broj iteracija je 8

Rezultat ovoga je:
Br Ćelije: 0 1 2 3 4 5 6
Sadržaj : 0 0 72 104 88 32 8
Pokazivač: ^

>>. Ćelija #2 ima vrednost 72 što je 'H'
>---. Oduzmi 3 od Ćelije #3 kako bi se dobilo 101 što je 'e'
+++++++..+++. Slično za 'llo' iz Ćelije #3
>>. Ćelija #5 je 32 što odgovara razmaku
<-. Oduzmi 1 od ćelije #4 kako bi se dobilo 87 što je 'W'
<. Ćelija #3 je bila postavljena na 'o' od poslednjeg slova 'Hello'
+++.------.--------. Ćeliju #3 koristimo za 'rl' i 'd'
>>+. Dodavanje 1 u Ćeliju #5 nam daje uzvičnik
>++. I konačno novi red iz Ćelije #6

Због читљивости, овај код је раширен на више линија и додате су празнине и коментари који објашњавају процес извршавања програма. Brainfuck игнорише све знакове, осим осам команди +, -, <, >, [, ], ., , тако да није потребна посебна синтакса за коментаре, све док сами коментари не садрже командне знакове. Као што је горе показано, и ово ограничење се може заобићи увођењем петље која се никад не извршава. Идентичан код се може записати и као:

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

Најкраћи познат програм који штампа "Hello, World!" броји 72 карактера и гласи:^[13]

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

ROT13

Овај програм шифрира свој улаз помоћу ROT13 шифре. Да би то урадио, мора мапирати карактере A-M (ASCII 65-77) до N-Z (78-90) и обрнуто. Такође мора да мапира и a-m (97-109) до (110-122) и обрнуто. Мора мапирати све остале карактере саме у себе; програм чита карактере једног по једног и исписује њихове шифроване еквиваленте док не прочита крај датотеке, и тада се завршава.

Једноставан приступ који се користи је следећи: учитавање улазног карактера xdisplaystyle x, дељење x−1displaystyle x-1 са 32, задржавајући количник и остатак. Осим ако је количник 2 или 3, излаз је xdisplaystyle x, задржавајући копију у току поделе. Ако је количник 2 или 3, остатак (((x−1)mod32displaystyle (x-1)mod 32) се дели са 13. Ако је количник 0, излаз је x+13displaystyle x+13; ако је 1, излаз је x−13displaystyle x-13; ако је 2, излаз је xdisplaystyle x.

Што се тиче алгоритма поделе, када се дели ydisplaystyle y са zdisplaystyle z да се добије количник qdisplaystyle q и остатак rdisplaystyle r, постоји спољна петља која прво поставља qdisplaystyle q и rdisplaystyle r на количник и остатак од 1zdisplaystyle frac 1z, затим на количник и остатак од 2zdisplaystyle frac 2z и тако даље. Након извршавања петље ydisplaystyle y пута, спољна петља се завршава и оставља qdisplaystyle q и rdisplaystyle r постављене на количник и остатак од yzdisplaystyle frac yz. Дељеник ydisplaystyle y се користи као бројач који се умањује и контролише колико пута се петља извршава. У оквиру петље, постоји код за повећање rdisplaystyle r и смањење ydisplaystyle y, што је углавном довољно. Међутим, сваки zdisplaystyle z-ти пут у спољној петљи, неопходно је да се анулира rdisplaystyle r и увећа qdisplaystyle q. То се постиже смањењем бројача тако да буде дељив са zdisplaystyle z. Сваки пут кад прође кроз спољну петљу, бројач се смањује, а када достигне нулу, попуњава се премештањем вредности rdisplaystyle r назад.

-,+[ Pročitaj prvi karakter i počni spoljnu petlju za čitanje karaktera
-[ Skoči unapred ako je karakter 0
>>++++[>++++++++<-] Postavi delilac (32) za petlju za deljenje
 (IZGLED MEMORIJE: deljenik kopija ostatak delilac količnik nula nula)
<+<-[ Postavi deljenik (x minus 1) i uđi u petlju za deljenje
>+>+>-[>>>] Uvećaj kopiju i ostatak / umanji delilac / Normalan slučaj: skoči unapred
<[[>+<-]>>+>] Specijalan slučaj: pomeri ostatak nazad do delioca i uvećaj količnik
<<<<<- Umanji deljenik
] Zavši petlju za deljenje
]>>>[-]+ Završi petlju za preskakanje; anuliraj mesto delioca i upotrebi mesto za zastavicu
>--[-[<->+++[-]]]<[ Anuliraj zastavicu osim ako je količnik bio 2 ili 3; anuliraj količnik; proveri zastavicu
++++++++++++<[ Ako je zastavica postavljena onda postavi delialc (13) za drugu petlju za deljenje
 (IZGLED MEMORIJE: nula kopija deljenik delilac ostatak količnik nula nula)
>-[>+>>] Umanji delilac; Normalan slučaj: uvećaj ostatak
>[+[<+>-]>+>>] Specijalan slučaj: uvećaj ostatak / pomeri ga nazad do delioca / uvećaj količnik
<<<<<- Umanji deljenik
] Završi petlju za deljenje
>>[<+>-] Dodaj ostatak nazad na deljenik da dobiješ korisnu 13-icu
>[ Skoči unapred ako je količnik bio 0
-[ Smanji količnik i skoči unapred ako je količnik bio 1
-<<[-]>> Anuliraj količnik i delilac ako je količnik bio 2
]<<[<<->>-]>> Anuliraj delilac i oduzmi 13 od kopije ako je količnik bio 1
]<<[<<+>>-] Anuliraj delilac i dodaj 13 na kopiju ako je količnik bio 0
] Završi spoljašnji niz za preskakanje (skoči ovde ako ((karakter minus 1)/32) nije 2 ili 3)
<[-] Anuliraj ostatak iz prvog deljenja ako je drugo deljenje bilo preskočeno
<.[-] Ispiši ROT13-ovan karakter iz kopije i anuliraj je
<-,+ Čitaj sledeći karakter
] Završi petlju za čitanje karaktera

Аритметичке операције

Додавање две вредности

Као једноставан пример, следећи део кода це додати вредност тренутне ћелије следећој ћелији. Сваки пут када се петља изврши, тренутна ћелија се смањује, показивач се помера у десну страну, а следећа ћелија се увећава и показивач се помера лево. Ова секвенца се понавља док почетна ћелија не буде 0.

[->+<]

Ово се може припојити једноставном програму за додавање на следећи начин:

++ Ćelija c0 = 2
>+++++ Ćelija c1 = 5

[ Počni petlju sa pokazivačem podataka na brojaču petlje (c1 u našem slučaju)
<+ Dodaj 1 na c0
>- Oduzmi 1 sa c1
] Završi petlju sa pokazivačem podataka na brojaču petlje
Primetimo da je petlja iznad ekvivalentna onoj datoj u prethodnom bloku koda

U ovom trenutku program je dodao 5 na 2 ostavljajući 7 u c0 i 0 u c1
ali ovu vrednost ne možemo ispisati na terminal pošto nije kodirana u ASCII-ju

Kako bismo prikazali ASCII karakter "7" moramo da dodamo vrednost 48 na vrednost 7
48 = 6 * 8 tako da koristimo još jednu petlju za množenje kako bismo skratili program

++++++++ c1 = 8 i ovo će biti naš brojač u petlji 
[
<++++++ Dodaj 6 na c0
>- Oduzmi 1 od c1
]
<. Ispiši c0 u kojoj je vrednost 55 što odgovara ASCII karakteru "7"!

Ovaj pristup štampanja funkcioniše samo za jednocifrene brojeve a 
generalizovan algoritam je dat ispod

Одузимање две вредности

Одузимање два броја се може имплементирати на сличан начин као и сабирање, само што се уместо повећавања поља резултата оно смањује. На пример, код који одузима тројку од петице може изгледати овако:

+++++ Postavi ćeliju 1 na 5 (umanjenik)
>+++ Postavi ćeliju 2 na 3 (umanjilac)
[ U petlju se ulazi na pokazivačem na drugu ćeliju
-< Smanji drugu ćeliju i pomeri pokazivač na prvu
-> Smanji prvu ćeliju i vrati pokazivač na drugu
] Ponavljaj sve dok druga ćelija nije 0
< Vrati pokazivač na prvu ćeliju (u kojoj je rezultat)

Множење две вредности

Множење два броја се може извршити као вишеструко сабирање. У свакој итерацији петље, један чинилац се смањује, а други повећава за константну вредност.

+++++ Postavi prvu ćeliju na 5 (činilac)
[
-> Smanji prvu ćeliju, prebaci pokazivač na drugu
+++ Dodaj tri na drugu ćeliju (drugi činilac)
< Vrati pokazivač na prvu ćeliju 
] Ponavljaj sve dok prva ćelija nije 0
> Postavi pokazivač na drugu ćeliju (u kojoj je rezultat)

Пошто brainfuck не подржава нумеричке литерале, сваку нетривијално малу вредности није практично добити као узастопно додавање јединице. Уместо тога, најчешће се користи алгоритам за множење сличан овом како би се од мањих вредности дошло до већих, на које се затим додаје нека мала вредност. ^[14]

Дељење две вредности

Логика иза дељења два броја је слична оној за множење. У свакој итерацији петље, од једног броја се одузима константна вредност, док се друга повећава за један, све док је прва вредност различита од нуле. Ова базична имплементација исправно ради само у имплементацијама чија је минимална вредност нула и не долази до поткорачења, или у случају да је дељеник дељив делиоцем.

++++++++++++ Postavi prvu ćeliju na 12 (deljenik)
[
--- Oduzmi 3 od prve ćelije (delilac)
>+ Pomeri pokazivač na drugu ćeliju i uvećaj je za jedan (količnik)
< Vrati pokazivač na prvu ćeliju
] Ponavljaj sve dok prva ćelija nije 0
> Pomeri pokazivač na drugu ćeliju (u kojoj je rezultat)

Штампање вредности

Brainfuck не разликује типове података, и при штампању већина имплементација штампа АСЦИИ карактер који одговара датој вредности. За једноцифрене бројеве, додавање константне вредности 48 (што је разлика између нумеричке вредности и АСЦИИ кода за ту цифру) као што је то урађено у примеру за сабирање је довољно. Међутим, када се штампају већи бројеви, ово није адекватно решење, већ се вишецифрен број мора делити са 10 и остатак при том дељењу чувати у засебним ћелијама, које се на крају исписују. Алгоритам који исписује број у ћелији на који показује показивач и користи ћелије десно од њега као "радну површину" је дат испод. Овај алгоритам функционише за све вредности, независно од величине ћелије.

[>>+>+<<<-]>>> Prvo kopiraj vrednost u radnu površinu i nazad
[<<<+>>>-]<<+>
[<->[ Dok god vrednost nije nula
>++++++++++< Napravi 10
[->-[>+>>]>[+[-<+>]>+>>]<<<<<] Podeli vrednost sa 10
>[-] Ova ćelija nam ne treba i postavljamo je na 0
++++++++[<++++++>-] Dodaj 48 na ostatak kako bi se dobila ASCII vrednost
>[<<+>>-] Sačuvaj ostatak
>[<<+>>-] Uzmi sledeću vrednost
<<
]>]
<[- Ako je ćelija prazna (nula) onda pravimo ASCII nulu (tj vrednost 48)
>>++++++++[<++++++>-]
]
<[.[-]<]< Odštampaj i anuliraj vrednosti ostataka (radnu površinu) u obrnutom redosledu

Проблеми са преносивошћу

До ових проблема долази делимично зато што Урбан Милер није написао темељну спецификацију језика, а делимично зато што многи каснији преводиоци и компилатори користе нешто другачије дијалекте програмског језика brainfuck.

Величина ћелије

У класичној верзији програмског језика, ћелије су широке 8 битова (ћелије су бајтови), што је и даље најчешћа величина. Међутим, да би се прочитали не-текстуални подаци, brainfuck треба да прави разлику између краја фајла (EOF карактера) од осталих уписаних вредности, због чега се користе 16-битне ћелије. Неке имплементације језика су користиле и 32-битне или 64-битне ћелије или ћелије арбитрарне величине (bignum). Програми који користе bignum ћелије су доста спорији, јер се чување неке вредности у ћелији врши у Ω(н) времену, што се брзо нагомила с обзиром на често извршавање + и - команди.

У свим овим варијантама, команде , и . и даље читају и пишу вредности у бајтове. У већини случајева ћелије могу да обухвате те вредности, а када се ћелија која има максималну вредност повећа (+ командом), у ћелију се смешта минимална вредност, и обратно. Изузеци су случајеви када се програм извршава на процесорима који интерно не користе потпуни комплемент што је у данашње време редак случај, имплементације које су одвојене од хардвера, имплементације које користе бигнуме и имплементације које акценат стављају на преносивости.

У већини случајева, прекорачење не представља велики проблем за brainfuck програмере. Међутим, пошто нема оператора поређења, програм не може направити разлику између означених и неозначених потпуних комплементата фиксне величине ћелије, нити на било који начин детектовати прекорачење. Такође, негативност броја може зависити од интерпретације бајта, што је често дефинисано имплементацијом.

Величина низа

У класичној дистрибуцији, низ се састоји од 30000 ћелија и показивач почиње на првој ћелији на левој страни низа. Више ћелија је потребно за уписивање ствари попут милионитог броја Фибоначијевог низа, а најлакши начин да се ово постигне и да језик остане Тјуринг-потпун је да се направи низ који је неограничен са десне стране.

Неколико имплементација^[15] проширују низ и са леве стране, али је ово ређа ситуација, стога преносиви brainfuck програми не зависе од тога.

Када се показивач помери изван граница низа, неке имплементације приказују поруку грешке, неке покушавају да динамички прошире низ, неке не примећују прекорачење и производе недефинисано понашање, док неке померају показивач на супротну страну низа. Компромис може бити проширење низа динамички у десну страну, као најлакши начин проширења низа и добро је за програме којима је потребна велика количина меморије, али ова опција вуче са собом казну у виду смањене брзине. Ако је коришћен низ фиксне величине, пожељно је изабрати врло велику величину низа.

Крај линије

Различити оперативни системи (а понекад и програмска окружења) другачије тумаче ASCII кодове. Најважнија разлика је у коду који се користи за крај реда и почетак нове линије текста. MS-DOS и Microsoft Windows користе CRLF, тј. 13 праћено са 10, у већини случајева. Unix и његови наследници (укључујући GNU/Linux и Mac OS X) и Amiga користе само 10, а старији Mac-ови користе само 13. Било би компликовано ако би brainfuck програми морали бити поново исписани на сваком од ових оперативних система. Међутим, лако је направити заједнички стандард за brainfuck програме. Урбан Милеров компајлер и његови примери програма користе 10 за улаз, као и за излаз. То прати и велика већина brainfuck програма, јер је 10 погодније за коришћење од CRLF-а. Дакле, brainfuck имплементације треба да се увере да brainfuck програми подразумевају да нова линија има вредност 10 и да то исправно ради, што многе и чине.

Ова претпоставка је присутна у већини узорака C кода као и других језика, где се користи "n" или 10 за нови ред. На системима који користе CRLF крај линије, стандард је да се замени "n" са "rn" на излазу и "rn" са "n" на улазу за токове који нису отворени у бинарном моду.

Крај датотеке

Понашање команде , на крају датотеке варира. Неке имплементације постављају вредност ћелије и показивач на 0, неке постављају на вредност ЕОФ константе у C-у (у пракси је то углавном -1), неке оставе вредност непромењену. Нема сагласности око коришћења датих опција, па постоје аргументи за сваку од њих:

Стављање вредности на 0 избегава косришћење негативних бројева и сажетије је направити петља која се извршава док не дође до краја датотеке. Ово проширење у језику је осмислио Пану Калиокоски (eng. Panu Kalliokoski).

Стављање вредности на -1 дозвољава крају датотеке да буде различит од било које вредности бајта (ако су ћелије веће од бајтова), што је неопходно за читање не-текстуалних података. Такође, то је понашање C превода , команде, дате у Милеровој readme датотеци. Ипак, није очигледно да се ови C преводи узму као норма.

Немењање вредности ћелије је понашање Милеровог компајлера. Ово понашање може постојати уз било које друго понашање. На пример, програм који подразумева да је крај датотеке једнак нули може да стави вредност ћелије на 0 пре сваке , команде и то ће исправно радити на имплементацијама које подразумевају да је крај датотеке једнак нули или да је крај датотеке непромењен. Лако је прилагодити се непромењеном крају датотеке и сваки brainfuck програмер заинтересован за преносивост програма би требало то да ради.

Имплементације

Једноставност brainfuck-а га чини популарном метом за многе различите имплементације.^[5] Сем оригиналне имплементације за Амигу коју је написао Урбан Милер, постоји преко сто различитих компајлера и интерпретера.^[16] Имплементације се крећу од изузетно малих као што су BF6502A2, интерпретер дугачак 135 бајтова за Аппле ][ //е,^[17] и bf core, који се састоји од 69 бајтова x86 асемблерског кода,^[18] па до оптимизујућих компајлера као што су bfc, који се ослања на LLVM и подржава оптимизације као што су спајање наредби, поједностављавање петљи, елиминисање мртвог кода, спекулативно извршавање и др,^[19] и awib, који подржава превођење до више различитих језика, и сам је писан у brainfuck-у.^[20]

Постоје и имплементације писане за платформе које нису у широј употреби. Тако је iHeadAche brainfuck интерпретер за Palm OS,^[21] zxBrainfuck писан у Z80 асемблеру са ZX Spectrum ^[22] или BrainfuckCE који је намењен TI 84+ CE калкулаторима.^[23] Хардверске имплементације овог језика укључују The Brainf*ck CPU Project, VHDL имплементација brainfuck CPU-а,^[24] TinyDumbCPU, SystemVerilog brainfuck језгро ^[25] и The Brainfuck Computer, који представља мали brainfuck интерпретер нарезан на ROM PIC16F84A микроконтролера.^[26]

Деривати и проширења

Стварање језика сличних или у великој мери инспирисаних brainfuck-ом се показало као интересантан изазов програмерима. I док је некима циљ искључиво забава, други овај језик надограђују бројним механизмима позајмљеним од класичнијих програмских језика.

Еквиваленти

Постоји широк спектар brainfuck еквивалената, који имају идентичне команде као brainfuck, али се различито кодирају, са или без улазно-излазних команди које овај језик поседује. Ова фамилија броји преко 50 различитих програмских језика.^[27][28] Неки од популарнијих су:

• 
  Ook!, који мапира осам команди brainfuck-а у пермутације дужине два речи "Оок.", "Оок?" и "Оок!". По речима аутора, дизајниран је тако да могу да га "пишу и читају орангутани".^[29] Један је од најстаријих у низу сличних brainfuck еквивалената.^[30]


• 
  Ternary и Triplet који brainfuck команде кодирају, редом, у парове тернарних^[31] и триплете бинарних^[32] цифара.


• 
  VerboseFuck који изгледа као традиционалан програмски језик, али се у ствари састоји од осам дугачких команди које личе на позиве методама и не могу се мењати, и захтева непроменљив блок кода на почетку и на крају програма. ^[33]


• 
  BodyFuck, brainfuck имплементација базирана на систему контролисаном покретима, тако да камера снима покрете програмера и снимак се кодира у осам могућих карактера.^[34]

Проширења

Са својих скромних осам инструкција, иако је Тјуринг-потпун, brainfuck не имплементира многе могућности које програмери могу пожелети. Стога, постоје варијације овог језика које користе изворних осам инструкција, и додају још неке.

• 
  pbrain додаје могућност писања процедура које се могу позивати из brainfuck кода.^[35]


• 
  cbrain је екстензија pbrain-а која додаје нумеричке литерале и бројне операторе.^[36]


• 
  Brainfork подржава креирање нових нити и конкурентно програмирање.^[37]


• 
  Hq9eFuck комбинује инструкције brainfuck-а и HQ9+-а у један језик, и додаје команду Дубока мисао која рачуна и исписује одговор на Питање о животу, васељени и свему осталом, што је референца на Аутостоперски водич кроз галаксију. ^[38]

Деривати

Brainfuck је такође инспирисао многе да направе своје језике који га на неки начин унапређују или га мењају по узору на могућности других језика. За разлику од једноставних проширења које на осам постојећих додају нове команде, програмски језици из ове групе позајмљују идеје и концепте, али не нужно и синтаксу и лексику од brainfuck-а. Постоји преко 200 различитих деривата овог језика.^[39] Неки од њих су:

• 
  PATH^[40], SNUSP^[41] и Wierd^[42] комбинују команде brainfuck-а са дводимензионом природом Befunge-а.


• 
  Mice in a maze комбинује инструкције brainfuck-а са теоријом ћелијских аутомата, и у њему програм се састоји од лавиринта кроз који пролазе (хипотетички) мишеви, извршавајући команде које им се нађу на путу.^[43]


• 
  Smallfuck^[44], Boolfuck^[45] и Bitter ^[46] су варијације brainfuck-а које као ћелије уместо бајтова користе битове. Bitter такође дефинише и две опционе команде за интерпретер, које помажу при дебаговању програма.

Изузетна непрактичност имплементације или неистражена природа физичке реалности нису спречиле програмере да напишу спецификације најразличитијих деривата овог језика. Тако постоји и Quantum brainfuck који уместо бајтова користи кубите,^[47] и Wigner's Fuckbuddy Is A (|Top⟩ + |Bottom⟩)/√2 који претпоставља да је интерпретација квантне механике Хјуа Еверета (тзв. интерпретација више светова или теорија мултиверзума) тачна и да се универзуми могу манипулисати.^[48] Како је и сам brainfuck настао као облик забаве међу програмерима, тако ове практично немогуће спецификације одлазе корак даље и кроз хумор уводе нове, фиктивне, програмске језике кроз наизглед озбиљне и компликоване физичке концепте.

Види још

• 
  Езотерични програмски језици – примери других езотеричних језика и саме парадигме


• 
  Тјурингова машина – теоријски концепт централан за рачунарство од кога brainfuck позајмљује неке концепте (најзначајније, појам траке која чини меморију brainfuck програма)

Референце

Спољашње везе

• Оригинална имплементација brainfuck-а на AmiNet архиви