Archief - [PROG]/ een gamekkelijke programmeer taal?

Quilombo · 22 feb 2006

mjah ge zei ergens da je der ni veel over kunt zegge tot ge iets deftig hebt gemaakt

k heb just wa basis van cobol, java, c, asm en delphi
asm wil k mij wel wa verder in verdiepen, ik denk ni da we daar nog veel van gaan zien
en k vind cobol wel leuk, wrs omdat het zo simpel is

en is gewoon maffe taal: in welke taal hebt ge nu iets als
multiply a by b giving c (ipv c=a*b) :|

cobol is toch nog altijd goe voor administratieve toepassingen dacht ik

edit: zo nutteloos is da ni hoor, kijk maar es bij interimkantoor wat er buitenhangt van programmeurs
edit2: gans die thread is wel lache als ge kijkt naar de beginvraag

mijn antwoord heeft em alvast: cobol

das simpel

Hasdrubal · 24 feb 2006

ja je zegt het! dacht ik ga ik ff een onnozel vraagske stellen ik was zlefs een beetje bang of ik wel replies ging krijgen. Keek ff twee dagen niet en opeens boem 5 pagina's.

Cobol heb ik nog nooit van gehoord.
multiply a by b giving c? dan vind ik c=a*b toch nog leuker.
Je maakt minder rap spel fouten, 't is minder typen en hoe doe je dat dan wel niet als je een ingewikkelde formule hebt?

Bubbling Zombie · 25 feb 2006

Hasdrubal zei:
Je maakt minder rap spel fouten, 't is minder typen en hoe doe je dat dan wel niet als je een ingewikkelde formule hebt?

Ge kunt da ook doen, ik dacht dat cobol iets had in de stijl van "eval" ofzoiets. En dan deed je Eval(a*b/c^d) en ge waart vertrokken e

Hasdrubal · 25 feb 2006

Bubbling Zombie zei:
Ge kunt da ook doen, ik dacht dat cobol iets had in de stijl van "eval" ofzoiets. En dan deed je Eval(a*b/c^d) en ge waart vertrokken e

ik dacht al. Hennig handig programmeer taaltje je moet alleen een gans boek schrijven voor een formuletje. :crazy:

moet ik dan misschien ook maar eens eens gaan bekijken.

Hale · 25 feb 2006

haskell en prolog zijn ook leuke talen.
misschien niet zoooo eenvoudig om mee te beginnen (of misschien net wel omdat je nog niet vast zit in het hele imperatief denken van talen zoals C/C++/Java/...).

beide zijn declaratieve talen wat erop neerkomt dat je veel meer zegt _wat_ het moet zijn dan _hoe_ je het bereikt. In sommige gevallen maakt dit bepaalde algoritmes véél eenvoudiger om neer te schrijven dan in een imperatieve taal waar je stap voor stap moet beschrijven wat er moet gebeuren.

klein voorbeeldje van quicksort in prolog :

Code:

quicksort([],[]).
quicksort([Head|Tail],Resultaat) :- 
       pivot(Head,Tail,Groter,Kleiner),
       quicksort(Kleiner,Res1),quicksort(Groter,Res2),
       append(Res1,Res2,Resultaat).
pivot(_,[],[],[]).
pivot(X,[Y|Tail],[Y|Groter],Kleiner):- Y>X,pivot(X,Tail,Groter,Kleiner). 
pivot(X,[Y|Tail],Groter,[Y|Kleiner]):- Y=<X,pivot(X,Tail,Groter,Kleiner).

Hasdrubal · 25 feb 2006

Hale zei:
haskell en prolog zijn ook leuke talen.
misschien niet zoooo eenvoudig om mee te beginnen (of misschien net wel omdat je nog niet vast zit in het hele imperatief denken van talen zoals C/C++/Java/...).

beide zijn declaratieve talen wat erop neerkomt dat je veel meer zegt _wat_ het moet zijn dan _hoe_ je het bereikt. In sommige gevallen maakt dit bepaalde algoritmes véél eenvoudiger om neer te schrijven dan in een imperatieve taal waar je stap voor stap moet beschrijven wat er moet gebeuren.

klein voorbeeldje van quicksort in prolog :

quicksort([],[]).
quicksort([Head|Tail],Resultaat) :-
pivot(Head,Tail,Groter,Kleiner),
quicksort(Kleiner,Res1),quicksort(Groter,Res2),
append(Res1,Res2,Resultaat).
pivot(_,[],[],[]).
pivot(X,[Y|Tail],[Y|Groter],Kleiner):- Y>X,pivot(X,Tail,Groter,Kleiner).
pivot(X,[Y|Tail],Groter,[Y|Kleiner]):- Y=<X,pivot(X,Tail,Groter,Kleiner).

hmm van wat ik ken, niet zoveel heb ik wel altijd dat imperatief denken gedaan... Hoewel het me niet zo'n groot verschil lijkt. En zolanng het een beetje logisch blijft ka dat geen probleem zijn. Bij elke taal moet je wel aan bepaalde dingen gewennen.

Hale · 25 feb 2006

als je van wiskunde houdt is prolog wel een fijne taal. Ze is nl. volledig gebouwd op mathematische gronden ( meer bepaald wiskundige logica ) waardoor ze bepaalde eigenschappen van die taal wiskundig kunnen bewijzen.
Nu, ge kunt die taal ook gebruiken zonder u al te veel van die wiskunde aan te trekken waarop alles gefundeerd is.

Hasdrubal · 25 feb 2006

Hale zei:
als je van wiskunde houdt is prolog wel een fijne taal. Ze is nl. volledig gebouwd op mathematische gronden ( meer bepaald wiskundige logica ) waardoor ze bepaalde eigenschappen van die taal wiskundig kunnen bewijzen.
Nu, ge kunt die taal ook gebruiken zonder u al te veel van die wiskunde aan te trekken waarop alles gefundeerd is.

bwa ben normaal wel goed in wiskunde dus

Hale · 25 feb 2006

http://www.cs.kuleuven.be/~gerda/DT/index.html hier vind je vanalles over het vak declaratieve talen zoals het gegeven wordt aan de KUL in 1ste lic informatica.

de twee talen die besproken worden zijn prolog en haskell. Voorlopig staat er blijkbaar nog alleen maar prolog op. de slides van de lessen worden trouwens iedere week aangevuld (vorig jaar was dat toch het geval).

edit :
de cursus is wel veel meer toegespitst op hoe prolog daadwerkelijk gebruiken, waarbij er redelijk vluchtig over de wiskundige onderliggende theorie ( SLD-resolutie, soundness en completeness van die resolutie regel, most general unifier,...) gegaan wordt. Dus ideaal om snel iets te kunnen maken dat ook daadwerkelijk compileert en runt.

Hale · 26 feb 2006

nog een voorbeeldje van hoe elegant sommige van die functionele talen zijn.
opnieuw quicksort, maar nu in Haskell

Code:

qsort []     = []
qsort (x:xs) = qsort elts_lt_x ++ [x] ++ qsort elts_greq_x
                 where
                   elts_lt_x   = [y | y <- xs, y < x]
                   elts_greq_x = [y | y <- xs, y >= x]

vergeleken met de C code voor hetzelfde algoritme :

Code:

void quicksort(int data[],int lengte){
   int i;
   int resultaat[lengte];
   int kleiner=0,groter=lengte-1;
   
   if(lengte>1){ //als er geen of 1 element is, dan moet er niet gesorteerd worden
     for(i=1;i<lengte;i++){ //ga al de andere elementen af
       if(data[i]<data[0]){ //kleiner dan pivot, plaats vooraan in resultaat
         resultaat[kleiner]=data[i];
         kleiner++;
       }else{ //groter als pivot, plaats achteraan in resultaat
         resultaat[groter]=data[i];
         groter--;
       }
     }
     resultaat[kleiner]=data[0]; //zet het pivot juist
     for(i=0;i<lengte;i++) data[i]=resultaat[i]; //kopieer resultaat naar data
     if(lengte>2){//als er minder dan 3 elementen zijn, dan zijn ze daarjuist gesorteerd
       quicksort(data,kleiner); //sorteer groep voor pivot
       quicksort(data+kleiner+1,lengte-kleiner-1); //sorteer groep na pivot
     }
   }
 }

noot : ik heb het C algoritme van wikipedia gehaald, en het ook niet nagelezen; ik neem aan dat er wel geen fouten in zullen staan

killgore · 26 feb 2006

kzie nie onmiddelijk fouten, ma het kan korter geïmplenteerd worden, ze gebruiken "onnodige" statements. (die met ++ en -- operators bv.).
Ik vind die andere talen persoonlijk minder duidelijk, hoewel ze mssch idd "elegant" kunne genoemd worden in sommige situaties

. En da van wiskundiger hangt af van persoon tot persoon.

Hale · 26 feb 2006

bwa, dat is waarschijnlijk minder duidelijk omda je waarschijnlijk ni vertrouwd bent met de syntax.

het elegantere eraan is dat je in de Haskell versie veel meer beschrijft hoe het algoritme eruit ziet op een hoog niveau ( opslitsen in twee lijsten, recursief quicksort daar terug op toe passen, en uiteindelijk de resultaten aan elkaar plakken ). In de C versie is dat op het eerste zicht veel minder duidelijk.

Nu eerlijkheid gebied mij ook wel te zeggen dat quicksort zich erg goed leent om het op een functionele manier te programmeren omdat het hele divide and conquer concept gebouwd is op recursie, wat je normaal veelvuldig gebruikt bij functionele talen.

Ook kan je de bedenking maken dat die

Code:

where
                   elts_lt_x   = [y | y <- xs, y < x]
                   elts_greq_x = [y | y <- xs, y >= x]

gebruik maakt van build in functies wat niet zo was in de C versie. Maar het prolog voorbeeld bevat zulke predicaten (prolog kent geen functies in de zin van C-functies) niet en die oplossing is nog steeds veel korter en duidelijker ( eens je prolog snapt that is

)

Hasdrubal · 26 feb 2006

hey dat is een handige link!

Quilombo · 27 feb 2006

Bubbling Zombie zei:
Ge kunt da ook doen, ik dacht dat cobol iets had in de stijl van "eval" ofzoiets. En dan deed je Eval(a*b/c^d) en ge waart vertrokken e

compute a = b * c

wlibaers · 27 feb 2006

Quilombo zei:
asm is tof
iemand asm tuto die em aanraadt??
zoals killgore zei geeft da idd beter inzicht in hoe een processor werkt, wij zien asm samen bij computerarchitectuur en da wordt parallel gegeven zoda ge begrijpt wat voor wat dient etc.

cobol vin k ook wel neig
da zal wel aan mij ligge ...

http://www.drpaulcarter.com/pcasm/
http://win32assembly.online.fr/tutorials.html
http://webster.cs.ucr.edu/

En meer links:
http://asm.sourceforge.net/
http://grc.com/smgassembly.htm

Nu, wat die Quicksort functies betreft: niet bepaald goede code.

Ze gebruiken extra geheugen om te sorteren. In de Haskell versie zie ik niet meteen een manier om daaraan te ontsnappen (en zal het ook van de interpreter afhangen), maar in C kan het beter. Die int resultaat[lengte] array is echt niet nodig, en bovendien wordt daar veel extra gekopiëerd. De prestaties daarvan gaan echt slecht zijn vergeleken met een fatsoenlijke versie. Lees de eerste drie paragrafen over Quicksort in TAOCP vol. 3 en je weet genoeg om iets beters af te leveren (p. 113-114 in de derde editie). Er zijn nog andere manieren om dit te verbeteren, zoals een meer geavanceerde pivotkeuze en insertion sort voor kleine deellijsten te gebruiken.

De Engelstalige wikipedia geeft betere informatie:
http://en.wikipedia.org/wiki/Quicksort
En de Haskell pagina kan ook interessant zijn:
http://www.haskell.org/haskellwiki/Introduction

En als je iets wil dat echt lastig te begrijpen is

http://www.pedrokroeger.net/weblog/?p=13
(de taal ondersteunt iets niet? Geen probleem, gewoon macro's schrijven tot niemand nog weet in welke taal je eigenlijk bezig bent :oink:

)

QplQyer · 27 feb 2006

Voor een chemicus weet jij toch verdomd veel over informatica wlibaers

wlibaers · 27 feb 2006

QplQyer zei:
Voor een chemicus weet jij toch verdomd veel over informatica wlibaers

Ik ben er al jaren mee bezig als hobby. Bovendien zit ik in de afdeling fysische scheikunde, waar regelmatig nieuwe software nodig is om elektronische apparatuur aan te sturen en gegevens te verwerken. Vermits het vaak geen standaardapparatuur is (of we ze niet op de standaard manieren gebruiken) moeten we die ook zelf schrijven, of updates uitvoeren in oude code in verschillende talen.

killgore · 27 feb 2006

wlibaers zei:
(de taal ondersteunt iets niet? Geen probleem, gewoon macro's schrijven tot niemand nog weet in welke taal je eigenlijk bezig bent )

Lol, ging wel niet over lisp, ma c++, iemand die zei bij uitkomen van hl2 sdk: this guyst don't use fuckin C++ but V++. Die hadden adhv macro's, typedefs, ... eigenlijk op vele gebieden een "nieuwe" taal ontwikkeld

.

Hale · 27 feb 2006

om nog even terug te komen op die haskell :

het interessante aan die taal is eigenlijk het achterliggende gedachtengoed/ paradigma : nl. functioneel programmeren. In functionele programma's bestaat alles uit functies en vooral : die functies vertonen geen side-effects. Wat wil dat zeggen : een functie doet niks anders dan een return value berekenen. Ze past geen argumenten aan, ze past geen globale variabelen aan, er wordt geen state bijgehouden, etc.
Dit leidt tot heel interessante eigenschappen. Zo zal voor een functie f voor een bepaalde variabele x gelden : f(x) = f(x).
Dit lijkt misschien logisch maar is het allesbehalve in een imperatieve taal. volgend stukje pseudo code maakt dit duidelijk :

Code:

global var i = 0;

functie f (int x) 
{
    i = i + 1;
    return x+ i;
}

als je nu f(x) tweemaal oproept met dezelfde x dan zal ze tweemaal een ander resultaat geven. In een functionele stijl/taal kan dit dus niet voorvallen aangezien je daar alleen de returnwaarde mag berekenen en niks anders aanpassen.
Hierdoor kan een compiler vanalles gaan optimaliseren
bv. het volgende stukje code :

Code:

y = f(x) + f(x)

kan vervangen worden door :

Code:

z = f(x)
y = z+z

zodat een mogelijk kostelijke functie oproep maar 1 keer uitgevoerd hoeft te worden.

een ander voordeel is dat je functies thread safe zijn. Je moet niet vanalles liggen synchronized maken zoals je in java zou doen want er is helemaal niets dat kan upf*cken als twee threads tegelijk dezelfde methode uitvoeren. Zulk een taal is dus uitermate geschikt om te parallelliseren.

Als laatste laat het ook toe om je code zogenaamd "lazy" uit te voeren. Een functie wordt pas geëvalueerd wanneer ze daadwerkelijk nodig is. Dit laat je bv toe om oneindige recursieve data structuren te definiëren (bv. oneindig doorlopende bomen ) omdat die niet volledig geëvalueerd worden. Dit is onmogelijk in imperatieve talen.

wlibaers · 1 mrt 2006

killgore zei:
Lol, ging wel niet over lisp, ma c++, iemand die zei bij uitkomen van hl2 sdk: this guyst don't use fuckin C++ but V++. Die hadden adhv macro's, typedefs, ... eigenlijk op vele gebieden een "nieuwe" taal ontwikkeld .

Ooit Bournegol gelezen?

http://www.goof.com/pcg/marc/bournegol.html

Archief - [PROG]/ een gamekkelijke programmeer taal?

Quilombo

Legacy Member

Hasdrubal

Legacy Member

Bubbling Zombie

Legacy Member

Hasdrubal

Legacy Member

Hale

Legacy Member

Hasdrubal

Legacy Member

Hale

Legacy Member

Hasdrubal

Legacy Member

Hale

Legacy Member

Hale

Legacy Member

killgore

Legacy Member

Hale

Legacy Member

Hasdrubal

Legacy Member

Quilombo

Legacy Member

wlibaers

Legacy Member

QplQyer

Legacy Member

wlibaers

Legacy Member

killgore

Legacy Member

Hale

Legacy Member

wlibaers

Legacy Member