LISP?

Een eigen taal ontwerpen (...) dan gaat de wereld open.

Goede punten, al deel ik "... python het probleem van moeilijke en onleesbare code. En "dwingt" een bepaalde elegantie af" niet echt met je. :D Maar serieus, wat ook meespeelt is dat @ProgHead ook aangeeft dat oplossingen die door anderen met een zekere ontwerpfilosofie zijn bedacht hem vaak weinig kunnen bekoren. Of iets zelf bouwen echt een goed idee is, dat is vooral aan hem om te beoordelen, maar een frisse kijk op het onderwerp van audio en het genereren en bewerken daarvan, en daar iets voor creëren, dat levert voor hem althans wellicht iets op dat hij niet zo gemakkelijk of helemaal niet zal vinden met bestaande tools. Ook iets dat niet zo groot en niet heel complex is kan in de juiste vorm een aha-moment opleveren dat inzicht geeft in de materie waar je mee bezig bent. Ergens proef ik uit de posts van @ProgHead dat het hem vooral daarom te doen is.
 
Goede punten, al deel ik "... python het probleem van moeilijke en onleesbare code. En "dwingt" een bepaalde elegantie af" niet echt met je. :D Maar serieus, wat ook meespeelt is dat @ProgHead ook aangeeft dat oplossingen die door anderen met een zekere ontwerpfilosofie zijn bedacht hem vaak weinig kunnen bekoren. Of iets zelf bouwen echt een goed idee is, dat is vooral aan hem om te beoordelen, maar een frisse kijk op het onderwerp van audio en het genereren en bewerken daarvan, en daar iets voor creëren, dat levert voor hem althans wellicht iets op dat hij niet zo gemakkelijk of helemaal niet zal vinden met bestaande tools. Ook iets dat niet zo groot en niet heel complex is kan in de juiste vorm een aha-moment opleveren dat inzicht geeft in de materie waar je mee bezig bent. Ergens proef ik uit de posts van @ProgHead dat het hem vooral daarom te doen is.
Ja je kan er met python ook een zooitje van maken ;) maar dat was het idee ooit. Een ontwerp filosofie is inderdaad iets wat je niet kan liggen, mijn ervaring is echter dat het met name gewoon flink wat vlieguren maken is en dan zijn de onderdelen van de die ontwerp filosofie echt wel te overkomen. Uiteraard moet hij dat zelf beoordelen. Maar wat ik zo (geheel eigen interpretatie hoor) tussen de regels door lees is het meer een kwestie van de mogelijkheden verminderen en aan de slag gaan :)

Als je kijkt naar tools als Supercollider, tidal Cycles, Max MSP en anderen is juist dat het alle mogelijkheden biedt zeker in het audio spectrum, kijkend naar programmeer talen dan kan je daar echt van alles mee, je eigen Max MSP bouwen of synths of eigen raamwerken. Alles kan. Maar het kan alleen als je er goed mee overweg kan. Dan is de keuze voor C++ een mooie, en tevens niet te makkelijke weg. Je kan je eigen systeem maken met je eigen (ontwerp) filosofie. Al is dat bedenken en vorm geven een van de moeilijkste dingen in het leven.
 
Dank voor de aanvullende discussie. Ik ga nu eerst verder met het bestuderen en oefenen van C++. De grootste hobbel van C++ bestaat voor mij uit die lelijke syntax, dus het is vooral een kwestie van even doorbijten. Heb ook al een boek alleen over die syntax gevonden, en dat maakt heel veel duidelijk. Vooral als ik de gegeven voorbeelden ook zelf uitprobeer.
 
Ja je kan er met python ook een zooitje van maken ;) maar dat was het idee ooit. Een ontwerp filosofie is inderdaad iets wat je niet kan liggen, mijn ervaring is echter dat het met name gewoon flink wat vlieguren maken is en dan zijn de onderdelen van de die ontwerp filosofie echt wel te overkomen. Uiteraard moet hij dat zelf beoordelen. Maar wat ik zo (geheel eigen interpretatie hoor) tussen de regels door lees is het meer een kwestie van de mogelijkheden verminderen en aan de slag gaan :)

Als je kijkt naar tools als Supercollider, tidal Cycles, Max MSP en anderen is juist dat het alle mogelijkheden biedt zeker in het audio spectrum, kijkend naar programmeer talen dan kan je daar echt van alles mee, je eigen Max MSP bouwen of synths of eigen raamwerken. Alles kan. Maar het kan alleen als je er goed mee overweg kan. Dan is de keuze voor C++ een mooie, en tevens niet te makkelijke weg. Je kan je eigen systeem maken met je eigen (ontwerp) filosofie. Al is dat bedenken en vorm geven een van de moeilijkste dingen in het leven.
Dit dus, duizendmaal dit.

Sorry en misschien onvriendelijk berichtje maar vind het oprecht kwalijk om assembly en zelf een programmeertaal te maken voor te stellen aan iemand die nog geen eens *kan* programmeren. Alsof je gaat voorstellen zelf een discrete polyfone synthesizer circuit van scratch te ontwerpen aan iemand die nog niet weet hoe synthesizers werken. Daar help je iemand niet mee. Leuk om samen over te kletsen hier, maar als je merkt dat iemand continu moeite heeft met kiezen en probeert van een lijstje wat dingen uit te sluiten is het misschien niet het moment om 100 keer moeilijkere nieuwe opties toe te gaan voegen. Een complete overschatting van ProgHead's kennis en huidige vaardigheden.

Ja, dat voelt niet fijn ProgHead en betekent ook niet dat je niet intelligent bent en ik zou het anders nooit zo direct zeggen, maar het zou oprecht helpen als je je eigen mening eens op waarde gaat schatten. Je klaagt over lelijke syntax, maar weet helemaal niet wat mooie syntax is.

Een beetje alsof iemand die schilderen leert, die tegen goede schilders klaagt dat de verf niet de juiste ingrediënten heeft. Of dat je wiskunde wilt leren, maar klaagt dat de icoontjes en volgorde van nummers niet logisch zijn. Alsof je probeert te leren hoe je brood bakt - Maar nu al vind dat de oven verkeerd is ontworpen. Een beginnend auto reparateur wat vind dat auto's lelijk in elkaar zitten.

Wat jij vind van hoe de syntax er uit ziet, is op het moment dat je nog niet kan programmeren, een compleet waardeloze mening. Duizenden mensen waarvan velen briljant hebben over de afgelopen 40-50 jaar C++ syntax verbeterd, waarom zou jij weten wat mooie syntax is en zei niet? Leer eerst hoe iets werkt - Ga het dan verbeteren of bekijken wat anders kan, en realiseer je je waar je zelf staat en wat dat zegt over je eigen opvattingen.

Wat je voelt is frictie - Die komt omdat je concepten nog niet helemaal eigen bent en groeiende bent. Jij ervaart die frictie, maar in plaats van te realiseren dat dat aan jou ligt verzin je een reden waarom het aan de programmeertaal ligt en stopt dan meteen met leren en springt naar de volgende. Je voelt frictie omdat het nog niet klikt, niet omdat je zo ontzettend briljant bent dat de programmeertaal het op een slechte of lelijke manier doet.

Alles wat je noemt is door iemand anders bedacht. Alles heeft een eigen ontwerpfilosofie. Nee, zelfs een eigen taal maken is daar geen oplossing voor, ook de hardware heeft een ontwerpfilosofie. C++ heeft kant en klare oplossingen voor vrijwel alle DSP problemen ter wereld. Maar niemand verplicht je die te gebruiken als je eenmaal weet hoe je dat zelf kunt doen.

Je zit op de eerste stijgende lijn van deze typische cognitieve bias - Realiseer je dat en ga eerst (toegepaste!!!) vlieguren maken voordat je je eigen meningen zo serieus neemt over onderwerpen waar je praktisch nog maar weinig ervaring mee hebt. Of niet, niks mis met niet de diepte in willen, maar realiseer je dan wel dat je visie op die diepte er een is van stuurman aan wal.

dunning-kruger-effect-850x560.jpg
 
Laatst gewijzigd:
@Demure Als je het niet verdraagt om mijn mening over de syntax van C++ te lezen dan raad ik je aan om mij in je vijandenlijst te stoppen. Dat scheelt je een boel onnodige ergernis. Ik heb jouw arrogante commentaar op mijn berichtjes ook niet nodig, dus daar is niets aan verloren.
 
Beste @Demure ik denk dat jou bericht echt goed bedoelt is, maar ik lees bij Proghead gewoon een eerste menselijke reactie en eerder dat het gewoon een feit is dat de syntax historisch belast is. Daarnaast schrijft ie dat hij een boek speciaal over de syntax heeft om die basis te accepteren, leren en begrijpen.

Dat gezegd hebbende, niet iedereen heeft door dat als je via de BIAS bij True Expert kennis aankomt niet iedereen realiseert dat je dan toch in een stockholm syndroom zit en binnen een tuintje alles netjes aan kunt harken.
 
Dank @MstrFX. En het is enkel goed en oprecht bedoelt, ik met plezier ProgHead's avonturen over de afgelopen 7 jaar gevolgd en heb het beste voor. Als een student deze vragen stelde en me liet zien waar hij mee bezig was en steevast in zijn eigen schoenen schiet had ik ook zo gereageerd. Mensen op pad helpen in wat ze leuk vinden is een van mijn passies, daarom heb ik ook een lange tijd in educatie gewerkt. Soms vereist dat ook een keer een kritische zelfreflectie over het eigen kunnen als je merkt dat mensen zichzelf in de staart blijven bijten. Vind niemand leuk om te horen, maar arrogant is het niet.

Hoe auto's in elkaar zitten is ook historisch belast, toch ga ik de mening van iemand die nog geen praktische ervaring met auto-ontwerp serieus nemen als het gaat over het mechanisch ontwerp daarvan. Dan is het nog steeds geen goed idee voor te stellen dat hij maar een auto van scratch moet ontwerpen in plaats van eerst gewoon te leren hoe je auto's repareert. Je kunt zien aan de vragen die hij daarna stelt dat dat toch ver boven zijn niveau is. Hij heeft het over geen programma's willen installeren op zijn Linux repo omdat het mogelijk de werking verstoort. Iemand die net "Hello World" in LISP schreef en zich afvroeg of hij een compiler nodig had bij zijn IDE. Niks mis mee en juist goed, allemaal doodnormaal voor iemand die begint of al een tijdje bezig is, maar klinkt niet als iemand die nu op het niveau is te leren hoe je een interpreter schrijft, of zie jij dat anders? Dat soort zaken voorstellen alsof het wel binnen zijn bereik ligt helpt hem niet. Leuk om ver te lezen vast, maar niet om op weg te helpen als je wilt leren programmeren zoals ProgHead zelf zegt.

ProgHead heeft een flinke drive en leest graag (veel!) boeken en kijkt graag tutorials, bewonderingswaardig en heel nuttig, maar heeft weinig praktische vlieguren en de mismatch tussen die twee lees je terug. Dat heb ik vaak genoeg bij studenten gezien toen ik nog les gaf. Om zonder die vlieguren te denken dat je überhaupt een goed idee kan hebben over de historische belasting van C++ syntax is echt vergezocht (niet dat ProgHead dat impliceerde, maar omdat jij er over begint alsof dat de reden voor zijn mening is). Bovendien is het niet de syntax van C++, want uiteindelijk er is altijd wel iets wat niet mooi is of niet werkt zoals ProgHead wiit - Maar het zit 'em er in dat ProgHead af en toe die mening niet opzij wilt zetten etot hij op een positie is waar hij wel dit soort meningen wel kan vormen met enige waarde. In plaats van de conclusie "Huh, dit werkt niet logisch zoals ik zou verwachten" zou het vervolg moeten zijn "Ik vraag me af waarom, ik begrijp vast nog niet waarom dat zo in elkaar zit" in plaats van door te schieten naar "De syntax is lelijk" of dat iets onlogisch zou zijn en dat vervolgens op te sparen als reden om er geen tijd meer in te steken. Dit dus:

Het is nu al zo dat ik blij ben als blijkt dat een zekere taal me om de een of andere reden niet bevalt, want dan hoef daar verder niet al te veel tijd in te steken.

Ik hoop dat je nu doorpakt, zei het C++ of iets anders, het maakt niet uit, zolang je maar iets kiest wat je plezier brengt. Laat je niet tegenhouden omdat de vorm van een functiecall je niet aanstaat of object georiënteerd programmeren niet meteen klikt, ook als je het dan even niet leuk vind. Die keuzes zijn niet zomaar gemaakt en door mensen met vele, vele jaren meer kennis en ervaring dan jij. Zodra je daar daadwerkelijk vlieguren in maakt word schakelen op ten duur een eitje. Je zit dan ook niet aan een taal vast. Die frictie hoort er bij, zoveel is lelijk en onlogisch aan C++ (en elke programmeertaal) als je nog niet gevorderd bent. Ik geloof oprecht dat je boeiende takes gaat hebben op hoe dingen in elkaar steken, hoop die ook ooit te lezen. Het is aan niemand om je te vertellen hoe je je tijd moet besteden, dat doe ik ook niet, het is enkel advies voor als je dit oprecht wilt leren.
 
Sorry en misschien onvriendelijk berichtje maar vind het oprecht kwalijk om assembly en zelf een programmeertaal te maken voor te stellen aan iemand die nog geen eens *kan* programmeren.

Behalve dat @ProgHead het zelf noemde kan ik geen bericht in dit draadje vinden waarin iemand hem assembly voorstelde. Kun je dat even citeren?

Verder weten we niet exact wat @ProgHead wel of niet kan, qua programmeren. Hij heeft hier op het forum wel 'ns wat dingen laten zien, het is niet zo dat hij helemaal niks kan. En we weten al helemaal niet hoe z'n skills kunnen ontwikkelen in de toekomst. Zelf een taal creëren, en dat kan in verschillende gradaties van complexiteit natuurlijk, het hoeft ook niet meteen op dit moment. Sterker nog, @ProgHead zei dat hij wil doorgaan met C++, daarop zei ik:

Als je C++ voldoende onder de knie hebt, daar zou het prima mee kunnen.

Dat zegt het eigenlijk al.
 
Het is eigenlijk best eenvoudig, programmeren is taal, en er gaat veel creativiteit zitten in het maken van dingen met taal, hetzij een oplossing voor een probleem, kunst en alles wat er tussen zit. Het is dus vooral beter worden in schrijven door veel te doen. Zodat het makkelijker wordt om je ideeën om te zetten in projecten, van experimenteren tot iets dat je als af kan beschouwen. Een boek, dichtbundel of een stuk Muziek is. Hoe goed je je idee gecommuniceerd krijgt is afhankelijk van je taal niveau. In het geval van een computer is het het communiceren via de machine. Daar hebben we in de afgelopen 80 jaar goede vooruitgang in geboekt zodat je als schrijver niet terug hoeft te vertalen naar machinetaal. Dus een eigen taal verzinnen om die laatste slag “eenvoudiger” te laten zijn tijdens het schrijven is wat al gedaan is en goed ook. Ik zou daar van profiteren en de focus volledig op de kunst van het schrijven leggen. Dat levert vanzelf de vrijheid op die gezocht wordt. Zitten er allerlei “voorbedachte” zaken in? Zeker, maar die hoef je niet te gebruiken. Sterker je kan in al die talen van C++ via supercollider, MAX MSP enzovoorts zelfs een eigen taal als proxy maken en daarachter de functie gebruiken die je of zelf maakt of er al in zit. Is dat nuttig, voor mij niet. Maar als de eigen taal dat kan bieden kan het wel. Ik vraag mij af of het de oplossing is. Het bedenken en doorvoeren van een bepaalde ontwerp filosofie & manier van experimenteren kan ook zonder problemen in al die tools mits je de taal afdoende beheerst.

Het is overigens wel een interessant discussie hoe je een (ontwerp)filosofie kan uitten, en hoe je de juiste tools kan selecteren. Mijn ervaring is daarin eerst wat lezen, soms manuals, tegenwoordig vaker tutorials, en dan al snel gaan werken met het instrument, de taal, het papier of wat het ook maar mag zijn. En dan blijkt voor mij iedere keer weer dat het uitgangspunt voor een project (of je filosofie) vaak het moeilijkste te bepalen is. En dat je als je je gereedschap gewoon kiest en leert, je alles er in kwijt kan. Of dat nu een compleet nieuwe set aan gereedschap is, of iets wat ik al langer heb. In het geval van nieuw gereedschap is het leren van het gereedschap onderdeel van de lol en de reis. Bij oude vertrouwde dingen is het meer met een schone lei beginnen en een ander uitgangspunt kiezen. Wat ik ook doe ik moet over die eerste hobbel heen zijn gegaan, de leercurve, om verder te kunnen.
 
Laatst gewijzigd:
Ik ga verder met C++ leren, of ik die taal nu mooi of lelijk vind. En wel om reden dat die taal in audio software een centrale rol blijkt te spelen. Ik wil bij mijn software avondturen weten wat er onder motorkap gebeurt en dan kom je bijna altijd weer uit op C++ (of C). Dus is het nu zaak om door te pakken.
 
Laat je niet tegenhouden omdat de vorm van een functiecall je niet aanstaat of object georiënteerd programmeren niet meteen klikt, ook als je het dan even niet leuk vind. Die keuzes zijn niet zomaar gemaakt en door mensen met vele, vele jaren meer kennis en ervaring dan jij.
Of er moest even snel een beslissing genomen worden en de minst erge optie was degene die je zag ;) Ook programmeertalen lijden aan voortschrijdend inzicht.
Zodra je daar daadwerkelijk vlieguren in maakt word schakelen op ten duur een eitje. Je zit dan ook niet aan een taal vast. Die frictie hoort er bij, zoveel is lelijk en onlogisch aan C++ (en elke programmeertaal) als je nog niet gevorderd bent.
Ik vind C++ inderdaad niet echt de netste taal. C# ziet er stukken beter uit, maar heeft ook veel minder bagage in vergelijking, alleen gaat niemand dat in een kernel stoppen.

Ik ga verder met C++ leren, of ik die taal nu mooi of lelijk vind. En wel om reden dat die taal in audio software een centrale rol blijkt te spelen. Ik wil bij mijn software avondturen weten wat er onder motorkap gebeurt en dan kom je bijna altijd weer uit op C++ (of C). Dus is het nu zaak om door te pakken.
Ik heb de rest niet helemaal gevolgd want we zitten volgens mij in totaal al op een hele ris pagina's, dus het is wellicht overbodig.

De volgende basis-aannames zijn bekend. Digitale audio is een stroom van bitjes. De taak is om die bitjes - linksom of rechtsom - naar een DAC te krijgen zodat je een voltage krijgt. Dat kun je dan naar je speaker sturen zodat er iets gaat trillen zodat je iets kunt horen.

Je kunt een zaagtand-oscillator bouwen door iets te maken wat van -32,768 to +32,767 telt (en dan weer terug bij af begint). Als je 44100 keer per seconde een getal naar de DAC stuurt heb je dan een zaagtandgolf. Iets naar de DAC sturen is niks anders als op tijd er voor zorgen dat er een bepaalde waarde in het geheugen staat wat de DAC moet uitlezen.

Dit is letterlijk hoe je op een Commodore 64 muziek maakt. Schrijf dingen naar een geheugenlocatie, en de SID pikt dit op en doet de rest. Doe dit op de juiste tijd, en het resultaat klinkt ook nog eens muzikaal.

Het is net een fabriek die elke dag een vrachtwagen aan widgets moet maken. Het maakt niks uit of de werknemers 1 uurtje bezig zijn en de rest van de dag niks doen, of dat ze pas om 5 voor 12 's nachts klaar zijn met het werk; om 00:00 staat de vrachtwagen er en die moet vol zijn. Zo niet, dan krijg je stukken stilte in de audio (het geheugen van de DAC wordt na aflevering op 0 gezet) of digitaal geschreeuw (het geheugen van de DAC was nog vol met de oude inhoud en die wordt nu weer uitgelezen; denk aan een korte sample die je loopt).

Helaas is het allemaal niet zo simpel, want je bent niet alleen.

Tijdens het maken van je zaagtand moet een computer nog een ris andere dingen doen. Je mag niet zomaar naar willekeurige stukken geheugen schrijven; om er voor te zorgen dat alles netjes gaat krijg je een stel functies aangeboden die dat voor je faciliteren. Ook die functies geven van alles van software-laag naar software-laag door, dus wie weet wat ze op de achtergrond doen. Da's ook interessant, maar dan mag je dus dingen doen zoals [drivers leren schrijven](https://www.youtube.com/watch?v=juGNPLdjLH4). Ook weer een hele andere tak van sport, en ook weer iets waar een hoop werk al voor je gedaan kan zijn.

In de tussentijd wil je ook nog even kijken of er misschien iemand aan de virtuele knoppen draait; en als die de frequentie van de zaagtand aanpast wil je natuurlijk wel een ander setje bitjes naar je DAC sturen.

Het grote verschil met een scripttaal zoals Python is dat Python start en weer stopt en in de tussentijd allerhande dingen gedaan heeft. LISP heeft dit letterlijk in de naam zitten - LISt Processing.

Bij een applicatie (en of dat nu een plugin of een spel of iets anders is) ben je continu aan de gang; er wordt een loop opgestart en in die loop doe je werk. Je controleert - zit er iemand aan de user interface knoppen te draaien? Moet ik nu wat naar de DAC sturen? Mag ik nu een aantal nanoseconden spenderen aan het uitrekenen van het volgende blokje golfvorm?

Iets als JUCE neemt je dat soort dingen uit handen, en dat betekent dat je dan eerst even al je energie kan steken in leren hoe DSP werkt.

Alles tegelijk proberen te leren is een goede manier om niks te leren ;)
 
Het grote verschil met een scripttaal zoals Python is dat Python start en weer stopt en in de tussentijd allerhande dingen gedaan heeft. LISP heeft dit letterlijk in de naam zitten - LISt Processing.

Bij een applicatie (en of dat nu een plugin of een spel of iets anders is) ben je continu aan de gang; er wordt een loop opgestart en in die loop doe je werk. Je controleert - zit er iemand aan de user interface knoppen te draaien? Moet ik nu wat naar de DAC sturen? Mag ik nu een aantal nanoseconden spenderen aan het uitrekenen van het volgende blokje golfvorm?
Waarbij je met een main loop in scripttalen ook wel continue functionaliteit kan creëren. Ik heb zowel one-shot Python scripts als programma's met een GUI waar je als je wilt uren in bezig kan blijven als gebruiker.

Een flinke uitdaging, als je het van de grond wil opbouwen, is inderdaad voldoende ongestoorde continuiteit van kritische taken. Bij outputs zit je dan al snel met buffers, bij inputs met interrupts, en als alles een interrupt is, is niks een interrupt, etc.
 
Ik blijf erbij , de beste manier om echt audio dsp te leren is reaktor core .

Gebruik geen macro’s maar enkel de lowest level core modules , dat zijn er maar een 30-tal , van bitwise logi operators to mem read.write , arrays , tables and sr.c sr.r clocking etc…

Eens je het snapt is het vrij simpel om je opgedane kennis te converteren naar eender welk programma , en vice versa
 
Back
Top