RobW schreef:
De weg van Tao ken ik niet dus kan ik die vraag niet goed beantwoorden.
Wat ik wel weet is dat ik een bijna natuurlijke weerstand heb met me ergens bij aan [te] sluiten.
Jij bent programmeur toch? (of geweest?)
De weg van de Tao is kunnen programmeren. Niet het kennen, niet het weten, maar het
kunnen.
(Daar mag je best even over nadenken, over dat
kunnen programmeren. Zodra je dat beheerst, ben je in staat
jezelf te programmeren namelijk. Maar wanneer kun je programmeren? Pas als je jezelf kent, natuurlijk.)
Ofwel weten, snappen, kunnen begrijpen, wat programmeren is.
In samenhang, synergie zelfs, met de hardware, zodat je programma uiteindelijk doet wat je wilt. "Debuggen" is te kostbaar, dus je schrijft je programma met alle mogelijke toestanden, inclusief de acties die genomen moeten worden op "verboden" of "onmogelijke" toestanden, die neem je allemaal mee.
Dat kost tijd, en omdat tijd geld is, en er snel, en vooral veel, geld verdiend moet worden, moet een programma, zodra het "compiled" op de markt.
("Ja maar het is nog niet af!" - "Maakt niet uit, als het niet werkt zoals wij zeggen, ontslaan we je wel, hebben we een zondebok voor de commercie. En na jou, nog veel meer." Het lijkt wel de zondvloed.)
Dat is nog tot daar aan toe. De consument als "alpha-tester".
(Vroeger kwamen er nog wel eens Beta's op de markt)
De werkelijke weerstand die je voelt, komt voort uit het feit dat je vaak genoodzaakt wordt te moeten (leren) programmeren in Pascal.
Weg vrijheid, weg klooien met pointers, weg creativiteit.
Weg begrip van de onderliggende architectuur.
Is dat erg? Nee en Ja.
Voor mij wel, ik heb nog in assembly geprogrammeerd (als hobby en studie) en kende mijn machine van haver tot gort. Ik heb klunzen van fouten gemaakt en ervan geleerd.
Maar de huidige, moderne, programmeur programmeert architectuur-onafhankelijk. (Kolder! Waarom zou dat moeten? Is het geld-gerelateerd?)
Met alle (rampzalige) gevolgen van dien?
(Er is schijnbaar een zeer diep vertrouwen dat de libraries doen wat ze moeten doen. Tot het punt dat het schrijven van die bibliotheken nog slechts op de schouders van enkele personen berust. Nou wil ik niet paranoide overkomen, maar ik vertrouw tegenwoordig helemaal niets meer, dat zich niet debuggen laat. Of de broncode niet (vrijelijk) van beschikbaar is.)
En, "Nee", het is ook niet erg, want Pascal leert je een stramien van programmeren aan. Zelfs in Pascal is het mogelijk "klunzen van fouten" te begaan.
Toen kwam Java.
En nu is Python helemaal hot.
Het maken van fouten is verplaatst, de bedoeling van al die hardware-afschermende talen was juist om fouten te voorkomen.
Het is weer niets anders dan BASIC. De intelligentie schuilt in de programmeur.
Voer eens een eenvoudige test uit: programmeer in de programmeertaal van je keuze eens: x "wordt" x/y*z (zonder gebruik van haakjes) waarbij x=1 en y en z=9.
Zodat er eigenlijk staat: 1/9 * 9 = x
Ik kan je nu al garanderen, dat je bij elke taal andere antwoorden voor x krijgt, variërend van 0,1234567901 tot 0,999999999 tot 1.
(Probeer het eens op een moderne (goedkope) rekenmachine, zonder haakjes-toetsen)
Waarom dat zo is, ligt aan de combinatie programmeur, programmeertaal, architectuur en het begrip van elkaar. En de desinteresse.
Toch is het mogelijk altijd het juiste antwoord te krijgen, binnen elke programmeertaal. (Weet jij wat het is?)
Hoe? Dat laat ik als puzzeltje voor je achter.
Want niets is fijner dan zelf dingen te ontdekken, vind ik.
Dat computers, en dan bedoel ik smartphones, over het algemeen goed werken, wijd ik louter aan toeval. Ik moest vandaag weer iemand uitleggen waarom ik niet al haar contacten kon terughalen, omdat er een bug zat in de software. Ik zei: "U vertrouwt er teveel op". Haar antwoord was: "Waarom wordt het dan verkocht?" Ik zei: "Omdat het gekocht wordt, heeft u zin in een rechtszaak?" Nee, dat was teveel gedoe.
En zo herhalen de dingen zich en blijven we altijd in het mediocre.
En, om nog even op de Tao terug te komen, Tao, is ook debuggen.
Het is de kunst fouten -of fouten, beter lijkt mij misverstanden- te kunnen
herkennen, tussen programma, compiler en architectuur. Als je dan weet de fouten eruit te halen, zodat het programma doet wat het beoogt te moeten doen, dan ben je ATARI-expert, en krijg je nooit te maken met:
Want een echte Guru hoeft natuurlijk niet meer te mediteren, dat doen zijn volgers wel voor hem.
En dat is, volgens mij, de weg van de Tao: jezelf
kunnen (her)programmeren (mocht dat nodig zijn).
Eerste noodzaak is dan je architectuur goed te kennen: te weten wie je bent.
Zoals mijn onderschrift al schrijft.
Hoe doe je dat? Door jezelf te "debuggen", de fouten uit je programma's te halen ... een levenstaak soms toch wel, maar twijfel nooit aan je microcode, als iemand je zegt dat je die moet veranderen, wens hem dan naar de hel. Want dan probeert diegene jou te bezitten en ziet je echt slechts als machine.
Jezelf begrijpen kan natuurlijk op diverse manieren. Alleen komen ze altijd op hetzelfde neer: je probeert je software aan de hardware aan te passen, of andersom, de hardware aan de software aan te passen.
Dat laatste is over het algemeen wat lastiger, gegeven het feit dat je nu eenmaal in het lichaam zit waarin je zit, met alle beperkingen van dien.
Wat nog wel kan is de "wetware" leren kennen, als architectuur.
Of nog nog erger, de microcode ervan proberen te ontcijferen: de code die individuen tot individu maakt.
Maar ik begrijp zelf ook wel dat dit een veel te mechanische kijk is op de wereld.
Beter is het gewoon je in het dagelijks leven te bedienen van een X-de generatie programmeertaal, en te kijken of de programma's waarmee je te maken hebt wel bepaalde bibliotheken hebben meegelinkt, tijdens het compileren.
#pragma me
#ifdef GOD
#undef GOD
#endif
Kunnen we eindelijk eens gaan filosoferen.
Want in God.h staat:
#define GOD DEITY
#ifdef GOD
#define me DEITY
#endif
En dat is circulair. Elke compiler geeft een error. Werkt op geen enkele architectuur, behalve als je opgeeft "--ignore-errors".
Uiteindelijk valt het te linken tot een ELF of .EXE die gelijk een error #14 segment fault geeft, of een "Dit programma is afgesloten, wilt U online naar een oplossing zoeken?" (je krijgt natuurlijk nooit antwoord, maar dat heb ik al eerder ergens uitgelegd).
En daar durf ik geen programma op uit te voeren, als ik de wetware al niet vertrouw, kan de hardware dan wel goed zijn?
Het lijkt me meer zulks:
#pragma LIFE
#ifdef SOMA
#include STOA
Maar dat zijn nog steeds allemaal aanwijzingen voor de compiler.
En die ben je uiteindelijk zelf.
Jij moet de diverse programma's waarmee je te maken krijgt, zien te compileren naar een werkende versie op jouw architectuur.
En, pragma's daargelaten, jij weet hoe je processor werkt, als het goed is.
Zodat je met de diverse pragma's weet om te gaan.
Waarmee ik bedoel, ze weet te bevragen. Zodat je kan vragen kan stellen in de trant van: Binnen jouw pragmatiek schijnt x gelijk te zijn aan y, kun je me ook uitleggen waarom?
Als je dan een verdoofde blik, of een mond vol tanden tegenkomt, weet je dat het antwoord "nee" is. Helaas weet het "slachtoffer" dat vaak zelf niet, en blaast zichzelf dan op. (Kan zowel letterlijk als figuurlijk)
Ruzie en onenigheid is dan je deel.
De weg van de Tao is (mijns inziens weliswaar) je gesprekspartner te laten inzien in welke gaten hij trapt: de gaten die openliggen, de gaten die in de blinde vlek liggen, en de gaten die voor een ander zijn gemaakt.
Dat kan soms pijn doen, als hij opeens beseft in zijn eigen gat te zijn getrapt.
Hier is mijn hand, ik help je eruit, de rest mag je zelf doen.
En als je niemand meer hebt, kun je het altijd nog zelf doen.
(Zoals yopi zegt, in zijn onderschrift)
Jezelf bij je haren uit het moeras trekken.
Er is alleen een zeer sterke persoonlijkheid voor nodig om dat te kunnen.
Beter lijkt het mij geen moeras te willen, kun je er niet in verzuipen ook.
Misschien vergt dat wel een onverschillige geest.
Maar dat is weer een heel ander verhaal.
Dat: als orde en chaos tegelijkertijd regeren, wellicht op dit moment wel verteld wordt.
Nu, waar je bij zit.
Zonder begin, zonder einde en derhalve zonder midden.
Dus zoek er maar niet naar, dat midden, want je kent de uitersten niet.
Leef: doe wat je doet, kijk niet naar de TV en laat altijd gelden wat je uit jezelf denkt dat goed is.
Zelfs als je eigen gedachten je tegen de borst stuiten, of je tegen je indoctrinatie in moet gaan.
Dan ben je tenminste eindelijk eens jezelf.
Handel daar eens naar.
Ik wil wel eens weten hoe egoïstisch of altruïstisch de "maatschappij" dan is.
Bovendien vraag ik me af wie het oordeel kan vellen.
HM
Democratie als veroorzaker en oplossing.
Eigenaardig.
