Voor een nieuwe taal, Go: https://golang.org

En als je meer "bij de grond wil blijven", dan is de nog experimentele taal V ook heel interessant: https://vlang.io/

Voor de echte puristen is er natuurlijk ook Rust: https://www.rust-lang.org/

Rotzooi (Go).


Kijk, dat is nou een interessante programmeertaal!


Mwah... Not for me... Maar als ik nog system software zou schrijven dan misschien weer wel.

@ Toje Fos,

Ik weet niet in welke richting Anoniem wil gaan programmeren maar als hij interesse heeft in web design dan zijn er natuurlijk javascript (daar moet je echt van af blijven), typescript (dat is oké), elm (dat is zeer krachtig) en als je echt wat anders wil dan is er natuurlijk ook LISP, en dan is de variant Clojure (en clojure-js) daar verreweg de beste van (betaald ook het beste mits je veel ervaring hebt).

Het probleem met Rust is dat de taal nogal lastig te leren heeft en ook dat je veel :: moet schrijven. De taal lijkt mij te veel een ad hoc taal, een combinatie van een functionele taal en een systeemtaal. Het is geen haskell maar ook geen python. En als dan het enige doel is om een veilige taal te hebben, dan lijkt mij V een veel betere taal, maar dat is mijn mening.

Haskell is een elegante taal.
https://www.haskell.org

Je kunt hiermee wiskunde problemen oplossen. Zie bijvoorbeeld het Euler project met vele puzzels.
https://projecteuler.net

Haskell wordt o.a. gebruikt in de financiële sector (fast-trading), waarbij de snelheid van de taal bijzonder hoog is.

C# of java lijke mij de basis.

Onderbouwing?

Er zijn hierboven een paar functionele talen genoemd: Haskell, Lisp, Clojure.

Wat interessant is aan functionele talen is dat ze gebaseerd zijn op een wezenlijk andere manier van denken dan je van andere programmeertalen gewend bent. Daar wat van oppikken kan een verrijking zijn. Me ooit een tijdje in Haskell verdiepen leverde mij bijvoorbeeld op dat ik een ander perspectief kreeg op generators en generator expressions in Python, en ik denk dat dat mijn gebruik daarvan op een hoger plan heeft getrokken.

Haskell is conceptueel lastig omdat het toegepaste wiskunde is van een hoger niveau dan je op de middelbare school meekrijgt. Voor je het weet ben je aan het opzoeken wat categorietheorie eigenlijk inhoudt, omdat je al snel tegenkomt dat concepten in Haskell in termen daarvan worden uitgelegd. Het uit zich ook in hoe de definitie van wat een functie in Haskell wiskundig zuiver gehouden is: het resultaat wordt puur uit de argumenten bepaald, de enige interactie tussen de functie en de buitenwereld van die functie loopt via de argumenten en het resultaat. Een functie is vrij van neveneffecten, in andere woorden.

Dat heeft vergaande consequenties. Een functie kan bijvoorbeeld geen I/O plegen, want iets uit een bestand of een database lezen, of iets naar stdout schrijven, zoals met 'print("Hello world")', is een interactie tussen de functie en de buitenwereld die buiten de argumenten en het aan de aanroeper teruggegeven resultaat om gaat. Dat kan nou juist niet niet in Haskell. Omdat een programmeertaal zonder I/O zinloos is hebben ze bij Haskell de truc bedacht om de buitenwereld niet te zien als iets dat buiten het programma zit maar als iets dat binnen een bijzonder soort objecten leeft.

Ze hebben dat geïmplementeerd met iets dat ze "monads" noemen, maar als je denkt dat je een "monad" snapt in termen van dit gebruik ervan dan sla je wat over, het is maar een van de toepassingen ervan. "Monad" is een concept uit de categorietheorie, en die heb je nodig om ze werkelijk te doorgronden. En dan moet je weer een brug zien te slaan tussen abstracte wiskundige concepten en de praktische toepassingen waar je een programmeertaal voor gebruikt.

Ik haalde op het VWO tienen voor wiskunde, maar aan Haskell had ik een stevige kluif, en ik ben uiteindelijk afgehaakt, na er wel heel veel van geleerd te hebben. Misschien had ik last van die zware conceptuele achtergrond van Haskell omdat ik de neiging heb om erin te duiken, ik wil die achtergrond doorgronden. Wie weet valt het mee voor iemand die genoegen neemt met het leren van de patronen waarmee je het kan gebruiken, maar of dat zo is dat kan ik niet beoordelen.

Met Lisp heb ik maar heel oppervlakkig te maken gehad, maar mijn indruk is dat dat de beschreven striktheid van Haskell niet heeft, en daardoor laagdrempeliger is. Dat zal dan ook voor Clojure gelden, dat is een Lisp-dialect.

Clojure is hier (security.nl) al eens eerder voorbij gekomen, volgens mij. Een nogal obscure haakjestaal (a.k.a. Lisp) [1] die op de Java runtime draait (hosted taal) en het is ook dynamically typed. Maar dat is bv. Python ook en Clojure is wel een gecompileerde taal, met Java interoperabiliteit en functioneel van insteek. Heel krachtig.

[1] https://xkcd.com/297/

Je kunt je prima amuseren met APL (A programming language), die wijkt nogal af van wat als normaal wordt gezien. ;) Vektor/matrix georiënteerde geïnterpreteerde taal. In 1 korte regel kun je bijvoorbeeld een gemiddelde (7 karakters) bepalen van een willekeurige lengte invoer, daar heb je in andere talen veel complexere beschrijvingen voor nodig. Vroeger veel lol mee gehad.

Dat is een kwestie van leren. Maar Clojure is GEEN Lisp, het is vanaf nul begonnen. Het is inderdaad een functionele taal en een taal die draait op inderdaad Java (het kan gewoon Java importeren) en ook .net EN ook op "het www", mbv clojurejs, en dat genereert gewoon javascript code, maar safe javascript EN bij het compileren haalt het ook alle code eruit die niet per se nodig is. Al met al vind ik Clojure een zeer interessante taal, vooral omdat de salarissen hoog zijn als je ervaren bent.

Van https://clojure.org/, 2e alinea, eerste zin:
De makers van Clojure denken er zelf kennelijk anders over.

Super bedankt so far iedereen!

vlang (https://vlang.io/) was mij totaal onbekend, ziet er super leuk uit!

Ik denk dat ik hier mee ga beginnen!

Thanks again!

G++
Go
En Tic Toc .....

COBOL?

Alive and kicking!
https://gnucobol.sourceforge.io/

https://www.security.nl/posting/645208#posting645537


Dat voordeel merkte ik al tijdens leren en gebruik van Clojure op maar met Haskell is het inderdaad nog sterker.


Naah... Je kan prima programmeren in Haskell zonder category theory te beheersen (hoewel ik wel een paar boeken erover heb liggen, dat dan toch weer wel).


Ik heb een paar boeken gekocht en ben er gewoon ingedoken (code schrijven). Je bouwt dan al snel een intuïtie op voor essentiële zaken als Functors, Applicatives, Monads, die je weer kan toetsen aan de boeken en verder verdiepen.


Clojure is dynamically typed en dat lijkt leuk in het begin - zeker als je net zoals ik liever lui dan moe bent - maar mij is het uiteindelijk toch een beetje opgebroken. Het wordt allemaal wat wollig en op een gegeven moment merkte ik dat zelfs de makers van bepaalde libraries zelf eigenlijk niet precies wisten wat er gebeurde (door dat wollige karakter). Daarom ben ik overgestapt op Haskell en merkte uiteindelijk - steile leercurve - dat het gemakkelijker is in Haskell dan in Clojure om bv. code te refactoren en andermans of oude eigen code opnieuw op te pakken.

Good for you. Ik merkte dat het me behoorlijk wat moeite kostte om de andere manier van denken op te pakken. Maar het is heel goed mogelijk dat ik teveel tegelijk probeerde te begrijpen. En mijn brein is duidelijk niet meer zo lenig als toen ik jong was ;-)

voor de leuk..., hobbyproject..., Arduino is leuk! Je kunt er hardware mee besturen :-) Alles opensource