Salut à tous!

Je viens vous présenter mon dernier projet en date (et cette fois-ci, un projet qui fonctionne), ArkScript!

Qui suis-je?

Un petit développeur qui a commencé à apprendre le C puis s'est lancé dans du Python, avant de retourner au langage bas niveau, mais cette fois avec le C++. Je continue de faire du Python (3) et du C++ en parallèle, à chaque besoin son langage. J'aime beaucoup tout ce qui est backend (ce qui explique pourquoi j'ai du mal à finir mes sites web et jeux vidéos sans aide extérieure) et qui bien souvent n'intéresse pas les autres (comme les API, les OS, les langages de programmation, les moteurs de jeux...).

Les origines du projet

L'an dernier, je me suis lancé dans un projet fou: créer un langage de programmation (Kafe). Quel échec cuisant! En effet je suis parti (pas comme un bourrin mais presque) directement coder une VM, en sautant l'étape parsing/compilation en pensant que c'était facile, ayant déjà eu à faire ce genre de choses pour d'autres projets. Que neni! Ma VM était ""bien"" mais j'ai lâché le projet, je n'arrivais pas à me lancer dans ce compilo, et cette VM était mal conçue (très mauvaise gestion de la mémoire et des objets).

J'ai tenté de relancer le projet récemment, je me suis arrêté au parsing. Quelque chose n'allait pas. Peu de temps après je me suis lancé dans toy language, Ark. Juste un petit lisp like tout con, interprété, en 2 semaines. Puis j'ai poussé le délire toujours plus loin, souhaitant faire ce compilo puis une VM. Et ça a marché! J'avais enfin réussi à faire ce que Kafe aurait dû pouvoir faire.

Des objectifs rigolos

(mettre un titre qui change souvent ça attire le regard, vous me direz si je me trompe )

Pour ne pas partir trop n'importe comment, je me suis fixé des objectifs bien différents (en quelque sorte) de ceux de Kafe:

• les features avant les performances (même si elles sont pas laissées en arrière plan)
• un langage fonctionnel, sans classes
• le moins de mots clés possibles, la concision avant tout! Personne n'aime apprendre un n-ieme langage avec 57'786 keywords
• une VM oui, mais pas d'OutOfMemory!
• un langage de scripting qui doit être utilisable dans des jeux vidéos

Ark s'est par la suite renommé ArkScript (pour mettre l'emphase sur le côté scripting et aussi parce qu'un autre langage avait le même nom) (cf la discussion sur reddit)

Des exemples

Un exemple qui utilise les closures, la capture explicite via &, ainsi que le closure field reading via la dot notation, pour répliquer des classes uniquement avec des fonctions, et ce en fonctionnel:

{
    (let create-human (fun (name age weight) {
        # functions can be invoked in the closure scope
        (let set-age (fun (new-age) (set age new-age)))

        # this will be our "constructor"
        (fun (&set-age &name &age &weight) ())
    }))

    (let bob (create-human "Bob" 0 144))
    (let john (create-human "John" 12 15))

    (print bob.age)
    (bob.set-age 10)
    (print bob.age)

    (print john.age)
}

La fonction d'Ackermann qui me sert pour mes benchmarcks, comme elle est récursive non primitive:

{
    (let ackermann (fun (m n) {
        (if (> m 0)
            # then
            (if (= 0 n)
                # then
                (ackermann (- m 1) 1)
                # else
                (ackermann (- m 1) (ackermann m (- n 1)))
            )
            # else
            (+ 1 n)
        )
    }))

    (print (ackermann 3 6))
}

Vous aurez remarqué que le langage est très lisp like, je trouve ça très bien même si je sais que ça peut ne pas plaire à tout le monde, ce qui n'est pas mon but après tout.

L'intérêt d'un langage lisp like c'est la concision (tout ce qui est après une parenthèse ouvrante est une fonction) et la magie: le code lui même est l'AST (arbre syntaxique abstrait) manipulé par le compilateur.

Je vous laisse le GitHub du projet: https://github.com/ArkScript-lang/Ark et le discord du projet où on discute de la spécification ainsi que des évolutions du langage: https://discord.gg/YT5yDwn

-
Edité par Anonyme 11 juillet 2020 à 12:23:50

Bonsoir !

Depuis le dernier post, beaucoup de changements ont eu lieu, que vous pouvez tous retrouver ici: https://github.com/SuperFola/Ark/blob/dev/CHANGELOG.md

Le gros des changements, c'est:

* une équipe qui grossi ! J'étais seul quand j'ai fait le premier post, et maintenant nous sommes 6 !
* un code plus clair, qui sépare exécution (VM) et données (State)
* un REPL (la sauvegarde de scope est en train d'être faite par un de nos contributeurs)
* une bibliothèque standard qui grossi de jour en jour
* une réduction des fonctions standard compile time ! (+ 1 2 3 4) est traité comme (+ 1 (+ 2 (+ 3 4)))
* des améliorations notables en terme de performance
* toujours plus de détections d'erreurs, essentiellement sur les importations cycliques, mais aussi des erreurs plus claires au runtime

Le langage est désormais suffisamment mature pour que l'on puisse coder un forEach directement en ArkScript, sans toucher au code C++, et ça c'est beau quand même

{
(let forEach (fun (L code) {
    (mut i 0)
    (while (< i (len L)) {
        (mut element (@ L i))
        (code)
        (set i (+ 1 i))
    })
}))

(forEach [1 2 3 4] '{
    (print element)
})
}

Long time no see!

Mais je suis porteur de beaucoup de bonnes nouvelles

Tout d'abord, le projet est maintenant dans une organisation dédiée: https://github.com/ArkScript-lang, sur laquelle on a donc le langage en lui même, les modules de bases (en C++), ArkDoc (un doxygen maison pour documenter du code ArkScript), un fork de madureira/String modifié pour le projet (une std::string en plus petit et plus rapide), le code source du site de présentation et de la documentation, et un dev-guide (comparable aux PEP de Python).

Ensuite, nous sommes maintenant 10 à travailler sur ArkScript, dont 3 contributeurs très actifs.

Les avancées sur le projet concernent essentiellement des mises à jour interne à la machine virtuelle et au compilateur, pour la rendre plus rapide (d'où la prolifération de branches orientées optimisations). Une bonne nouvelle est qu'une allocation de liste de 1000 éléments (125 essais) prenait 75µs, seulement 15µs maintenant, et l'usage mémoire global a été diminué. Le compilateur est bien plus rapide également, compiler 10k lignes de code ArkScript prend 14 secondes, contre plusieurs minutes auparavant (le couple lexer/parser va être amélioré pour faire descendre ce nombre encore plus bas).

La lib standard a légèrement été modifiée pour des conventions de nommage et de code mais rien de nouveau de ce côté, justement on attend vos retours, vos cas d'usages, vos questions sur le langage pour l'améliorer!
Alors n'hésitez pas à essayer le langage, il est suffisamment stable pour être utilisé en lieu et place de Lua ou Python par exemple!

La liste complète de ce qui a été changé est ici: https://github.com/ArkScript-lang/Ark/blob/dev/CHANGELOG.md

Bonne journée à tous, en espérant vous revoir utiliser ArkScript

main:007> (if) class Ark::ParseError: ParseError: no more token to consume
On line 1:59, got TokenType::Grouping
 1 | (if)
  | ^
 2 | no more token to consume
Ark::State::doString failed 

main:001> (print a)
unbound variable: a
At IP: 2, PP: 0

main:001> (let a 12) (print (a))
Can't call 'a': it isn't a Function but a Number
At IP: 11, PP: 0

main:012> (import "blabla")
could not load plugin: blabla
At IP: 44, PP: 0

main:013> (import "blabla.ark")
class std::runtime_error: While processing file FILE, couldn't import blabla.ark: file not found
Ark::State::doString failed 

-
Edité par Anonyme 11 juillet 2020 à 12:25:23

-
Edité par PtitloupBey 16 juillet 2020 à 18:35:21

Merci pour vos messages, ça fait plaisir !

Actuellement on travaille sur l'amélioration de la documentation (donc des tutos aussi) du code et de la lib standard, ainsi que sur les tests et les exemples. On aura bientôt assez de stabilité sur cette (très) grosse version pour sortir une nouvelle release, et peut être entamer la 3.1.0 avant la fin de l'année !

Ce que j'aimerai faire avant de publier la prochaine release, c'est fortement améliorer le compilateur pour gérer des unbound variables, de la réduction de constantes dans des expressions (constant folding qu'on dit).