Lambda

Megfelelő fejlesztőkörnyezet keresése közben egy problémába, legalábbis annak látszó dologba ütköztem. Minden elérhető forrás az Emacs használatát javasolta. Erről tudni kell, hogy egyike azon szoftvereknek, amelyek kettéosztják a világot (a másik tudtommal a vi). Vannak, akik rajongásig szeretik és vannak akik szenvedélyesen utálják. Én az utóbbi csoportba tartoztam (a vi-t illetően pedig az azt szeretők közé).

Próbáltam más utat keresni (átmenetileg találtam is), de a végső megoldás mégis az Emacs lett. Hogy miért? A Slime nevű pluginje miatt, amelyet kifejezetten Lisp-pel való munkához fejlesztettek.

A Slime a következők miatt látszott (és bizonyult) jó választásnak:

• szokásos fejlesztőeszköz-funkciókat tudja (segítség a parancsoknál, debugger, fordítási hibaüzenetek forráshoz kötése)
• kapcsolódás távoli Lisp szerverhez
• távoli REPL használata
• azonnali kód-kiértékelés és -fordítás, távoli szerverre is
• távoli fájlszerkesztés és betöltés

Ez persze nem látszott az elején, sokat kellett kísérletezni hozzá, hogy megértsem az utolsó kettőt például. A távoli fájl- és kódműveleteket úgy kell elképzelni, hogy fut a program a szerveren, változtatsz valamit a kódon, majd egy billentyűparanccsal a kód bekerül a szerverre, lecserélve az ott futó kódrészt. Nincs leállítás, megszakadás, stb, a felhasználó következő kérését az új kód fogja kiszolgálni.

Ezért hát rászántam magam és feltettem az otthoni gépemre az Emacs-ot, Ubuntu alatt egyszerűen az sudo apt-get install emacs22 paranccsal. Emacsból egyébként több is van, a két legelterjedtebb a GNU Emacs és az XEmacs. Közös eredettel büszkélkedhetnek, ám egyszer különváltak. Az utóbbi nevében az X nem a Unix-rendszerek grafikus felületére utal, mindkét változatnak van grafikus felülete. Én a GNU Emacs-ot választottam.

Kell még hozzá egy Slime, ha már ennyire áradoztam róla. Ez általában megtalálható a Linux disztribúciókban, ám a Slime-nak van olyan kényes tulajdonsága, hogy azonos verziók szeretnek együttműködni. Azaz ugyanazt kell feltennünk a kliens oldalra, ami a szerveren fut. A szerveren pedig CVS-ből jön a kód, így a kliensen ugyanígy kell tennünk a következő paranccsal:

cvs -d :pserver:anonymous:anonymous@common-lisp.net:/project/slime/cvsroot co slime

Ezt valami olyan könyvtárban add ki, ahol a Lisp-es fejlesztési cuccokat gyűjtöd. Aztán adjuk meg az Emacs-nak, hogy hol keresse. Ehhez hozd létre a saját könyvtáradban a ~/emacs.d/slime.el fájlt valamilyen szerkesztővel, a következő tartalommal (a pontosvesszővel kezdődő sorok a megjegyzések):

; hol találja a Slime-ot:
(add-to-list 'load-path "/home/user/lisp/slime/")
; töltse is be azt:
(require 'slime)

(add-hook 'lisp-mode-hook (lambda () (slime-mode t)))
(add-hook 'inferior-lisp-mode-hook (lambda () (inferior-slime-mode t)))
; mit indítson, ha a kliensgépen levő Lisp kell
(setq inferior-lisp-program "/usr/bin/sbcl"
      ; kezdeti behúzás változtatása
      lisp-indent-function 'common-lisp-indent-function
      slime-compile-symbol-function 'slime-fuzzy-complete-symbol
      ; hyperspec dokumentáció
      common-lisp-hyperspec-root "file:///home/user/lisp/HyperSpec/"
      slime-startup-animation t)
; így induljon el a Slime: kérünk REPL-t
(slime-setup '(slime-repl))

Ezután egyelőre nincs más dolgunk, mint elindítani az Emacs-ot. Fontos: kilépni a Ctrl-X Ctrl-C billentyűparancsok egymás utáni kiadásával lehet! Ha elindul hibák nélkül, akkor jól csináltuk a dolgunkat, legközelebb folytatjuk.

Múltkor ott hajítottuk el a fonalat, hogy van egy feltelepített, de ki nem próbált Lisp-ünk az SBCL képében. Itt az ideje, hogy ki is próbáljuk. Egyik egyszerű módja a clbuild-del történik (ha már fent van): ./clbuild lisp. Némi szöveg után egy barátságos csillagot kell kapnunk (ez a REPL, amiről majd máskor szólok), ahova már Lisp utasításokat lehet írni. Most egyelőre nyugodjunk meg annyiban, hogy elindult, és közöljük vele, hogy (quit) -- a zárójelekkel együtt, mire illemtudóan kilép.

Három alapozó feladatunk van még hátra a kiváló webes alkalmazás létrehozásához:

1. webes környezet összerakása
2. fejlesztőkörnyezet és tartozékai
3. megtanulni a nyelvet :)

Ma a webes környezetet rakjuk össze.

Lisp-ünkhöz nem létezik a klasszikus értelemben vett webes keretrendszer, mint például a Ruby on Rails vagy a CakePHP. Ez nem azt jelenti, hogy a választott környezetünk gagyi, hanem jobbára azt, hogy nincs rá ilyen formában szükség.

Ahogy körülnéztem, két gyakrabban használt keretrendszert találtam, az UnCommon Web (UCW) és a Weblocks nevezetűt. Mindkettő elég elriasztó elsőre, és mindegyiknél a kulcsszó a "continuation", amitől majd egy későbbi írásban fogok szót ejteni (már írnom kell külön, hogy miket halasztok későbbre, szóval ne aggódj, tényleg fogok róla írni). Az elérhető források alapján úgy döntöttem, hogy elsőnek az UCW-vel fogok megismerkedni, mert ez tűnt kiforrottabbnak és szélesebb körben használtnak. Van benne egy alap webszerver is, ami jól is fog jönni. Van ezen kívül más út is, amit majd máskor részletezek :)

Szóval kedvenc szerverünkön tartózkodva adjuk ki ezt a parancsot: ./clbuild install ucw. Ez letölti és helyére rakja az UCW-t és a függőségeit is, és már csak ezért hálát adhatunk, hogy a clbuild-et kitalálta valaki. Persze a világ nem tökéletes, és nálam hiányolta még a closer-mop csomagot, ezért ha ezt nem láttad a felrakottak között, célszerű telepíteni a ./clbuild install closer-mop paranccsal (közben persze lehet hogy javították a clbuild-et). Hasonlóképpen vegyük magunkhoz a puri és az rfc2388-binary csomagokat: ./clbuild install puri, ./clbuild install rfc2388-binary. Ezeket majd a futtatandó példaprogram igényli.

Indítsuk el a Lisp-ünket a ./clbuild lisp paranccsal, majd közöljük vele, hogy (require 'ucw) (figyelj az aposztrófra az ucw előtt!). Ezen remélhetőleg nem sértődik meg és jó hosszan írogat amint fordítja az egyes programokat. Ha visszakapod a csillagot, akkor rendben ment minden. Ha nem, akkor kérdezni fog valamit, ami általában valamilyen csomag hiányára utal. Próbáld meg kideríteni a szövegből, hogy mi lehet az a csomag (esetleg másold be az egészet ide kommentbe), kérd meg a clbuild-et, hogy telepítse és próbáld újra.

Ha az első megpróbáltatáson túl vagyunk, töltsük be a példaprogramot. Erre való a (load "/eleresi/utvonal/fajl.lisp") parancs. A (load "/home/bkovacs/clbuild/source/ucw/manual/example-code.lisp") nálam betölti a példaprogramot. Persze a fájl elérési útvonalát cseréld le a nálad létezőre. FRISSÍTÉS: egy openvz alapú minimál-szerveren furcsa fordítási hibákkal elszállt a betöltés. Kinyomoztam, hogy egyrészt kell neki GCC, másrészt pedig a libc6-dev (vagy ezzel megegyező, libc6 fejlesztéshez szükséges) csomagot kell feltenni. Az ilyen munkához ajánlom a Linux screen programját (igény szerint erről is írok). Ha itt is visszakaptad a csillagot, akkor a neheze megvan. Ezután el kell indítani a példa szervert a (ucw-user:start-example-server) paranccsal. Ez először kérdez, mert a start-example-server nincs exportálva a ucw-user csomagból, erre 0-t nyomva (continue) továbbmegy és elindul a szerver. A logja a Lisp ablakában látszik, minden művelet itt fog zajlani. Nézd is meg, hogy melyik porton indult el a webszerver. Az alábbi sor végén látszik, hogy nálam a 8000-es portot használja.

00:40          UCW INFO    Started standard-server #<STANDARD-SERVER IT.BESE.UCW.CORE:HTTPD-BACKEND 1 {C410B89}> with backend #<HTTPD-BACKEND :host 0.0.0.0 :port 8000 {C42B019}>A teszteléshez írd be a böngésződbe a http://localhost:8000 (illetve a 8000 helyett azt a portot, amelyen nálad elindult) címet és szokatlan hibaüzenetet kell kapnod.

The page you requested was not found
"/" was not found on this server

Lehet próbálgatni a minta-lapokat:

• http://localhost:8000/example/hello.ucw
• http://localhost:8000/example/hello2.ucw
• http://localhost:8000/example/hello-action.ucw
• http://localhost:8000/example/hello-session.ucw
• http://localhost:8000/example/hello-callback.ucw
• http://localhost:8000/example/hello-components.ucw
• http://localhost:8000/example/hello-yaclml.ucw
• http://localhost:8000/example/hello-control-flow.ucw

Férfiasan bevallom, ezek a példák így bedobva még távol állnak az értelmestől. Igazából azt hivatottak demonstrálni, hogy az UCW mindenféle feladatra használható, a hagyományos "megyünk oldalról oldalra" típusú weblaptól a komoly workflow-t (itt jön majd a "continuations") megvalósító lapokig.

A következőkben a hiányzó elemeket rakjuk majd hozzá a rendszerünkhöz, mielőtt belemennénk a nyelv és az UCW rejtelmeibe. Addig is, ha kérdésed van, szólj hozzá alul!

Kezdjük azzal, hogy ki kell építeni a szükséges környezetet. Illetve még előtte azt, hogy a sokféle Lisp közül én a Common Lisppel foglalkozom itt. És persze ennek is van több nyílt forrású változata, mint például az SBCL (Steel Bank Common Lisp), CMU CL, CLISP, Allegro CL (ingyenes változata), és még bizonyára sokan mások. Utánanézve úgy találtam, hogy az SBCL az egyik legelterjedtebb és legaktívabban fejlesztett változat, így ezzel fogok dolgozni. Majd egyszer leírom, hogy milyen különbségeket találtam a különböző változatok között és miért pont az SBCL-t választottam (főleg, ha kéritek), de itt most legyen elég ennyi.

Naszóval fel kell rakni valahova. Ehhez szükség lesz egy Linuxra (hogy miért nem Windows, ebbe most ne menjünk bele -- ha valaki Windows alatt is beüzemeli a rendszert, megköszönöm, ha megosztja a tapasztalatait). Én Ubuntut használok, de Debian éppúgy megteszi, sőt bármilyen másik is, ezeknél sem különbözik sokban a folyamat. Ráadásul most úgy rakom össze a rendszert, hogy a futtatókörnyezet (SBCL) egy szerveren lesz, a fejlesztőkörnyezet (Emacs, erről később) pedig egy kliens gépen. Természetesen egy gépre éppen így kell összerakni. Nézzük most a szervert.

Futtatókörnyezet

Először be kell szerezni az SBCL-t, ami praktikusan az apt-get install sbcl paranccsal történik. Ezután szükség lesz egy clbuild nevű kis programocskára, ami összegyűjtve a szokásosan használt Lisp könyvtárakat (library) segítséget nyújt ezek feltelepítéséhez. Ehhez szükség lesz a darcs nevű verziókezelő programra. Ennél arra kell figyelni, hogy a 2.x verziója legyen telepítve. Én Ubuntu 8.04 LTS szerveren dolgoztam, amelyben régi darcs van, ezért a google-n rákeresve a "darcs debian" kifejezésre eljutottam a Debian letöltőoldalára, ahonnan a csomagot leszedve dpkg -i darcs-valami (valami helyett az aktuális csomagnév maradék részét helyettesítsd be például egy TAB megnyomásával) paranccsal már fel is telepedett (függősége nálam nem volt).

Ezután már lehet is leszedni a clbuild-et a darcs get http://common-lisp.net/project/clbuild/clbuild paranccsal. Én mindezt a home könyvtáramban tettem, igyekszem mindent ott tartani. Ezután cd clbuild, majd chmod 755 clbuild, hogy tudjuk futtatni szegényt. Az alapvető parancs a ./clbuild check, ami ellenőrzi, hogy a működéséhez szükséges programok elérhetőek-e. Ezt elég egyszer lefuttatni, és szinte biztos, hogy hiányolni fog csaknem mindent, ezért rakjuk fel a következő programokat: cvs, subversion, mercurial, curl, git. Nálam ezek a következőképpen mentek: apt-get install cvs subversion mercurial curl git-core (figyelj, a git-et a git-core csomagban találod Ubuntun/Debianon). Ezután lefuttatva a ./clbuild check parancsot valami ilyesmi kimenetet kell kapnod:

bkovacs@tauceti:~/clbuild$ ./clbuild check
Checking for helper applications...
found /usr/bin/cvs
found /usr/bin/svn
found /usr/bin/darcs
found /usr/bin/wget
found /usr/bin/hg
found /usr/bin/curl
found /usr/bin/git
found /bin/mktemp
Success: All helper applications found.

Checking Lisp startup...
Success: Lisp starts up using "/usr/bin/sbcl"

Looking for installable systems...
38 system definition files registeredEz azt jelzi, hogy megvan az összes segédalkalmazás (helper application), a Lisp is (SBCL), illetve a telepíthető rendszerek (installable systems) is rendben van, 38db van belőlük.

Innen folytatjuk legközelebb.
 

E blog címében a lambda a lambda kalkulusra utal. Ebből persze számtalan további kérdés fakad, például, hogy az meg miaz.

Ez egy formális rendszer, amely függvényekkel foglalkozik. Biztos sokmindenre jó, de én most a funkcionális programozással, illetve ennek is egy igen régi változatával, a Lisp nyelvvel fogok foglalkozni. E nyelv keletkezése 1956-ra datálódik és John McCarthy nevéhez fűződik, aki mesterséges intelligencia tárgyat tanult, ahol először valósította meg a lambda kalkulus rendszerét számítógépen. Valójában 1958-ban készítette el az első változatot. Miért érdekes ez a nyelv? Mert még mindig létezik, használják, sőt fejlődik. Ebben pedig lehet valami.

Maga a nyelv rendkívül egyszerű. A neve, Lisp jelentése List Processing, azaz listakezelő. Ebből fakadóan listákat kezel, magyarán ez az alap adatstruktúrája. Minden lista benne, a függvények is, ami az egyik alapegysége. Mindehhez még sok zárójel társul, ami a listák elejét és végét jelzi, és elég csúnyán néz ki ahhoz, hogy a kezdőket elrettentse. Egy példa: (defun factorial (n)
   (if (<= n 1)
       1
       (* n (factorial (- n 1)))))Aki foglalkozott már más nyelvekkel, esztétikailag lehet hogy csalódott ennek láttán.

Így persze ismét felmerül a kérdés: miért foglalkozom vele? 

Leginkább azért, mert

• túl sokan mondják, hogy fejlesztési idő szempontjából az egyik leghatékonyabb nyelv
• több igen sikeres magyar és nemzetközi projekt alapja volt
• nagyon ígéretes web-fejlesző keretrendszerek vannak hozzá (bocs, elsősorban ez a téma foglalkoztat)
• csaknem minden mai, divatos technológiát támogat
• nem népszerű, aránylag kevesen használják

Kinek szól ez a blog?

Ezen az oldalon igyekszem leírni azokat a dolgokat, amiket a nyelvvel és környezettel kapcsolatban felfedezek. Alapvetően hozzám hasonlóan kalandvágyó, kísérletező embereknek szól, illetve azoknak, akik belefáradtak a modern nyelvek bőbeszédűségébe, a tervezési mintázatok (design patterns) alkalmazásába, és valami másra, jobbra vágynak.

Honnan veszem a bátorságot, hogy erről írjak?

Onnan, hogy én is kezdő vagyok. Amúgy is dokumentálom, amit felfedezek, akkor meg más miért ne venné hasznát egy csetlő-botló leírásnak? A véleményeitekből remélem megtudhatom majd, hogy érdeklődőkre találtam-e vagy csak magamnak írok.