[func/decl prog] wat voor debugging/how features?

[Alarmnummer]

In een taal zoals prolog/haskell/clean gebruik je natuurlijk een hele collectie aan functies/predicaten. Maar welke manieren zijn er om te kunnen how`en? Zodat je je redenatie kan volgen.

Een how tree laten zien is niet altijd praktisch omdat door een enorme hoeveelheid van aanroepen deze niet meer overzichtelijk is.

ik heb een (heel) oud voorbeeld op mijn website staan van een simpele how tree.

http://www.geocities.com/peter_veentjer en dan personal/projects/expertsysteem.

Ik vraag me af of hier bepaalde technieken voor zijn ontwikkeld.

ps: traces en spypoints lijken me niet altijd even zinvol door de grote hoeveelheid aanroepen.. of zit ik nu te veel te vragen?

[mbravenboer]

In functionele programmeertalen (wat Prolog IMHO dus niet is, zoals ik al een paar heb gezegd ) is er helemaal geen redenatie. In functionele talen worden gewoon simpel functies geevalueerd en is er helemaal geen redenatie-algoritme of wat dan ook. Als je Haskell gebruikt kan je onder andere gewoon de zaak tracen:

Tracing debuggers present to the user a view of the step (reductions) that the Haskell internal graph goes through while evaluating.

Je volgt dus in feite gewoon de evaluatie. Hier is niets mystieks of intelligents aan .

Hier een hele pagina over Haskell debugging etc:
http://www.haskell.org/debugging/

[Alarmnummer]

ik had al een aantal dingen doorgekeken en ik vraag me af in hoeverre stepping handig is (bij een groot aantal functies) Hierdoor raak ik het overzicht in ieder geval kwijt.

Misschien zou unit testing van functies/predicaten iets zijn

ps: topic kan misschien [func/decl prog]debugging/how features heten

[MaxxRide]

Prolog lijkt me iid een typisch geval van LOGISCHE programmeertaal.

[Alarmnummer]

Op dinsdag 12 februari 2002 22:51 schreef Pinda het volgende:
Prolog lijkt me iid een typisch geval van LOGISCHE programmeertaal.

ach.. in prolog kan je ook functies maken zelfs met meerdere return waardes

Maar je kan in prolog niet zo met functie types omgaan zoals in haskell

[mbravenboer]

Alarmnummer: ik had al een aantal dingen doorgekeken en ik vraag me af in hoeverre stepping handig is (bij een groot aantal functies)

Tja, als je evaluatie wilt volgen kan je denk ik niet veel anders...

Misschien zou unit testing van functies/predicaten iets zijn

Er zijn al ontzettend veel unit-testing omgevingen voor declaratieve talen. Een unit-testing omgeving zoals JUnit is eigenlijk zeer eenvoudig, dus het is vrij makkelijk om dit te maken voor jouw lievelings-taaltje .

Voor Haskell heb ik even gezocht:
http://www.haskell.org/wiki/wiki?UnitTesting

ps: topic kan misschien [func/decl prog]debugging/how features heten

done .

[mbravenboer]

Alarmnummer: ach.. in prolog kan je ook functies maken zelfs met meerdere return waardes

Nee, dat typeert een functionele taal .

Maar je kan in prolog niet zo met functie types omgaan zoals in haskell

Juistum .

[Alarmnummer]

Op dinsdag 12 februari 2002 23:00 schreef mbravenboer het volgende:
Nee, dat typeert een functionele taal .

door de matching functionaliteit kun je in prolog een predicaat ook zien als een functie

[mbravenboer]

Alarmnummer: door de matching functionaliteit kun je in prolog een predicaat ook zien als een functie

Tja, het gaat nu eenmaal niet zozeer om de functies, maar om wat je allemaal met een functie kunt doen . Over het algemeen bedoelt men met een functionele taal een pure hogere-orde functionele taal en dat is het in ieder geval niet. Uiteraard zitten er wel overeenkomstige ideeen in, maar dat volgt meer uit het feit dat ze beide niet imperatief zijn...

[Alarmnummer]

Op dinsdag 12 februari 2002 23:08 schreef mbravenboer het volgende:

[..]

Tja, het gaat nu eenmaal niet zozeer om de functies, maar om wat je allemaal met een functie kunt doen . Over het algemeen bedoelt men met een functionele taal een pure hogere-orde functionele taal en dat is het in ieder geval niet. Uiteraard zitten er wel overeenkomstige ideeen in, maar dat volgt meer uit het feit dat ze beide niet imperatief zijn...

Dat weet ik, doordat je met functies op een hele andere manier kan omgaan (bv meegeven van een functie als argument, paritiele parametrisatie) is haskell veel 'functioneler' dan prolog. Maar het argument dat return waardes alleen een functionele talen hoort is niet correct (alleen beetje gekke notatie )

[mbravenboer]

Alarmnummer: Maar het argument dat return waardes alleen een functionele talen hoort is niet correct

* mbravenboer zoekt waar dat genoemd is .

[Alarmnummer]

maar om weer even ontopic te komen

hoe kun je duidelijk maken hoe het verloop van je functies is gegaan bij een groot aantal functie aanroepen? Zodat je wat meer inzicht kan krijgen.

[mbravenboer]

Alarmnummer: hoe kun je duidelijk maken hoe het verloop van je functies is gegaan bij een groot aantal functie aanroepen?

Ik denk dat je beter even op het web kan zoeken naar wetenschappelijke literatuur over debugging en profiling technieken. Er is al ontzettend veel onderzoek naar visualisatie van evaluatie gedaan... Ik denk niet dat het erg effectief is om hier naar ideeen te zoeken .

Op welk paradigma/taal doel je specifiek? De pagina die ik hierboven postte kan je al gebruiken als startpunt voor hogere-orde functionele talen.

[Alarmnummer]

Ik heb er zelf wel wat ideeen over: bv door een bepaalde functie (dus de definitie) op het scherm te zetten en dan alle referenties naar andere functies een hyperlink te maken en als je daarop klikt dat je hierbinnen het verloop kan zien. Voor variablen geld hetzelfde, kun je zien hoe ze aan hun antwoord zijn gekomen.

vb
a=1
b=2
c=a+b

goal c

je ziet nu:
c=a+b=3 (met een hyperlink onder a en b)

dan klik je op a
en zie je:
a=3

[edit] te weinig gecopieerd

[Alarmnummer]

voor de taal van het expertsysteem. Zitten wat elementen van haskell in (ga binnenkort aan de slag met functies als argumenten) en zit wat prolog ideeen in.

Maar het nalopen van functie verloop is in beide talen vrijwel hetzelde. (zitten natuurlijk wel heeele grote verschillen in, maar het aanroepen van functies/predicaten is in veel opzichten hetzelfde).