Une prise en main rapide
Algorab permet aux étudiants de rapidement commencer la pratique en étant facile à installer sur toutes les plateformes, simple d'utilisation et doté d'une syntaxe concise permettant ainsi aux enseignants de gagner du temps sur les premiers cours.
println("Hello World")val name = ask("What's your name?")println("Hello $name!")print("Hello World")name = input("What's your name?")print(f"Hello {name}!")printf("Hello World\n");char word[256];fgets(word, sizeof(word), stdin);printf("Hello %s!\n");Hello WorldWhat's your name?AliceHello Alice!Un langage expressif
La plupart des algorithmes et structures de données sont fastidieux à écrire dans des langages tels que Python, C ou Java sans être forcément faciles à relire. Algorab importe des concepts issus de la programmation fonctionnelle tels que les types algébriques de données et le pattern matching pour rendre claire et concise l'expression des problèmes classiques d'algorithmie.
enum LinkedList[A]: case Empty case Node(head: A, tail: LinkedList[A]) def append(element: A): LinkedList[A] = this match case Empty then Node(head, Empty) case Node(head, tail) then Node(head, tail.append(element))class LinkedList: def append(self, element): pass class Empty(LinkedList): def append(self, element): return Node(element, Empty()) class Node(LinkedList): def __init__(self, head, tail): self.head = head self.tail = tail def append(self, element): return Node(self.head, self.tail.append(element))#include <stdlib.h>typedef struct Node { int head; struct Node *tail;} LinkedList;LinkedList *createNode(int head, LinkedList *tail) { LinkedList *result = malloc(sizeof(LinkedList)); result->head = head; result->tail = tail; return result;}LinkedList *append(LinkedList *list, int element) { if(list == NULL) return createNode(element, list); else return createNode(list->head, append(list->tail, element));}Un accompagnement actif des étudiants dans leur apprentissage
La plupart des langages de programmation ne mettent pas à disposition les outils nécessaires à l'autonomie des débutants, ce qui les fait décrocher et donc perdre du temps de cours, faute d'aide suffisante du langage. Algorab dispose de messages d'erreurs précis et clairs. L'étudiant peut ainsi dialoguer avec le langage pour comprendre et résoudre de lui-même son problème.
record User(name: String, age: Int)val user = User("John", 20)println("Hello ${user.username} !")Error: Unknown record field.At ./myscript.algo, line 4, character 22println("Hello ${user.username} !") ^^^^^^^^^^^^^Hint: user is of type User. Did you mean user.name?Une meilleure professionnalisation
Algorab incite à l'utilisation de bonnes pratiques de programmation comme la gestion des erreurs, le nommage correct, l'ajout de commentaires ou l'écriture de tests. Les étudiants acquièrent ainsi des compétences applicables aux langages utilisés dans le monde professionnel.
---Create a new user.- param name the user's name. Should not be empty.- param age the user's age. Should be positive.- return a new User with the given fields.---def createUser(name: String, age: Int): User can Throw[UserError] = if name.isBlank then throw(UserError.BlankName) else if age < 0 then throw(UserError.NegativeAge) else User(name, age)test createUser with assertEquals(createUser("Sofia", 23), User("Sofia", 23)) assertThrows(createUser("", 23), UserError.BlankName) assertThrows(createUser("Sofia", -23), UserError.NegativeAge)Tableau comparatif
| Fonctionnalité |  Python |  C | Algorab |
|---|---|---|---|
| Typage statique fort | |||
| Erreurs claires | |||
| Expressivité | |||
| Enseignement des bonnes pratiques | |||
| Écosystème riche |