Milyen a kapcsolatod a funkcionális programozási nyelvekkel / paradigmával?

Címkék

Nem ismerem őket.
46% (338 szavazat)
Ismerem, de nem tetszik.
11% (78 szavazat)
Tetszik az elgondolás, de nem használom.
18% (133 szavazat)
Tetszik, és használom is (munka, hobbi stb..).
9% (69 szavazat)
Csak az eredmény érdekel
16% (116 szavazat)
Összes szavazat: 734

Hozzászólások

Tetszik az elgondolás, de nem használom, mert nagyon kevés az olyan probléma és környezet, amikor ez volna a jó választás.

--
The Net is indeed vast and infinite...
http://gablog.eu

Nem tetszik az elgondolás, mert nagyon kevés az olyan probléma és környezet, amikor ez volna a jó választás.

Ha funprogramozást akarok látni, akkor valami egzotikus nyelvben gondolkodok. A funkcionális nyelvek körül egyelőre nagyobb a hype, mint a hasznuk.
----
Hülye pelikán

A hype-érzet lehet hogy onnan ered, hogy az egyetemeken és a kutatásban nagyobb a funkcionális nyelvek súlya mint az iparban.
Ennek megvan az oka.

A funkcionális nyelvek közelebb állnak a matematikához, így a kutatásban könnyebb velük dolgozni. Mióta vannak jó fordítóprogramok, az iparban is jobban használhatóak lennének sokféle problémára. Kérdés hogy az ipar felfigyel-e rájuk.

1. Miért zavar az, hogy az Ericsson használja, ha egyszer gerinchálózati központok vezérlésére a tapasztalat szerint alkalmas ? Amúgy open source, bár tényleg ők találták ki.

2. Mellesleg sok kisebb cég is használja, e-payment, stb. témákban. Ha statisztika érdekel, iratkozz fel az erlang mail listára, és nézd meg, milyen mail domainből jönnek hozzászólások. Nem csak erixonost meg gmailest fogsz látni :)
(www.erlang.org)

Tetszik az elgondolas, de nem hasznalom, mert tobbet kellene vele foglalkoznom. Illetve elofordult mar tobbszor olyan, hogy egy problemat funkcionalis stilusban oldok meg imperativ nyelven.

Ott eleg nehez, tekintve hogy a function-t mint nyelvi elemet a 7esbe akartak bevezetni, de aztan meggondoltak magukat.

Osszehasonlitasul: a vilag osszes tobbi p > 1% elofordulasi nyelveben letezik legalabb a fuggvenypointer fogalma

Idekivankozik Lajosba masodik mondata az alabbi napirajzrol: http://napirajz.hu/archives/2010/09/06/0/

nem azt mondtam, hogy funkcionalis, hanem hogy nagyon hasonlo. koszi, tudom mit tud a Java, azt is, hogy mi lesz/lett volna a 7esben.
es az, hogy Javaban nincs fuggvenypointer, sosem hianyzott meg annyira. ahol minimalisan igen, ott meg ki lehetett valtani OOPvel.

de tessek, ilyen egy ilyen kod, ami nyilvan jol kihasznalja a nyelv lehetosegeit:


interface P {
    List<Card> match(List<Card> cards);
}

enum Value {
    HCARD(new P() {
        ...
    }),
    PAIR(new P() {
        ...
    }),
    ...
    private final P predicate;

    private Value(P predicate) {
        this.predicate = predicate;
    }

    public List<Card> match(List<Card> cards) {
        return predicate.match(cards);
    }
}

hasznalni meg egyszeru, mint a faeket: Value.HCARD.match(akarmi)

Tudom, hogy tudod, mi a java :)

Viszont en akarhanyszor hozzanyulok, mindig arra lyukadok ki, hogy a nyelvi hianyossagait kerulgetem, a kenyelmetlen - tudom, az utobbi evekben feljavitott - reflexiot, a fuggvenypointerek hianyat, a rendes delegacio hianyat, a polimorfizmus egyes eseteinek hianyat, stb...

De nyilvan ha valaki java-guru, akkor ezek hianya fel se tunik, mint ahogy magyarban se tunik fel a nemmegkulonboztetes hianya, ram meg furan neznek, ha egy fiuorientalt kornyezetben a veletlenszeruen elofordulo noi fejlesztokre she helyett he-t mondok, mert ugye minden mas nyelvben ott van, en meg csak forditom magamban az o" -t...

Sz'al par ev mas nyelvekkel, es furan fogsz nezni, hogy mennyi minden hianyzik innen :)

Java mellett volt C#-os projektem, az egészen baráti volt,

van most egy C++-os is, azt nagyon de nagyon utálom (dcom api-val kommunikálás, ACE framework-kel), egyszerűen állandóan a mit hozunk létre lokálisan, mit heap-en, hogyan konvertálgatunk a kettő között bohóckodással szívok, dislike :)

Merthogy?

Egyszerűen kényelmetlennek találom, hogy olyan dolgokkal kell foglalkoznom programozás közben, ami alapvetően és elsősorban a nyelv/interpreter/whatever dolga lenne, amivel én foglalkozni akarok, az a lehető legjobban tesztelt, legjobb struktúrával/olvashatósággal rendelkező kód, amit valamilyen szabályok (design pattern) alapján tudok építeni, lehetőleg minél több nyelvi támogatással.

Java-ban ez nagyjából megvan, de néha itt is úgy érzem, hogy sok felesleges kódot kell írnom.

Példák:

- unit test framework-ök elég gyengék
- normális hibajelzés hiánya (visual c++ legalábbis csak azt nem mondja meg, hol van a hiba)
- típuskonverziók különböző könyvtárak között (tipikusan m$ vs saját cuccok)
- UTF8 kezelése nyelvi szinten?
- Refactoring támogatás fejlesztői eszközökben?
- java-ban új objektum létrehozása: new XXX(), és annyi, C++-ban auto_ptr, shared_ptr, lokális, ha nem úgy jött létre, ahogy nekem kell, akkor másolgatni ide-oda
- ACE framework nem igazán tetszik (ez nem a C++ hibája, csak én sirok miatta)
- java-hoz képest nagyon kevés/nehezen integrálható könyvtár
- hosszú fordítási idő vs. java-ban azonnal látom, ha valami nem jó

Értem én, hogy C++-ban ugyanúgy lehet használni a design pattern-eket, egyszerűen csak a Java-hoz képest kényelmetlennek tartom a C++-t, úgy érzem, hogy a nyelvvel/környezettel szenvedek, és nem a feladatot oldom meg.

A Qt tenyleg jo, illetve forditashoz erdemes reszben valami fasza make kornyezetet hasznalni (peldaul CMake), reszben pedig agyonparameterezni, ha jol emlekszem Jason kollega egy masik szalban irt erdekes dolgokat, majd megkeresem neked.
--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

Egy alapvetoen oop nyelvben egyaltalan nem baj az, ha minden osztaly, azt az egy plusz sort meg ki lehet birni, masreszt pedig egysegesebb lesz tole a nyelv. Egy OOP nyelvben nem biztos hogy helye van a C/scripting szemleletnek.
--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

Nem arról van szó hogy jó vagy nem jó, hanem hogy java után a c++-ban (fordító hibajelzése, infrastruktúra, fejlesztői eszközök) nagyon sok minden eléggé kényelmetlen, fapados.

(clang elég igéretes, XCode meg hiába szép és jó, csak Mac-re lehet vele fejleszteni, ahogy néztem...)

Igen, de csak n.-edik tanult nyelvnek.

Különben úgyis csak "Fortranban" fognak bennük az emberek programozni.

Tanulási szakaszban nincs jobb mint a következetes nyelvek kikerülhetetlen korlátokkal, az emberek lusták és sosem jönnek rá maguktól a következetesség előnyeire - ha nincsenek rákényszerítve, kikerülik a szabályokat ha terhesnek érzik.

Szóval purely-OO és purely-functional nyelvek FTW...

Attól függ mennyi a huzamosabb idő, de sosem volt olyan, hogy kizárólag egy nyelvet használok. A korai C++ kódjaim nem gányolósak voltak, hanem a kevés lexikális tudásról beszélnek: alig használtam az stl-t, nem volt benne template, virtuális függvények stb. Tehát szépen vezettem bele magam a paradigmákba. Viszont az erőltetett paradigmány nyelveket én baromira korlátozónak és kényelmetlennek érzem (mondjuk van aminél ez nem érződik annyira, de scriptnyelvek annyira nem számítanak itt).
----
Hülye pelikán

Kevesebb problemara hatekony, mint amennyire most divatos. (Hosszabb mint zoldebb.)

----------------------
while (!sleep) sheep++;

A funkcionális nyelvek hatékonysága leginkább párhuzamosításnál jön ki, ugyanis egy ilyen kódot csont nélkül végre lehet hajtani párhuzamosított feldolgozással. Manapság pedig, ahogy egyre inkább haladunk a (masszívan párhuzamosított végrehajtási rendszerű) GPGPU-k felé, szerintem egyre fontosabbak lesznek a funkcionális nyelvek.

Biztos, hogy jó az, ha egy nagyobb projektben többféle paradigma keveredik annak ellenére, hogy ugyanazt a programozási nyelvet használja mindenki?

Szerintem egy programozási projekt az nem demokratikus intézmény, ahol mindenki úgy kódol ahogy neki tetszik. Ezért nem baj, ha egy programnyelvben egy dolgot csak egyféleképpen lehet megcsinálni.

egeszen addig, amig nem kell belenyulnia valakinek, aki mondjuk nincs otthon az adott paradigmaban :P
ettol fuggetlenul szerintem nem feltetlen rossz az, ha a nyelv olyan szabadsagot ad, amivel konnyen labon tudja loni magat a fejleszto. ez a vonas pedig megtalalhato a php-tol(vagy a Visual Basic-tol) kezdve a c++ -ig eleg sok nyelvben.

Tyrael

"Szerintem egy programozási projekt az nem demokratikus intézmény, ahol mindenki úgy kódol ahogy neki tetszik."
Ezzel egyetértek, de amit levezetsz belőle azzal már nem.

"Ezért nem baj, ha egy programnyelvben egy dolgot csak egyféleképpen lehet megcsinálni."
Tetszőleges programnyelvben egy dolgot nagyon sokféleképp lehet megcsinálni. Akár sok paradigmával, amit esetleg a nyelv nem is támogat. pl. Javaban is lehet funkcionális stílusban programozni, de az nem lesz olyan "szép", mint mondjuk ugyanaz Scalaban.

Ne is legyenek különféle ciklus utasítások (for, while, until, ...), vagy feltételes utasítások (if, switch, ...)! Legyen egy, használja mindenki azt!
Ez pont nem az egyszerűsítés, a jobban érthetőség irányába vezet.

"Javaban is lehet funkcionális stílusban programozni, de az nem lesz olyan "szép", mint mondjuk ugyanaz Scalaban."
Ez úgy hangzik, mintha az lenne a cél, hogy funkcionálisan oldjon meg valamit, de az javaban nem megy olyan könnyen, mint scalaban. Szerintem meg ha javaban kódol, akkor ne is jusson eszébe, hogy tisztán funkcionális alapokon oldjon meg valamit, mert nem ez az elvárt.

"Ne is legyenek különféle ciklus utasítások (for, while, until, ...), vagy feltételes utasítások (if, switch, ...)! Legyen egy, használja mindenki azt!
Ez pont nem az egyszerűsítés, a jobban érthetőség irányába vezet."
Valóban ezek kiválthatók egymással, de valószínűleg azért férnek meg mégis egymás mellett (minden elterjedtebb programozási nyelvben), mert nagyon sokszor használt alapeseteket fednek le. Nekem ezekkel nincs is bajom és nem is kapcsolódnak a vitához. Ezek nem jelképeznek eltérő programozási paradigmákat, mi pedig ebben a szálban a multi-paradigmás nyelvekről társalgunk, amiket te jó dolognak tartasz én meg nem.

Szerintem egy programozónak nem könnyű úgy kiigazodnia egy kódon, hogy annak különböző részei eltérő paradigmák szerint készültek.

Szerintem meg szépen megférnek egymás mellett.
Java nyelven lásd pl.

if (a == null) b = "Alap";
else b = a;

vs

b = (a == null) ? "Alap" : a;

Vagy a nem módosuló osztályok használata: pl. BigDecimal, ...
Szerintem senkinek nem esik nehezére a BigDecimal használata, pedig az FP stílus.

Ja, errol beszelek -- a fel internet arrol enekel, hogy a funkcionalis programokat mennyire jol lehet parhuzamositani. Aztan amikor a konkret feladatot kellene megoldani, akkor mar nem skalazodik annyira jol.

Naiv hozzaallas, hogy a tisztan funkcionalis nyelvek jol parhuzamosithatoak. Egeszen konkretan azert, mert a vegrehajtoegysegek jelenleg tisztan proceduralisak. Erdemes kicsit utanaolvasni, nagyon erdekes tema.

----------------------
while (!sleep) sheep++;

"Egeszen konkretan azert, mert a vegrehajtoegysegek jelenleg tisztan proceduralisak."

Ez csak annyit jelent hogy nehéz funkcionális nyelvekhez jó fordítóprogramot írni. De azért mára már vannak elég jók.

"Aztan amikor a konkret feladatot kellene megoldani, akkor mar nem skalazodik annyira jol."

Lehet hogy igazad van, de esetleg meg sem próbálják rendesen. Kíváncsi vagyok a tapasztalataidra (vagy mások tapasztalataira).

Azért is írtam sokféle hatékonyságot, mert nem csak egy dolog számít.
Nagyon sok program nagyon nagy részében a futási hatékonyság egyáltalán nem számít. (pl. 5ms alatt fut le valami vagy 50ms alatt)
Sokkal inkább számít, hogy mennyi idő elkészíteni, karbantartani, újrafelhasználni, hibát keresni benne, mennyire hibatűrő vagy amit Te is említesz.
A párhuzamosságnál nagyon fontos a konkurrens (van erre valami jó magyar szó?) adatmódosításból eredő hibák kiküszöbölése, amiben szintén nagyon jó a funkcionális programozás.

Csak lazan kapcsolodik (egy regi TDWTF posztnal volt komment):

Only a Deranged Fool would use VB.Net for a task this important. Clearly the only Sane Choice is ... no, I'm not going to calm down. Get your hands off me! I don't care how many side effects that filthy solution has; I'm not going to use a functional alternative.

Dysfunctional languages, that's the way to go.

http://thedailywtf.com/Comments/Spaced-Out.aspx

--
Take my advice; I don't use it anyway.

A "Tetszik, és használom is (munka, hobbi stb..)." opciót választottam, de ez így nem igaz. Ami igaz:
"Tetszik, és most tanulom (hobbi)."

-----
"Én vagyok a hülye, hogy leállok magával vitatkozni."

Olyasmi, mint a kínai. Tetszik és használnám is, de valahogy annyira idegen az ilyen nyelvek logikája számomra, hogy nehézséget okoz, hogy alkalmazkodjak hozzá egy gyakorlati probéma megoldása során. Tanulgatom a Scala nyelvet, de a végén valahogy mindig az objektumorientált logikánál kötök ki, amikor megpróbálok megvalósítani valamit benne.

Kedves emberek,

Az ugye megvan, hogy a javascript egy funkcionalis - nem multiparadigmalis meg mittom - nyelv?

Konkretan regularis kifejezesekkel tetszoleges javascript program atirhato LISPpe. (Belulrol ugyanis egy scheme interpreter, kicserelve a grammatika BNF fajlja)

A jQuery - barmennyire ruhelljem is - pl. funkcionalis, paradigma szerint is.

Az elgondolasa nem skalazodik.

Tok jo, ha van 3 gombod amire click event kell, de ha hirtelen komplex widgeteket akarnal osszerakni, amik egymasba vannak agyazva, vagy mediator kene neked tobb widget kozt, akkor rajossz, hogy azok a klasszikus patternek, amiket a jQuery kidobott, megiscsak jok valamire.

Ha maskor nem, akkor, amikor fel ev mulva el kene olvasni a kodot.

Persze be lehet rendezni egy kodot ugy, hogy valahol nagyon alul jQuery-t hasznaljon, es megis legyen valami ranezesre is eszlelheto architekturaja, csak a tobbiek ebben meg jobbak.

Pici dolgokra meg a jQuery jobb nyilvan. Csak nem szoktak eszrevenn, amikor atlepik ezt a hatart, ill. a legritkabb esetben allnak at valamire, vagy rendezik a kodot valami konzekvens es szabvanyos strukturaba, hanem folytatjak tovabb a projektet, aztan ez megy 1-2 evig, utana meg bogozd ki.

ha komolyan kerdezed, akkor valoszinuleg azert, mert elobb volt a javascript nyelv mint implementacio, amit eloszor lekoppintott/kiterjesztett a Microsoft JScript neven, majd a Netscape megkerte az ECMA-t, hogy standardizalja, valamint keszitsen belole specit, ez lett az ECMA-262.
tehat tekinthetunk rajuk ugy, mint specire(ecma) illetve implementaciora(javascript, actionscript).
http://en.wikipedia.org/wiki/Ecmascript
sajna ott van meg a problema, hogy meg a kulonbozo js engine-ek sem ugyanolyan modon/mertekben tamogatjak a specit, csak hogy tovabb fregmentalodjon a piac.
http://en.wikipedia.org/wiki/Comparison_of_layout_engines_(ECMAScript)

Tyrael

Tetszik és használom is -- hobbiból, mert még messze van az amikor programozói munkát fogok végezni... :)

Tengernyi indokot lehetne felhozni mellette, de az internetes viták jellemzően nem az érvekről szólnak, szóval menjen inkább a flame:

“When the limestone of imperative programming is worn away, the granite of functional programming will be observed.”—Simon Peyton Jones

;)

-----------
"Generally, Russian technology assumes dumb machines and smart humans, not the other way around." -- The Russian Tea HOWTO

Ez tetszik! :-)

"Little-Endians of Lilliput and the Big-Endians of Blefuscu"

Szerk.: ez is:
"Consider the Java expression Date(2006,1,1); what calendar date do you suppose that specifies?The answer is February 1, 3906. In Java we count months starting with 0, days starting with 1, and years starting with 1,900."

Idézet a cikkből hogy ne kelljen kattintani:

"Ahogy a szoftver egyre bonyolultabbá válik, egyre fontosabb hogy jól strukturált legyen. Jól strukturált szoftvert könnyű írni és debugolni, és a kapott modulgyűjtemény újrafelhasználásával csökkenthetők a programozási költségek. A cikkben bemutatjuk hogy két funkcionális programozásbeli eszköz, a magasabbrendű függvények és a lusta kiértékelés hogyan járul hozzá lényegesen a modularitáshoz."

Ismerem, tanulom, és belátom, hogy bizonyos esetekben hasznos, de egyszerűen nem szeretem. Feladata válogatja a megoldáshoz használt eszközt.

Ezzel az allatkaval az imapfilter hasznalata soran talalkoztam, mely a lua nyelvet hasznalja filternyelvkent. Nem mondom, hogy egyszeru, de legalabb bonyolult. Tetszik, de magamtol ilyen nyelvben nem irnek semmit.
--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

egyeb: tetszik az elgondolas, hasznaltam de mar nem hasznalom.

Szerintem az FP tokre hasznalhato a gyakorlatban is. En 3D engine-t es hozza pelda jatekot fejlesztek Haskellben.
Nemreg pl 3 nap alatt sikerult osszedobnom par szaz sorbol egy Quake3 palyamegjelenitot.
Meg sztem a legnagyobb elonye hogy, a szigoru tipusrendszernek koszonhetoen majdnem bugmentes progit lehet benne gyorsan osszehozni.

Akit erdekel az csekkolja le a forrast:
http://code.google.com/p/lambdacube/source/browse/#svn%2Ftrunk%2Fbsploa…
http://code.google.com/p/lambdacube/source/browse/#svn%2Ftrunk%2Flambda…
http://code.google.com/p/lambdacube/source/browse/#svn%2Ftrunk%2Flambda…

http://www.haskell.org/haskellwiki/LambdaCubeEngine

Jópofa, elég tömörnek tűnik. Egyetemen tanultam prolog/sml-t, de valahogy sosem fogott meg. Java-ban használtam a a lambdaj-t, az egészen hasznos néhány esetben, de nem szükségszerű.

Mennyire lehet használni az oop gondolkodásmódot, tervezési mintákat, mennyire lehet nagy programokat készíteni mondjuk haskell-ben?

Teljesen jol lehet nagy projekteket fejleszteni haskellben. Nagyon nagy segitseg a type inferences es type checking, na meg a type classok.
Az oop gondolkodasmod viszont felejtos, mashogy kell tervezni a programot FP-ben, sokkal abstraktabban es altalanosabban lehet kodolni. Sokkal kevesebb lesz a boiler plate kod.

Na ez az, konkrétan ezek a dolgok érdekelnének. Mert most java-ban programozunk, és megvannak a nagyon szépen/jól bevált design pattern-jeink, a tervezéstől, a kódoláson át a tesztelésig. Esetleg olyat tudnék elképzelni, hogy a kód egy része funckionális lenne, viszont oo alapokra építve, viszont ez lehet, hogy öntökönlövés kategória. Az, hogy mennyi a boilerplate az erőteljesen függ attól, hogy mit hoznak nyelvi szintre/milyen könyvtárak vannak. Ami nekünk fontosabb, hogy jól tervezhetően, tesztelhetően, integrálhatóan tudjunk kódokat írni... (baromira nem érdekel, hogy {}-t vagy ;-t kell írni, a fent említettek sokkal fontosabbak...)

Létezik valamilyen leírás a neten erről?

Bocs, nem teljesen a kérdésedre fogok válaszolni de hátha érdekes.

A funkcionális nyelveknek nagyon erős matematikai alapjai vannak. Ezeknek a nyelveknek elméleti modellje a lambda kalkulus amit az 1930-as években fejlesztettek ki matematikusok. Ezzel elmondható hogy mi az hogy számítás és egy nagyságrenddel egyszerűbb mint a Turing-gép.

A matematika tulajdonképpen a dolgok formális leírásának a nyelve. Kérdés, hogy megeszi-e a számítógép. A funkcionális programozók hisznek ebben és ezt az álmot igyekszenek megvalósítani egyfajtaképpen.

OO programozással is leírhatod a dolgokat tömören, érezni fogod hogy mit jelent, de sosem fogod tudni pontosan mit jelent amit írtál.

(Ez persze egy végletesen leegyszerűsített szubjektív megfogalmazás. :)

Számomra az OO programozás azt jelenti, hogy egy struktúrát építek fel bizonyos szabályok szerint,
amibe bele tudom kapcsolni az új feladatokat elvégző elemeket, tervezhető módon. Valójában eljut az ember arra a szintre, amikor a nyelv csak egy eszköz, és igazából struktúra szinten gondolkozik, nyelvi szinten csak megvalósítja azt. Erre vannak "épitési segédletek": design pattern-ek, illetve best practice-ok.

Részemről a funkcionális nyelven programozás azt jelenti, hogy a nyelvet változtatom, a kérdés az, hogy egy gondolkodásmódjában alapvetően eltérő programozási nyelvnél ezeket a mintákat/sablonokat mennyire tudom jól/egyáltalán felhasználni...

Minél inkább tervezés a programozás és nem próbálgatás, annál kevésbé számít a nyelv, tényleg csak egy eszköz.
De ha egy nagy, komplex rendszert kell alkotni, akkor esetleg érdemes egy nyelvet alkotni előbb hozzá, de ha nem akkor meg megéri körülnézni a meglevő nyelvek között. Szóval mégiscsak számít a nyelv.

Az OO mintákat nem lehet közvetlenül átvinni tisztán funkcionális nyelvekbe, ez jó is így.
A funkcionális programozás szerintem a magasabbrendű függvények (például függvénykompozíció) használatánál kezdődik. Másik jellegzetessége az állapotnélküliség. Például a típusosztályokban nincs és nem is lehet adattag.

Én úgy látom hogy ezek a módszerek még messze nincsenek kidolgozva funkcionális nyelveknél. Több fontos részterületen most alakulnak ki a bevett módszerek. Például ilyen az interaktív programok írásában az FRP (Functional Reactive Programming), hcube ilyen kódot linkelt be.

Az oktatásban érdekes kísérletezés folyik. Jó hogy van egyáltalán lehetőség az oktatásra a mainstream nyelvek mellett, de kellene kb. egy három féléves tárgy a megtanulásukhoz. Szerintem technológiai fölényben vannak a funkcionális nyelvek, de egyelőre absztraktabb gondolkodás is kell hozzájuk pont azért mert nincsenek jól bejáratott módszerek.

Egy tisztán egy szemléletű nyelv sosem lehet "technológiai fölényben", az mindig megmarad egyetemi illetve egyéb, nagyon speciális célra. Viszont az eredménye megvan a kutatásnak, még ha soha nem is jön el a "funkcionális nyelvek éve/egyeduralma": a legtöbb nyelv felvett már egy rakás funkcionális jellemzőt, és ez csak folytatódik. Nem kell aggódni, az ipar kitermeli magának a nyelveit, és mivel a visszafele kompatibilitás jó, ezért a régi nyelvek alakulnak át.
----
Hülye pelikán

A kevesebb néha több.
Most a két legnépszerűbb nyelv, a C és a Java nem multiparadigmás (http://langpop.com/). A C++ multiparadigmás de úgy tudom kritizálják is miatta.
Technológiai oldalról nézve, a paradigmák hátrányai egyesülnek multiparadigmás nyelvben.

A Haskell például egy tisztán funkcionális nyelv. Ha beletennék az OO paradigmát, akkor az altípusosság miatt elveszne több nagyon erős tulajdonsága, például a determinisztikus típuskikövetkeztetés.

Az oldal amit linkeltél számtalan győztest hoz ki nagyon sok kategóriában, de én egy szóval sem mondtam, hogy CSAK multiparadigmás nyelv lehet sikeres. Sőt, sokmindenre nem alkalmas. A C++-t meg sokmindenért kritizálják, van, amiért jogosan, van, amiért nem. Aki azért kritizálja, amiről beszélünk, az nem érti a lényegét. A C++ egy erős eszköz, erős nyelv, és mint erős nyelv, nehezebben fejezed magad ki rajta. Több lehetőség -> komplexebb nyelv.

Amiről te beszélsz technológiai oldal az az elméleti megközelítés, amit a gyakorlat sokszor cáfol.
Te a Haskellel jössz, ami alapvetően rossz példa, mert egy tisztán X nyelv nyílván veszít az erejévől, ha kevered. De a trendek affelé mutatnak, hogy az imperatív nyelvek felvesznek funkcionális jellemzőket, a funkcionális nyelvek közül meg az lesz sikeres, amelyik nem tisztán az. A "tisztaság" az egyetemre való, kutatáshoz. Az iparnak hatékony eszközök kellenek.
----
Hülye pelikán

A mérések szerint a Haskell pl. hatékony kódot készít.
Ha a programozási eszközökre gondolsz, akkor azok valóban hiányoznak, de ez nem a technológia hibája.

A programozási paradigma meg attól paradigma hogy minden lényeges kérdésre tud választ, nem csak egyre.
Véleményem szerint azzal hogy azt mondod hogy a funkcionális programozás nem minden környezetben megfelelő, kb. azt mondod hogy matematikai eszközökkel nem lehet mindent formalizálni. De ez egy erősen szubjektív vélemény.

Háát...

- Az általános célú script nyelvekhez is mostanában jelennek meg használhatóbb eszközök (refactoring, statikus ellenőrzések, code completion stb... )
- Nagyságrendekkel lassabbak még ma is mint a fordított nyelvek

És mégis a 90-es években már úgy terjedtek mint a gomba, szóval én mégis inkább magában az FP paradigmában látom a terjedés lassúságát: szinte teljesen más hozzáállást, tudást stb.. igényel:
pl. tonnányi számítás és algoritmuselméleti felfedést kell kidobnod vagy újra gondolni ha nem "konstans időben módosítható állapotokban" gondolkozol

Egyik sem talált. Arról beszélek, hogy a valós életbeli problémák olyanok, hogy egy tiszta nyelv nem tud minden részére hatékony választ adni. Minden paradigma jó valamire, de ha szerinted mindegyik ugyanannyira jó mindenre, akkor minek találtak volna ki többet?
A "nem megfelelő" nem azt jelenti, hogy "alkalmatlan". Tudod, mint sajtreszelővel maszturbálni.
----
Hülye pelikán

Na igen, erre jók a funkcionális nyelvek. Hülyéskedni. Carmacknak a Q3:A-nál meg kellett oldani, hogy egy 166-os Pentium szoftveresen ki tudjon rendereleni egy 10-20k poligonból álló pályát, legalább 8 playerrel.

Erre csak a C meg assembly volt jó.

De ha egy jó kernelt akarsz írni, arra is C kell. A funkcionális nyelvek tudományos munkára meg szórakozásra jók. Ha mission critical dolgot kell csinálni akkor gépközeli nyelvet kell használni, akár bytecodeot.

--
GPLv3-as hozzászólás.

A mission critical nem mindenkinek azt jelenti, hogy hajtsuk ki a szart is a PC hardware-ből.

Sőt leggyakrabban nem ilyen környezetben használják a kifejezést. Én személy szerint az otthoni 3D-s játék szaggatásánál kisebb informatikai kockázatot szinte elképzelni sem tudok. ;)

Ilyenek szoktak inkább lenni:

hogy fusson évekig leállás nélkül vagy
hogy a teljesítmény lineárisan skálázódjon 1000+ nodeig
hogy (akár matematikai) garanciák legyenek arra hogy bizonyos események meghatározott időpontban bekövetkeznek (vagy hogy épp nem)
hogy tökéletesen megvalósítson valamilyen formális specifikációt

stb...

Forog velem a világ, és mégsem SML. :)

Egy ocaml cucchoz kuldtem patch-eket, erdekes volt, de nem estem bele.

alapvetően tetszik, de viszonylag ritkán használom, ha mégis akkor leginkább a strategy pattern "egyszerűsítésére" (funkcióobjektum helyett lambda).

Nálunk most volt ada mint kötelező tantárgy.
Hát mit ne mondjak, nekem nagyon nem jött be.
Részben azért, mert ugy néz ki mint a pascal, másrészt nagyon kötöt
(nagyon sok mindent megtilt, gondolom igy probálták megakadályozni,
hogy az óvatlan programozó ne csinálhasson hülyeséget)
Mutatok vannak, de elvannak "fedve".

És általában rövidebben meglehet irni a feladatot, mint cppben,
de cppben pedig a hosszab kódot is gyorsabban meglehet irni mint adában a rövidebbet :P

az Adanak a legnagyobb elonye, hogy iszonyatosan tipusbiztos, ergo lehet formalisan is bizonyitani. vannak olyan szintek, ahova ez kell, pl az NSA ~1/masfel eve publikalt valamilyen belepteto rendszert, amit egy ada variansban irtak.

ja, meg hogy tamogatja out of the box a concurrencyt.