Ιστορικά Στοιχεία


5-7-2020
Η γλώσσα έχει ολοκληρωθεί και λειτουργεί σε Windows και Wine (Linux).

Ποιος έγραψε το κώδικα:
Η ιδέα και ο περισσότερος κώδικας είναι γραμμένος από τον Γιώργο Καρρά, Τεχνολόγο Πετρελαίων ΤΕΙ Καβάλας.

Στο κώδικα της γλώσσας περιλαμβάνονται ρουτίνες που έχουν γράψει άλλοι, για κοινές εργασίες όπως π.χ. για να αποθηκεύουμε σε jpg αρχεία. Ο κώδικας είναι ανοικτός από την πέμπτη έκδοση και θα παραμείνει έτσι. Πολλές ιδέες βρέθηκαν στο Vbforums.

Βασική Ιδέα:
Τη δεκαετία του '80, στο Χολαργό, και την εποχή των micro (μικροϋπολογιστές)  των 8bit, είχα την πρώτη επαφή με γλώσσες προγραμματισμού, αρχικά με την Ti Basic, και μετά με την BBC Basic. Στη διαδρομή αγόρασα την Forth, και διάβασα Pascal, Modula 2, και κάποια στιγμή έπεσε στα χέρια μου ένας διερμηνευτής για Pilot, μια απλή γλώσσα για κουίζ, καθώς και κώδικας για την Lisa (πρόγραμμα τεχνητής νοημοσύνης). Μου φάνηκε ότι μπορούσα να φτιάξω έναν διερμηνευτή για Fortran, για δοκιμή, στον Electron (32 kbyte μνήμη). Έπαιζε αλλά με λίγες μεταβλητές, που έπρεπε να υπήρχαν ήδη στο κώδικα, χωρίς ιδιαίτερο evaluator, μόνο με χρήση της Eval() που είχε η BBC Basic
Την δεκαετία του '90 είχα έναν Atari 520Ste και την GFA Basic που έβγαζε εκτελέσιμο αρχείο (Διερμηνευτής και Μεταφραστής για εκτελέσιμο).  Τότε έγραψα και τον evaluator σε μια νέα γλώσσα την GEORGE (τίποτα δεν είναι τυχαίο). Σε αυτήν πάντρεψα την Basic με την Forth. Μπορούσε κανείς να αυξήσει το λεξιλόγιο, με λέξεις - τμήματα, και να χρησιμοποιήσει έναν σωρό τιμών  (αυτή η ιδέα παίζει στη Μ2000). Το 1996 αγόρασα το πρώτο PC (δεν είχα χρήματα πριν για κάτι τέτοιο, και συνάμα είχα και οικογένεια με δυο παιδιά τότε και είχα μετακομίσει στην Πρέβεζα).

Το 1998-1999 ήμουν γραμματέας της Λέσχης Πληροφορικής Πρέβεζας, και είχα συγγράψει μαζί με τον Δρ. Γκούβα το βιβλίο "Η ιστορία της Πληροφορικής" , βιβλίο που μοιράστηκε δωρεάν στους μαθητές όλου του νομού (δώσαμε τα δικαιώματα στον εκδότη για 5000 βιβλία, και ακόμα το πουλάνε). Από την ασχολία μου αυτή, ήρθε και η ιδέα για μια γλώσσα για Μαθητές!

Το 1999 έπεσε στα χέρια μου ένα αντίγραφο της Visual Basic 5 και άρχισα τις πρώτες δοκιμές για την Μ2000.  Δεν υπήρχε βέβαια τρόπος να βρω πληροφόρηση από το κανονικό κανάλι (ήθελε συνδρομή που δεν είχα να δώσω), οπότε έψαχνα snippets, που βοήθησαν κύρια για να στήσω το περιβάλλον της Μ2000. Εκεί μπήκε η ιδέα των τριών συνιστωσών, γραφικά, βάσεις δεδομένων, και πολυμέσα σε μια εφαρμογή με ενσωματωμένη τη γλώσσα. Η γλώσσα ονομάστηκε Μαθητής 2000, ο στόχος ήταν να φτιαχτεί κάτι απλό για μαθητές, που να έχει ενδιαφέρον.

Τη δεκαετία του 2000  και ειδικότερα το 2003 έστειλα αντίγραφο της γλώσσας στην εθνική βιβλιοθήκη με ISBN 960-87618-0-8


Στον πρώτο διαθέσιμο διερμηνευτή υπήρχε και ένα βιβλίο εκπαίδευσης, ένα προγράμματα για να πακετάρει κανείς την εφαρμογή του σε Μ2000, για διανομή, καθώς και ένα IDE (περιβάλλον ανάπτυξης προγραμμάτων), με πολλαπλά παράθυρα, για να γράφει κανείς κώδικα και να τον εκτελεί στον διερμηνευτή (αν και από την αρχή ο διερμηνευτής είχε έναν ενσωματωμένο διορθωτή, ο εξωτερικός είχε και χρωματισμό εντολών). Το IDE έχει πάψει να χρησιμοποιείται, επειδή στις νεότερες εκδόσεις ο ενσωματωμένος διορθωτής απέκτησε αφενός άμεσο χρωματισμό, καθώς γράφουμε, και αφετέρου Unicode, δηλαδή να χρησιμοποιεί χαρακτήρες που ανήκουν στο UTF-16 (το IDE δούλευε σε ANSI).  Επίσης παρέχεται μαζί με το περιβαλλον Μ2000 και ένα αρχείο info.gsb που περιέχει πολλά προγράμματα, και ένα από αυτά είναι ο mEditor, ο διορθωτής της Μ2000 σε παράθυρο φτιαγμένος με κώδικα Μ2000, με χρωματισμό εντολών και εμφάνιση βοήθειας.

Τα πρώτα αρχεία gsb με κώδικα της Μ2000 ήταν σε ANSI, 8bit, σε ελληνική κωδικοσελίδα των Windows, ενώ στις νεότερες εκδόσεις είναι σε UTF-8. Μπορούν να διαβαστούν, και τα παλιά αρχεία.



Από το 2003 έως το 2013 είχα σταματήσει την ανάπτυξη της γλώσσας. Κύρια λόγω της ολοκλήρωσης της βασικής ιδέας αλλά και άλλων ασχολιών - έφτιαχνα το FotodigitalLab μια εφαρμογή για εκτυπώσεις. Από το 2013 άρχισα πάλι να φτιάχνω τη γλώσσα, σκεπτόμενος ότι μπορεί να τρέχει σε VirtualBox, σε εικονικό υπολογιστή.  Με την εμφάνιση των Windows 10 κατάλαβα ότι τα αρχεία που χρειάζονταν το περιβαλλον, το Win32 σύστημα, θα είναι μέρος των Windows 10, για πάντα!

Ομολογώ ότι ενώ μπορούσα να χρησιμοποιήσω αντικείμενα στη Visual Basic, δεν μπορούσα να σκεφτώ πώς θα τα έβαζα σε μια Script γλώσσα όπως η M2000. Τελικά για όλα υπάρχουν λύσεις.  Ο evaluator (το σύστημα που εκτελεί τις εκφράσεις, όπως αριθμητικές και λογικες) χειρίζεται και αντικείμενα. Η λύση ήταν να γυρνούν δυο πράγματα, μια η αριθμητική τιμή και μια ο δείκτης σε αντικείμενο.  Αν ο δείκτης σε αντικείμενο είναι το τίποτα (Null), τότε έχουμε αριθμητική τιμή. Στη πορεία έφτιαξα την δυνατότητα να ορίζουμε τελεστές σε αντικείμενα, οι οποίοι καλούν μεθόδους τελεστών των αντικειμένων αυτών.

Το 2016 έκλεισα αισίως πενήντα χρόνια ζωής, και χαίρομαι για τις δημιουργίες μου! Συνεχίζω ακάθεκτος! Δεν στερεύουν οι ιδέες παρόλο που κάποιοι φορουμίστες πρότειναν να κλείσει το έργο, σκεπτόμενοι ότι ως εργαλείο η Μ2000 δεν τους κάνει. Περισσότερο με ενδιαφέρει να κάνω κάτι όσο περισσότερο καλύτερο και ας το εκτιμήσει ένας μόνο! Είναι ένα δώρο τόσο για εκείνον που το θέλει όσο και για μένα που το φτιάχνω!

Παρακάτω ακολουθούν στοιχεία για τις εκδόσεις από το τελευταίο προς το πρώτο


Παραδείγματα με αγγλικές εντολές στο Rosetta Code, Μετρήθηκαν 359 λύσεις (tasks), στις 28/07/2020. Υπάρχει το τμήμα RO στο Info αρχείο που βγάζει το σύνολο των γλωσσών στο τόπο rosettacode.org ταξινομημένο βάσει τον αριθμό άρθρων - λύσεων - σε προβλήματα ή αιτήματα που βάζει ο τόπος αυτός.

Περί Εκδόσεων:

Η τρέχουσα έκδοση του διερμηνευτή είναι η 11, τελευταία αναθεώρηση 3.
Η 11η έκδοση ενσωμάτωσε όλες τις αναθεωρήσεις της 10, είναι πιο γρήγορη, έχει περισσότερες δυνατότητες στις φόρμες χρήστη (γραφικό περιβάλλον), έχει αρκετές βελτιώσεις.

Βιβλιο εκπαιδευτικό για νεοεισερχόμενους στο προγραμματισμό:
Έχει 9 κεφάλαια:
  1. Το πρώτο μου πρόγραμμα!
  2. Παιχνίδι: Μάντεψε έναν Αριθμό
  3. Το κόσκινο του Ερατοσθένη
  4. Το δένδρο του Πυθαγόρα
  5. Παραγγελία Αυγών
  6. Απόσταση Λιβενστέϊν
  7. Ακολουθία Φιμπονάτσι με πολύ μεγάλους αριθμούς
  8. Δυαδικός Αθροιστής
  9. Ψηφιοποίηση Δεδομένων (Ελεύθερο Σχέδιο)

Έγραψα ένα άρθρο (pdf) που θα εμπλουτίζεται: Μ2000 Προγραμματιστικά Υποδείγματα
  1. Αδόμητος Προγραμματισμός
  2. Δομημένος Προγραμματισμός
  3. Διαδικαστικός Προγραμματισμός
  4. Τμηματικός Προγραμματισμός
  5. Προγραμματισμός με Αντικείμενα
  6. Συναρτησιακός Προγραμματισμός (Μόνο επικεφαλίδα, θα εμπλουτιστεί)
  7. Προγραμματισμός με Γεγονότα (Μόνο επικεφαλίδα, θα εμπλουτιστεί)
  8. Προγραμματισμός Παράλληλος (Μόνο επικεφαλίδα, θα εμπλουτιστεί)


Παρουσιάστηκε το άρθρο Ο Αντικειμενοστραφής Προγραμματισμός με τη Μ2000. Όλα τα παραδείγματα έχουν ελεγχθεί με την αναθεώρηση 51, έκδοση 9.9. και βασίζονται στις λύσεις που δόθηκαν στα αγγλικά παραδείγματα στο blog.

Έγραψα για 26 Design Patterns παραδείγματα με αγγλικές εντολές της Μ2000 και τα δημοσίευσα στο blog.

Αναθεώρηση: 46. Η δείκτης() γυρνάει ομάδα τύπου Null ή Μηδενικός (είναι και τα δύο).
α=δείκτης()
Τύπωσε α είναι τύπος μηδενικός = Αληθής
Τύπωσε α είναι τύπος Null = Αληθής

Σχετικά με τις Ομάδες, τους δείκτες και τις αναφορές.
Μπορούμε να δώσουμε τύπους στις επώνυμες ομάδες και να ενώσουμε ομάδες (αντίγραφα αυτών) απευθείας σε δεξιά έκφραση με το τελεστή ΜΕ. Έτσι έχουμε δυο ειδών κληρονομικότητες, την κληρονομικότητα σε ορισμό (σε κλάσεις) και την κληρονομικότητα σε αντικείμενα απευθείας. Το πεδίο Τύπος μπορεί να έχει περισσότερα από ένα ονόματα τύπων. Όταν ένα αντικείμενο περνάει σε μια μέθοδο ενός άλλου αντικειμένου που έχει τουλάχιστον την ίδια σειρά τύπων, τότε οι ιδιωτικές μεταβλητές και μέθοδοι είναι ορατές στην μέθοδο. Αυτό δεν υπήρχε πριν φτιαχτούν οι τύποι αντικειμένων του γενικού τύπου ομάδα.  Αν θέλουμε μια ομάδα να περιέχεται σε μια ομάδα (να έχει μια ομάδα), και όχι να είναι μια ομάδα άλλου τύπου, τότε χρησιμοποιούμε εσωτερικές ομάδες ή δείκτες που κρατούν ομάδες. Η διαφορά αυτών των δύο είναι ότι η εσωτερική ομάδα είναι επώνυμη ομάδα, οπότε ανιγράφονται τα στοιχεία της ενώ ο δείκτης αντιγράφεται σαν δείκτης και όχι σαν περιεχόμενο, έτσι μπορούν δυο ομάδες να έχουν δείκτη σε ίδια ομάδα.

Επώνυμη Ομάδα είναι το αντικείμενο ως τιμή, και έχει παρουσία σε θέσεις μεταβλητών. Δεν γίνεται δυο επώνυμες ομάδες να είναι το ίδιο αντικείμενο (εκτός αν το δεύτερο αναγνωριστικό είναι αναφορά στο πρώτο). Η ζωή της επώνυμης ομάδας τερματίζει όταν διαγραφεί η παρουσία της στις μεταβλητές, συνήθως στο τερματισμό του τμήματος που δημιουργήθηκε. Όταν θέλουμε το αντικείμενο να δουλεύει ως μοναδικό τότε μια επώνυμη αρκεί. Σε πίνακες βάζουμε ανώνυμες ομάδες. Πχ αν Α είναι επώνυμη ομάδα το Π(3)=Α θα βάλει αντίγραφο της Α στον πίνακα Π() στη θέση 3. Το Α=Π(3) θα μεταγράψει τις τιμές του παλιού Α στο τωρινό Α. Αν το Α έχει το μέλος Χ τότε η Τύπωσε  Α.Χ, Π(3).Χ θα τυπώσει τις Χ των δυο ξεχωριστών αντικειμένων.

Ανώνυμη ή πτητική Ομάδα: το αντικείμενο με παρουσία μέσω δείκτη. Τερματίζει όταν ο τελευταίος δείκτης στο αντικείμενο διαγραφεί. Μπορούμε να έχουμε όσους δείκτες θέλουμε, κανείς όμως δεν είναι "πρώτος" ή ξεχωριστός. Αν Α είναι δείκτης σε ομάδα τότε το Π(3)=Α θα βάλει ένα δείκτη στο Π() στη θέση 3. Αν το Α έχει το μέλος Χ τότε η Α=>Χ=100 θα αλλάξει την τιμή του Χ στο 100. ΜΙα Τύπωσε Α=>Χ, Π(3).Χ θα δώσει το 100 δυο φορές, γιατί το Π(3) είναι το Α (είναι το ίδιο αντικείμενο). Αν στο Α δώσουμε νέο αντικείμενο τότε το παλιό θα υπάρχει στην Π(3). Η Α=Π(3) φέρνει πάλι στην Α το παλιό αντικείμενο. Δεν έχουμε αντιγραφές τιμών μελών (όπως της Χ), σαν αυτές που έχουν οι επώνυμες ομάδες.

Ο κάθε τύπος αντικειμένου έχει τα υπέρ και τα κατά. Οι επώνυμες χειρίζονται γρήγορα τα μέλη τους. Οι ανώνυμες μεταφέρονται με μια απλή αντιγραφή δείκτη. Αντικείμενα σε λίστες, πίνακες ή σωρούς τιμών είναι ανώνυμα (βρίσκονται από τη θέση/κλειδί τους σε αυτά). Έτσι μια ταξινόμηση λίστας με στοιχεία ομάδες θα γίνει το ίδιο γρήγορα ανεξάρτητα από το  μέγεθος του αντικειμένου στη μνήμη. Υπάρχουν γλώσσες που έχουν εξαιρέσει τις επώνυμες, ή τις λένε στατικές (δεν δίνουν δυνατότητα να έχουμε κατασκευή νέας). Πχ η Python  έχει ανώνυμα αντικείμενα (όλα έιναι με δείκτη), επίσης όμως δεν έχει χρήση αναφοράς και περάσματος με αναφορά, η δε χρήση ισχνής αναφοράς είναι μια παρεξηγημένη υπόθεση! Στην Python η χρήση ενός μέλους απαιτεί την εύρεση στη λίστα του αντικειμένου κάθε φορά. Δεν έχουμε άνοιγμα του ανικειμένου, αλλά γίνεται ανίχνευση του μέλους πριν την κάθε χρήση (στη Python μπορούμε να σβήνουμε μέλη, στη Μ2000 δεν γίνεται αυτό).

Αναγνωριστικό Επώνυμης ομάδας: Ένα όνομα όπως και αυτό των μεταβλητών. Τα δημόσια μέλη (μεταβλητές) είναι σαν κανονικές μεταβλητές μπορούν να δώσουν ανεξάρτητα αναφορές, ή όλα μαζί αν περάσουμε την ομάδα με αναφορά σε  κλήση. Μια επώνυμη ομάδα έχει λίστα με τι έχει αλλά στη Μ2000 αυτά που έχει είναι στο χώρο των μεταβλητών και όχι μέσα στο αντικείμενο. Η ομάδα μπορεί να έχει ιδιωτικά μέλη, αλλά και αυτά στον ίδιο γενικό χώρο βρίσκονται απλά δεν είναι θεατά από οπουδήποτε παρά μόνο από τα τμήματα και συναρτήσεις (μεθόδους) του αντικειμένου. Ο γενικός χώρος μεγαλώνει και μικραίνει βάσει των κλήσεων. (κατά μια έννοια είναι μια στοίβα τιμών).

Οι πτητικές ομάδες δεν έχουν αναγνωριστικό! Δεν βρίσκονται σε θέσεις μεταβλητών άμεσα αλλά έμεσα με δείκτη. Τα μέλη της είναι κλειστά, εκτός συστήματος μεταβλητών, τα κρατάει η ομάδα χωριστά. Ένα αναγνωριστικό μπορεί να έχει το δείκτη στην ομάδα και να τον μεταγράψουμε σε πίνακα ή ότι άλλο (αυξάνεται ο μετρητής δεικτών). Όταν διαγράφονται οι δείκτες ή βάζουμε τιμή Null  (0& ή Δείκτης()) τότε μειώνεται ο μετρητής και όταν φτάσει το 0 τότε καλεί την διαγραφή του αντικειμένου. Λέγονται πτητικές γιατί μεταφέρονται αυτούσιες! Σε αντίθεση μια επώνυμη μπορεί να μεταφερθεί μόνο μπροστά (σε κλήση) με αναφορά (μια μεταβλητή που δείχνει στην αρχική και μοναδική μεταβλητή της επώνυμης). Ο διερμηνευτής χρησιμοποιεί άμεσα μια πτητική ομάδα κάνοντας το εξής: Ανοίγει την ομάδα ως επώνυμη, κάνει ότι έχει να κάνει και την κλείνει. Είναι σαν να καλούμε πρόγραμμα. Υπάρχει η δομή Για Αντικείμενο [, Αντικείμενο] { εντολές } που ανήγει ομάδες για πολλαπλές εργασίες, οπότε να μην έχουμε συνέχεια άνοιγμα - κλείσιμο.

Δείκτης και αναφορά είναι διαφορετικά πράγματα στη Μ2000. Η αναφορά έχει να κάνει με τις μεταβλητές, και δεν έχει να κάνει με το τι δείχνουν οι μεταβλητές είναι μηχανισμός ένωσης ονομάτων, ενώ οι δείκτες κάνουν με τιμές που μπαίνουν οπουδήποτε, σε μεταβλητές ή πίνακες ή λίστες ή σωρούς τιμών. Γίνεται να περάσουμε αναφορά που να έχει δείκτη, οπότε η αλλαγή δείκτη (δίνουμε νέο ή άλλο αντικείμενο) θα γίνει άμεσα στην αναφερόμενη μεταβλητή. Στη Μ2000 υπάρχει και η έννοια της ισχνής αναφοράς, δηλαδή ενός αλφαριθμητικού που θα χρησιμοποιήσει η Διάβασε για να φτιάξει μια κανονική αναφορά. Αυτό μας βολεύει όταν δεν θέλουμε σφικτό δέσιμο μεταξύ αντικειμένων. Έχει όμως το μειονέκτημα να μην συνδέεται η "τύχη" του αντικειμένου με τη ζωή της ισχνής αναφοράς, και κατά την προσπάθεια σύνδεσης (για να βγει μια κανονική αναφορά), να αποτύχει το πρόγραμμα!
Οι δείκτες σε αντικείμενα ομάδα εσωτερικά μπορεί να είναι ή πραγματικοί δείκτες ή ισχνές αναφορές (ανάλογα τι θέλουμε), όμως ο χειρισμός είναι ο ίδιος (με τις ιδιοτροπίες της ισχνής).

Ομάδα Άλφα {
Τύπος: Ζεύγος      
      Χ=10, Ζ=30
}
Τύπωσε Άλφα είναι τύπος Ζεύγος
Ομάδα Βήτα {
Τύπος: ΚάτιΆλλο
      Τμήμα ΚάνεΚάτι {
            Τύπωσε "Αυτό"
      }
}
Δέλτα = Άλφα με Βήτα
Τύπωσε Δέλτα είναι τύπος Ζεύγος
Τύπωσε Δέλτα είναι τύπος ΚάτιΆλλο
Δέλτα.ΚάνεΚάτι


Στην αναθεώρηση  38 προστέθηκαν τύποι στις Κλάσεις, και ένας εύκολος τρόπος να φτιάχνουμε κλάσεις από κλάσεις (κληρονομικότητα) ενώ παραμένει ο τρόπος να φτιάχνουμε αντικείμενα από άλλα αντικείμενα.

Κλάση Άλφα {
      Χ=30
}
Κλάση Βήτα Ως Άλφα {
      Ψ=40
}
Κλάση Δέλτα {
      Ψ=10
      Ζ=100
}
Μ=Βήτα()
Τύπωσε Μ.Χ=30, Μ.Ψ=40
Τύπωσε Μ είναι τύπος Βήτα = Αληθής
Τύπωσε Μ είναι τύπος Άλφα = Αληθής
\\ Δυο αντικείνα συνθέτουν το Ν
Ν=Άλφα() Με Δέλτα()
Τύπωσε Ν.Χ=30, Ν.Ψ=10, Ν.Ζ=100
Τύπωσε Ν είναι τύπος Δέλτα = Αληθής
Τύπωσε Ν είναι τύπος Άλφα = Αληθής
Κλάση Πολλαπλή Ως Δέλτα Ως Βήτα {
      Τμήμα Δειξε {
            Τύπωσε , ,
      }
}
Ξ=Πολλαπλή()
Ξ.Δείξε  ' 30  10 100
Τύπωσε Ξ είναι τύπος Βήτα = Αληθής
Τύπωσε Ξ είναι τύπος Άλφα = Αληθής
Τύπωσε Ξ είναι τύπος Δέλτα = Αληθής

Σε αυτή την έκδοση προστέθηκε η δυνατότητα χειρισμού RTL γλωσσών, αραβικά και εβραϊκά, δηλαδή γλωσσών που γράφονται από αριστερά προς τα δεξιά. Νέα προγράμματα στο info.gsb, όπως ένα σκάκι για δυο, με έλεγχο κινήσεων, χιλίων εντολών κώδικα Μ2000.


Στην 9.8 έκδοση έγιναν πολλές βελτιώσεις. Ο προγραμματιζόμενος χρωματιστής γραμμών κειμένου στο στοιχείο ελέγχου Κείμενο (Editbox) χρωματίζει  Html, c#, ΓΛΩΣΣΑ. Υπάρχουν παραδείγματα στο info.gsb. Επίσης γίνεται σωστή χρήση των surrogates του UTF-16LE, κωδικοποίησης χαρακτήρων για νούμερα κωδικών που απαιτούν τέσσερα bytes.

Στην 9.7. Προστέθηκε η δυνατότητα χρήσης του tab για τον διορθωτή και βελτιώθηκαν τα στοιχεία ελέγχου του συστήματος παραθύρων της Μ2000 (χρησιμοποιεί δικά της στοιχεία, και όχι τα στοιχεία της VB6)


Στην 9.6 Από τις τελευταίες αναθεωρήσεις της 9.5 μπήκε η ιδέα να φτιαχτεί η Αν με ανάπτυξη χωρίς μπλοκ εντολών, αλλά με γραμμε εντολών μεταξύ των αναγνωριστικών της δομής. Έτσι μπήκε το Τέλος Αν. Επιπλέον αν σε μια γραμμή έχουμε τη δομή Αν   Τότε    Αλλιώς.Αν   Τότε  Αλλιώς.Αν    Αλλιώς, θα έπρεπε να είχαμε μπλοκ κώδικα πχ Αν Χ Τότε {Τύπωσε 1} Αλλιώς.Αν Υ Τότε {Τύπωσε 2} ....Αλλιώς Τύπωσε 10  όπου η τελευταία αν έχει μπλοκ τελειώνει εκεί η δομή και μπορεί οποιαδήποτε ροή και να είχε πάρει να εκτελέσει την επόμενη στη γραμμή, ενώ αν δεν έχει μπλοκ τότε εκτελεί όλη τη γραμμή σαν να ήταν μπλοκ. Τώρα λοιπόν μπορούμε να γράψουμε το προηγούμενο χωρίς μπλοκ εντολών. Στη νέα δομή μπήκε τρόπος να κοιτάει μπορστά ο διερμηνευτής για τα αναγνωριστικά που ψάχνει. Ειδικά η Αν έχει το προσόν να παίζει με διάφορα, πχ να μην έχει την Αλλιώς στο τέλος, ή να την έχει  ακριβώς πρώτη, πχ η Αν Χ Αλλιώς Τύπωσε "Χ=0" θα τρέξει με Χ=0, γιατί μια Τότε θα είχε εκτελεστεί με μη μηδενική τιμή, ενώ με μηδενική η Αλλιώς αν υπάρχει, που εδώ υπάρχει!

Επιπλέον σε αυτήν την έκδοση μπήκαν και σε άλλες δομές οι εκδόσεις χωρίς μπλοκ. Σε κάθε περίπτωση ισχύουν και οι εκδόσεις με μπλοκ. Μια διαφορά που  υπάρχει για την Αν σε σχέση με τις άλλες δομές είναι ως προς την χρήση του Έξοδος (και άλλων όπως η Διέκοψε και η Ξεκίνα και η Συνέχισε), δηλαδή αναγνωριστικών που επιδρούν σε μπλοκ. Στην Αν αν δεν βάλουμε μπλοκ επενεργούν στο πάνω από την Αν μπλοκ. Στην Επανέλαβε (ή Επανάλαβε), καθώς και την Ενώ, έχουμε κρυμμένο μπλοκ, δηλαδή ενώ δεν χρησιμοποιούμε μπλοκ, ο διερμηνευτής φτιάχνει δικό του, για να χρησιμοποιήσει σωστά αυτές τις εντολές. Ετσι η έξοδος κάνει το Επανέλαβε Μέχρι να τερματίσει.



Στην 9.5 Μπήκε το πέρασμα με αναφορά σε στοιχεία πίνακα και σε στατικές μεταβλητές. Αυτό έγινε με την απλή ιδέα της ενδιάμεσης θέσης μνήμης, ή μεταβλητής, που κρυφά φτιάχνει ο διερμηνευτής, και αντιγράφει την τιμή σε αυτήν και την δίνει με αναφορά, και στην επιστροφή επαναφέρει τις νέες τιμές στις αρχικές τους θέσεις (λέγεται μέθοδος copy in copy out).

Επίσης οι αυτόματοι πίνακες (ή tuple) όπως και οι πίνακες απέκτησαν ειδικές συναρτήσεις που μπορούν να εκτελεστούν προς τα δεξιά αθροιστικά:

Στο παρακάτω παράδειγμα δίνουμε τα filter, map, fold σε ένα πίνακα με δείκτη το c και παίρνουμε ένα αλφαριθμητικό. Όταν ζητάμε αλφαριθμητικό πρέπει να έχουμε το $ στη τελευταία συνάρτηση για να καταλάβει ο διερμηνευτής ότι έχουμε αλφαριθμητική παράσταση και έτσι να προχωρήσει στην εκτέλεσή της.

Ο διερμηνευτής δεν χρησιμοποιεί ακόμα AST, ή κάτι ανάλογο, αλλά συναρήσεις που καλεί η μια την άλλη καταναλώνοντας κώδικα, και αυτός ο κώδικας αναφέρεται σε ένα βασικό αντικείμενο, το αντικείμενο εκτέλεσης. Κάθε τμήμα και συνάρτηση τρέχει σε ξεχωριστό αντικείμενο εκτέλεσης. Οι ρουτίνες είναι δομές της γλώσσας και δεν απαιτούν αντικείμενο εκτέλεσης. Τα νήματα είναι και αυτά ξεχωριστά αντικείμενα εκτέλεσης. Οι μεταβλητές γράφονται σε μια λίστα γραμμική, και τα τμήματα και οι συναρτήσεις σε μια άλλη λίστα επίσης γραμμική. Παρόλα αυτά μπορούν να τρέχουν γεγονότα από τις φόρμες για παράδειγμα ή και νήματα, ή και τα δύο ταυτόχρονα, χωρίς να έχουμε θέμα με τις γραμμικές λίστες. Οι λίστες διαγράφουν στοιχεία με την αντίθετη φορά από τη φορά που γράφονται. Έτσι όταν έχουμε το Τμήμα Α { Τμήμα Β { } : Β } : Α, θα γραφτεί το Α στη λίστα χωρίς να κοιτάξει καθόλου ο διερμηνευτής το τι έγραψε. Μετά θα εκτελέσει το Α, και αυτό θα φτιάξει το Β και θα το εκτελέσει, στην έξοδο του Α θα σβηστεί το Β.
Επειδή ο διερμηνευτής τρέχει σε μια εφαρμογή σε Visual Basic 6, και αυτή είναι ενός επιπέδου επεξεργασίας, κάθε φορά που ένα γεγονός συμβαίνει, εκτελείται το γεγονός, και αν μπλοκαριστεί, τότε εκτελείται κάτι άλλο, νέο, αλλά τίποτα από τα προηγούμενα που βρίσκονται σε εκτέλεση δεν εκτελούνται. Όταν φτιάχνουμε παραθυρικές εφαρμογές με την Μ2000, μπορούμε να έχουμε ένα γεγονός σταματημένο, και ταυτόχρονα να γενούνται άλλα γεγονότα, και όλα αυτά χειρίζονται τις γραμμικές λίστες χωρίς πρόβλημα. Δηλαδή το μειονέκτημα της Visual Basic να βγάλει με fork  ένα νέο process, είναι πλεονέκτημα για τη M2000. Πιθανόν κάποτε να γραφτεί η Μ2000 για πολλές διεργασίες τύπου process, αλλά σίγουρα όχι σε VB6.

Εν τέλει είναι βολικός ο τωρινός τρόπος υλοποίησης της γλώσσας, ειδικά γιατί πορεί κάποιος να επεκτείνει εύκολα τη γλώσσα. Το μειονέκτημα αυτού του τρόπου είναι η πιο αργή εκτέλεση. Έχει βελτιωθεί η ταχύτητα με χρήση διάφορων τεχνικών, αλλά κάποια στιγμή θα πάει η γλώσσα σε μια AST διαμόρφωση και εκτέλεση από ένα VM.

Προς το παρόν με απασχολεί να εκτελούνται προγράμματα υπό μορφή ασκήσεων ή για μοντελοποίηση, να βρούμε δηλαδή πώς μια ιδέα υλοποιείται. Υπάρχει lexical analyzer για την Μ2000, και αυτός θα χρησιμοποιηθεί κάποια στιγμή σε νέα έκδοση, ίσως την 10.

a=(1,2,3,4,5)
Print a#rev()
Print a#sum()=15
Print a#max()=5, a#min()=1
k=-1
L=-1
Print a#max(K)=5, a#min(L)=1
Print K=4 ' 5th position
Print L=0 ' 1st position
Print a#pos(3)=2 ' 3rd position
Print a#val(4)=5
\\ tuples in tuple
a=((1,2),(3,4))
Print a#val(0)#val(1)=2
Print a#val(1)#val(1)=4
a=(1,2,3,4,5,6,7,8,9)
fold1=lambda ->{
      push number+number
}
Print a#fold(fold1)=a#sum()
Print a#fold(fold1,1)=a#sum()+1
even=lambda (x)->x mod 2=0
b=a#filter(even, (,))
Print b ' 2 4 6 8
Print a#filter(even)#fold(fold1)=20
map1=lambda (a)->{
      push a+100
}
c=b#map(map1)
Print c ' 102,103, 104, 105
numbers=lambda p=1 (x) ->{
      push x+p
      p++
}
oldnumbers=numbers ' we get a copy of numbers with p=1
c=c#map(numbers)
Print c ' 103, 106, 109, 112
zfilter=lambda -> number>106
tostring=lambda -> {
      push chrcode$(number)
}
oneline=lambda -> {
             shift 2 ' get second as first
             push letter$+letter$
}
Line$=c#filter(zfilter)#map(tostring)#fold$(oneline,"")
print Line$="mp", chrcode$(109)+chrcode$(112)
zfilter=lambda -> number>200
Line$=""
Line$=c#filter(zfilter)#map(tostring)#fold$(oneline,"")
\\ lines$ can't change value becuse filter has no items to give
Print Line$=""
\\ if we leave a second parameter without value the we get No Value error
Try {
      Line$=c#filter(zfilter, )#map(tostring)#fold$(oneline,"")
}
Print error$=" No value"
\\ second parameter is the alternative source
Line$=c#filter(zfilter,(109,112))#map(tostring)#fold$(oneline,"")
Print Line$="mp"
c=(1,1,0,1,1,1,1,0,1,1,0)
\\ hard insert
Print c#pos(1,0,1) ' 1  means 2nd position
Print c#pos(3->1,0,1) ' 6  means 7th position
\\ using another tuple
Print c#pos((1,0,1)) ' 1  means 2nd position
Print c#pos(3->(1,0,1)) ' 6  means 7th position
t=(1,0,1)
Print c#pos(t) ' 1  means 2nd position
Print c#pos(3->t) ' 6  means 7th position


Στην 9.4  αφαιρέθηκε ο συλλέκτης σκουπιδιών. Είχε μπει μόνο για τις περιπτώσεις όπου μια Κατάσταση (κάτι ως vector), είχε αναφορά στον εαυτό της ή σε ένα πίνακα που αυτός είχε σε ένα στοιχείο του αναφορά στην κατάσταση, να μπορεί να σπάει αυτές τις λεγόμενες κυκλικές αναφορές. Όμως κρίθηκε ασύμφορο, για το κέρδος έναντι του κόστους και δεν είχε πάντα επιτυχία. Όπως και να έχει τα αντικείμενα θα καταστραφούν όταν τερματίσει ο τρέχον διερμηνευτής (μπορούν να τρέχουν και άλλοι, αλλά ο καθένας είναι ξεχωριστός, βλέποντας την δική του μνήμη)
Αυτή η έκδοση τρέχει και τον Y combinator:
Module Ycombinator {
      \\ factorial
      Print lambda (g, x)->{=g(g, x)}(lambda (g, n)->if(n=0->1, n*g(g, n-1)),10)
       \\ fibonacci
      Print lambda (g, x)->{=g(g, x)}(lambda (g, n)->if(n<=1->n,g(g, n-1)+g(g, n-2)), 10)

      \\ Using closure in y, y() return function
      y=lambda (g)->lambda g (x) -> g(g, x)

      fact=y((lambda (g, n)-> if(n=0->1, n*g(g, n-1))))
      Print fact(6), fact(24)

      fib=y(lambda (g, n)->if(n<=1->n,g(g, n-1)+g(g, n-2)))
      Print fib(10)
}
Ycombinator
      y=lambda (g)->lambda (x-> g(gx)
      fact=y((lambda (g, n)-> if(n=0@->1@, n*g(g, n-1))))
      Print fact(6), fact(24)

Τα 0@ και 1@ είναι τύπου Decimal, οπότε η fact() επιστρέφει decimal μέχρι το 27 

Εδώ γίνεται χρήση γεγονότων σε μια ομάδα, και η fib() είναι μέλος της ομάδας. Η συνάρτηση πάνω από το 140 γυρίζει διπλό (τύπος double (64bit float)), ενώ πριν decimal (ή αριθμό, με 28 ψηφία, δεκαδικά ή ακέραια). Τον τύπο το κανονίζει η m, όπου με -1@ ορίζεται ως decimal, ενώ το απλό -1 είναι διπλός (ενώ τα -1# Λογιστικός, -1& μακρύς, -1% ακέραιος 16bit, -1~ απλός (32bit float))

Τα γεγονότα χρησιμοποιούνται για να καταχωρήσουμε παλιές τιμές, ώστε να μην τις αναζητάει με αναδρομή ξανά και ξανά ο διερμηνευτής.

Αν βάλουμε στα ονόματα των συναρτήσεων εξυπηρέτησης το 1 στο τέλος, ώστε να μην τα βρίσκει ο διερμηνευτής, και αλλάξουμε βέβαια το άνω όριο του i από 200 στο 20, στο τελικό For, θα δουλέψει η fib() αλλά στο είκοσι, θα αργήσει στο διπλάσιο, από όσο χρόνο έκανε για το προηγούμενο, το οποίο και εκείνο έκανε το διπλάσιο του προηγούμενου κ.ο.κ. Τα γεγονότα έχουν το προσόν να καλούνται, χωρίς να γυρνούν λάθος και όταν δεν υπάρχουν, και έτσι προγραμματιστικά πρέπει να φτιάξουμε τη συνάρτηση για να ανταποκρίνεται και στις δυο περιπτώσεις.

Το WithEvents (ή ΜεΓεγονότα στην ελληνική παραλλαγή), δίνει στη συγκεκριμένη το όνομα του τμήματος όπου θα κληθούν οι συναρτήσεις εξυπηρέτησης. Αυτές οι συναρτήσεις έχουν την ιδιότητα, όπως και οι συναρτήσεις των γεγονότων του συστήματος παραθύρων, να καλούνται "τοπικά", δηλαδή να μην δημιουργούν δικό τους όνομα χώρου, αλλά να παίρνουν αυτό που τους δίνει το γεγονός. Έτσι όταν κληθεί η Alfa_Getit, ως τμήμα (δηλαδή μια συνάρτηση που δεν γυρνάει τιμή, δεν καλείται σε έκφραση, ή σε πράξεις κατά μια έννοια), το όνομα του χώρου θα είναι το όνομα του τμήματος, και έτσι η κατάσταση GetIt, που είναι τοπική σε αυτόν το χώρο, θα φαίνεται και εδώ. Δείτε ότι διαβάζουμε κάποιες μεταβλητές με την new, που σημαίνει ότι θα φτιαχτεί νέα μεταβλητή οπωσδήποτε, ακόμα και αν υπάρχει τοπική με το ίδιο όνομα. Οι μεταβλητές διαγράφονται με την ανάποδη φορά από τη φορά δημιουργίας τους. Κάθε συνάρτηση ακόμα και αυτή των γεγονότων, διαγράφει ό,τι δημιουργεί.

Δείτε τέλος  περνάμε με αναφορά τη συνάρτηση μέλος της ομάδας, σε ένα εσωτερικό (τοπικό) τμήμα, το inner, και από αυτό εκτελούνται τα γεγονότα που καλούν πίσω στο τμήμα CheckEvents.

Module CheckEvents {
      \\ we can use standard functions (not lambda functions)
      \\ we can use lambda() so we can use function with different names
      \\ We can define functions inside groups with events
     Group WithEvents Alfa {
           Event "GetIt", "PushIt"
           Function fib(n) {
                  if n<=1 then {
                        =val(n->Decimal)
                  } else {
                        if n<140 then { m=-1@} else m=-1
                        call event "Getit", n, &m
                        if m>-1 then =m : exit
                        \\ m1 may get double if a decimal can write the result
                        \\ if we use m we get overflow error
                        m1=lambda(n-1)+lambda(n-2)
                        call event "Pushit", n, m1
                        =m1
                  }            
            }
      }
      \\ we use an Inventory list to save old values
      Inventory Getit
      \\ event's service functions
      \\ if not event's functions exist, call event skipped
      Function Alfa_Getit {
            Read new key, &m
            if exist(Getit, key) then m=eval(Getit)
      }      
      Function Alfa_Pushit {
            Read new key, m
            Append Getit, key:=m
      }
      Module Inner (&fibonacci()){
            For i=1 to 200 ' until 139 we get decimal type, above it we get double
                  Print fibonacci(i),
            Next i
      }
      Inner &Alfa.fib()
}
CheckEvents



Στην 9.3 Οι ομάδες μπορούν να έχουν "ελαφριά" γεγονότα, δηλαδή γεγονότα που συνδέονται στατικά σε ένα τμήμα ή μια συνάρτηση, ενώ τα κανονικά γεγονότα λειτουργούν με ένα αντικείμενο γεγονός το οποίο έχει ένα γεγονός και καλεί πολλές συναρτήσεις, τις οποίες έχει ενσωματωμένες, τις βάζουμε και τις βγάζουμε, και μπορούμε να προσθέτουμε με αναφορά συναρτήσεις από στατικές ομάδες. Όπου στατικές λέμε τις επώνυμες, που ανήκουν σε ένα τμήμα ή συνάρτηση, τα οποία τρέχουν, ενώ μη στατικές είναι αυτές που διατηρούνται βάσει ενός δείκτη.

Μπήκε το πέρασμα σε τμήματα τιμής με όνομα με τη χρήση του % πριν το όνομα. Δηλαδή λέμε στην μεταβλητή που θα φτιάξει ως τοπική το τμήμα, για μια παράμετρο, τι τιμή θα πάρει, πριν το καλέσουμε! Η αριστερή παρενθέση της λίστας παραμέτρων στα τμήματα μπορούν να κολλάει ή όχι στο όνομα. Ή μπορούμε να γράψουμε:
Τμήμα Alfa {
Διάβασε x ως ακέραιο, z ως διπλό
...........
}
Αυτό κάνει ο διερμηνευτής, βάζει την Διάβασε ως πρώτη γραμμή κατά την εγγραφή του τμήματος στη λίστα τμημάτων. Η λίστα τμημάτων έχει τα ονόματα με προθέματα που τα διαχωρίζει σε τοπικά και γενικά. Έτσι όταν καλούμε ένα τμήμα ή θα υπάρχει γενικό ή θα υπάρχει με το πρόθεμα του τρέχοντος, δηλαδή θα είναι τοπικό, αλλιώς θα βγει λάθος.

το πέρασμα με όνομα δεν δουλεύει αν καλέσουμε το τμήμα με την Κάλεσε (είναι ο τρόπος για να καλέσουμε τον αυτό του, αν θέλουμε να έχουμε αναδρομή, διαφορετικά ένα τμήμα δεν καλεί το όνομά του, βγαίνει λάθος, που θα λέει ότι πρέπει να χρησιμοποιήσεις την Κάλεσε ή Call).

Module Alfa (x as Integer, z as Double) {
      Print "x=";x,"  "+ Type$(x)
      Print "z=";z, "  "+Type$(z)
}

Alfa 1, 2
\\ By Name pass
Alfa %x=2, %z=1


Στις τελικές αναθεωρήσεις της 9.3 μπήκε και η επιστροφή αριθμού από αλφαριθμητικό με τρόπο που διαλέγουμε:

Συνάρτηση Αριθμός(α$) {
      Κάνε β
      =Τιμή(Ψευδές->Λογικός)
      Δες {
            Αν ΕινΓρ Τότε {
                  z=Τιμή(α$,γράμμα$, β)
            } Αλλιώς.Αν ΕινΑρ Τότε {
                  z=Τιμή(α$,αριθμός, β)
            } Αλλιώς z=Τιμή(α$,"", β)
            =β>Μήκος(α$)
      }
}
Συνάρτηση ΑκέραιοςΑριθμός(α$) {
      Κάνε β
      =Τιμή(Ψευδές->Λογικός)
      Δες {
            z=Τιμή(α$,"Ακ", β)
            =β>Μήκος(α$)
      }
}
Τύπωσε ΑκέραιοςΑριθμός("1221213123213")=Αληθές
Τύπωσε ΑκέραιοςΑριθμός("1221213.123213")=Ψευδές
Τύπωσε Αριθμός("123131232131231231.23123123")=Αληθές
Τύπωσε Αριθμός("-123131232131231231.23123123e112")=Αληθές
Τύπωσε Αριθμός("-123131232131231231.23123123e112", ",")=Ψευδές
Τύπωσε Αριθμός("-123131232131231231.23123123e112", 1036)=Ψευδές
Τύπωσε Αριθμός("-123131232131231231.23123123e112", 1033)=Αληθές
Τύπωσε Τιμή("233.44sec", 1033)=233.44
α$="233.44sec"
β=0
Τύπωσε Τιμή(α$, 1033, β)=233.44
Αν β>0 Τότε Τύπωσε Mid$(α$, β)="sec"
\\ οποιοδήποτε αλφαριθμητικό με μήκος >1 για χαρακτήρα δεκαδικών εξαιρεί τα δεκαδικά.
Τύπωσε Τιμή(α$, "??", β)=233
Αν β>0 Τότε Τύπωσε Mid$(α$, β)=".44sec"

Στην Έκδοση 9.2 Καθορίστηκε ότι οι αριθμητικές μεταβλητές θα διατηρούν το τύπο τους (θα γυρνούν λάθος σε περίπτωση υπερχείλισης). Μπορούμε να ορίζουμε τύπους προκαταβολικά για τις παραμέτρους μιας συνάρτησης, ή ενός τμήματος. Επίσης οι τελεστές στις ομάδες λειτουργούν με προτεραιότητες, και έτσι δημιουργούμε τύπους μεταβλητών με βάση το αντικείμενο ομάδα.

Στην Έκδοση 9.1 μπήκαν διάφοροι αριθμητικοί τύποι όπως currency και decimal, single, boolean.

Από την αναθεώρηση 48 λειτουργεί η εκδοχή της Διάρθρωσης (μνήμης) ως Διάρθρωση Κώδικα για να εκτελούνται προγράμματα σε γλώσσα μηχανής x86 (λειτουργεί και σε υπολογιστή με 64bit, ως 32bit κώδικας). Στις προηγούμενες εκδόσεις υπήρχε μεν αυτή η επιλογή αλλά δεν δούλευε ικανοποιητικά.

Από την αναθεώρηση 46 (έκδοση 9.0) το αρχείο βοήθειας άλλαξε σε Access 2007, και ως συνέπεια αυτού είναι ότι χρειάζεται να περάσουμε στο λειτουργικό το runtime της Access 2007 το οποίο δίνεται ελεύθερα από την Microsoft. Αυτή η αλλαγή έγινε για να μπορεί να γίνεται εγκατάσταση σε Linux, Wine 1.8 σε 64bit λειτουργικό και να λειτουργεί σωστά η βοήθεια.





30-10-17 Η έκδοση η 9.0 περιλαμβάνει την Υπερκλάση, μια ομάδα κοινή για ομάδες, που μπορεί να έχει μοναδικές μεταβλητές, και όλες οι ομάδες της υπερκλάσης να μπορούν να τις βλέπουν μέσω μιας "κλήσης" στην Υπερκλάση. Βελτιώθηκε η ταχύτητα του διερμηνευτή.

Μέσα σε δυο χρόνια βελτιώθηκε τόσο η 8 και έτσι προέκυψε η 9.0

Στην έκδοση 8.9 μπήκε η αυτόματη αναγνώριση αρχείου κειμένου σε UTF-8 και χωρίς την ύπαρξη BOM. Η χρήση του Not (Όχι, Δεν) μπορεί να γίνεται χωρίς παρενθέσεις μετά από λογικούς τελεστές.  Η Μ2000 απέκτησε Σταθερές, δηλαδή αναγνωριστικά που παίρνουν μια φορά τιμή από έκφραση (παράσταση) και μετά δεν μπορούμε να τα αλλάξουμε. Και πάρα πολλά άλλα πράγματα που με ανάγκασαν να αλλάξω την έκδοση σε 9.0 (μετά από 44 αναθεωρήσεις της 8.9)


Στην έκδοση 8.8 μπήκε το ευκλείδειο υπόλοιπο και διαίρεση, οι τελεστές div# και mod#, ή Δια# και Υπόλοιπο#. Επίσης μπήκε επιλογή για το πώς θα λειτουργούν τα κανονικά div και mod, κατά Visual Basic ή κατά Python. Ο διορθωτής τώρα κλείνει άμεσα αλφαριθμητικά και παρενθέσεις καθώς και μπλοκ εντολών (πληροφ.). Φτιάχτηκε json χειρισμός μέσω αντικειμένου γραμμένου σε Μ2000.


Στην έκδοση 8.7 βελτιώθηκε ο έλεγχος του κώδικα καθώς τρέχει ακόμα και από νήματα, με ανανέωση της φόρμας Έλεγχος. Συνάμα αυξήθηκε η ταχύτητα στο χειρισμό αντικειμένων. Βελτιώθηκε ο συλλέκτης σκουπιδιών.



Στην έκδοση 8.6 μπήκε το αντικείμενο Σωρός, δηλαδή ενώ είχαμε το σωρό του τμήματος ή της συνάρτησης, και μπορούσαμε να έχουμε πρόσκαιρα έναν νέο σωρό, τώρα μπορούμε να έχουμε μεταβλητές με στοιχεία σε σωρό και να τις χρησιμοποιούμε σε ένα μπλοκ Σωρός όνομα {} αφήνοντας το όνομα με ότι θέλουμε για την επόμενη φορά. Το αντικείμενο αυτό μπορεί να γυρίσει ως επιστροφή τιμής αλλά μπορεί να βγει αντίγραφο. Υποστηρίζεται και αντίγραφο ένωσης δύο σωρό (τα αντίγραφα κάνουν αντιγραφή σε πίνακες και αντικείμενα ομάδες στο σωρό). Επιπλέον τα τμήματα και οι συναρτήσεις (και οι λάμδα) μπορούν να γράφουν στον ορισμό τη λίστα παραμέτρων σε παρενθέσεις (θέλει ένα διάστημα πριν το άνοιγμα παρένθεσης),  και ουσιαστικά ο διερμηνευτής βάζει την Διάβασε με τις παραμέτρους στη πρώτη γραμμή. Φυσικά είναι προαιρετικό, μπορούμε δηλαδή να χρησιμοποιούμε τον κλασικό τρόπο με τις παραλλαγές του, όπως το να παίρνουμε προαιρετικά νέα ορίσματα. Ακόμα μια προσθήκη στις ομάδες στον ορισμό τους (λειτουργεί και σε συναρτήσεις τύπου Κλάσης, που κατασκευάζουμε ομάδες) ή ετικέτα Κλάση: η οποία δεν περιλαμβάνει ό,τι ακολουθεί στην λίστα μελών της ομάδας, ενώ λειτουργικά είναι μέλη, και έτσι στις αντιγραφές αντικειμένων όπως και στην επιστροφή από τη συνάρτηση Κλάση, δεν περιλαμβάνονται.

Στην έκδοση 8.5 οι ιδιότητες στις ομάδες μπορούν να έχουν δείκτες. Εκτός από την Αριθμός και την Γράμμα$ που σηκώνουν από το σωρό τιμών  αριθμό ή αλφαριθμητικό μπήκε και η Ομάδα και ο πίνακας, ώστε να διαβάζουμε ορίσματα απ' ευθείας σε παραστάσεις χωρίς χρήση μεταβλητής. Άλλαξε μέρος του κώδικα που φτιάχνει νέες μεταβλητές, ώστε να έχουμε ομάδες με τιμές αλφαριθμητικό, δηλαδή το όνομα της ομάδας μπορεί να έχει το σύμβολο $ στο τέλος. Πάντα θα υπάρχει και το όνομα χωρίς το $ για να επιλέγουμε τμήματα, συναρτήσεις, ιδιότητες σε μια τέτοια ομάδα. Επιπλέον μπορούμε να ορίσουμε παραμέτρους στις ομάδες όταν ζητάμε τιμή ή όταν βάζουμε τιμή.
Η έκδοση 8.4 έγινε πιο γρήγορη με την καταχώρηση των ρουτινών στην πρώτη αναζήτηση. Επιπλέον οι ομάδες απόκτησαν προαιρετικά επιστροφή τιμής και ανάθεση τιμής καθώς και προγραμματισμό τελεστών. Παράλληλα απέκτησαν ιδιότητες μόνο για ανάγνωση ή και ανάθεση τιμής, ως  ομάδες σε ομάδες. Η συνάρτηση Ομάδα() επιστρέφει αντίγραφο ομάδας ακόμα και αν η ομάδα σε παραστάσεις γυρνάει τιμή.  

Στην έκδοση 8.3 μπήκε η αλλαγή βάσης στους πίνακες, μπορούμε να έχουμε ταυτόχρονα πίνακες με βάση 0 ή βάση 1. Μπήκε η Cdr() και η Car() ή Επόμενα() και Πρώτο() για τους πίνακες. Το (1,2) δίνει αυτόματα πίνακα δύο στοιχείων. Το ((1,2), (3,4)) δίνει ένα πίνακα με δύο στοιχεία του ενός πίνακα. Φαινομενικά είναι δυο διαστάσεων αλλά τυπικά είναι πίνακες σε πίνακες, επειδή μπορούμε να αλλάξουμε κάποιο στοιχείο με άλλο πίνακα, άλλων διαστάσεων ή μεγέθους στοιχείων. Η Μήκος() δίνει τον αριθμό στοιχείων και σε πίνακες, χωρίς να κοιτάει διαστάσεις, αλλά και χωρίς να λογαριάζει τα στοιχεία πινάκων σε πίνακες. Μπήκαν οι πίνακες με μεταβλητή ως αναφορά σε πίνακα και μπορούμε με μια Α+=20  να αυξήσουμε όλα τα στοιχεία κατά 20. Φτιάχτηκε ο επαναλήπτης, ένα αντικείμενο που κρατάει αρχή, τέλος, δρομέα και λειτουργεί για πίνακες και καταστάσεις (λίστες).  Πχ η Α=(1,2,3) δίνει το Α ως πίνακα. Αν θέλουμε να διαβάσουμε το τελευταίο στοιχείο υπάρχει η Πίνακας(Α, 2). Αυτοί οι πίνακες έχουν βάση 0. Μπορούμε να ενώσουμε μια αναφορά στην Α με όνομα πίνακα πχ Α() και έτσι να χειριστούμε την Α όπως όλους τους πίνακες, ακόμα και να αλλάξουμε διάσταση, να προσθέσουμε στοιχεία.

Η έκδοση 8.2 πρόσθεσε το χειριστή <<  και τι δυνατότητα αμφίδρομης επικοινωνίας μεταξύ συναρτήσεων., με σκοπό την ροή δεδομένων (ρεύμα ή stream). 

Η έκδοση 8.1 είναι αντικείμενο (ActiveX dll) που μπορεί να φορτωθεί σε άλλες γλώσσες και να δώσει κονσόλα, γραφικά και άλλα για εξαγωγή. Περιλαμβάνει δικά της παράθυρα χρήστη, και παράθυρα διαλόγων. Ακόμα έχει δυο αντικείμενα την Κατάσταση Ειδών με κλειδιά με πίνακα κατακερματισμού εσωτερικά, και τη διάρθρωση μνήμης (buffer) που με δομές (struct) μπορούμε να βάζουμε δεδομένα στη μνήμη και να τα περνάμε στο λειτουργικό ή οπουδήποτε αλλού (μπορούμε να καλούμε C ρουτίνες).

4-5-2016 Μετά από 225 αναθεωρήσεις της 8.0 φτάσαμε στην 8.1 (σε διάστημα 11 μηνών).

12-2-16 Πρώτο τεύχος του εγχειριδίου της Μ2000. Σήμερα περιλαμβάνει 35 τεύχη.

5-7-2015 Χρήση του Git, για την έκδοση 8.  Σελίδα στο Github (αρχικά ο φάκελος λέγονταν Version8, αλλά άλλαξε σε Version 9). Η έκδοση 8 (Ιούλιος 2015) έχει τις Κλάσεις (συναρτήσεις που φτιάχνουν αντικείμενα) ως κύρια προσθήκη καθώς και βελτιώσεις ως προς την ταχύτητα. 

8-6-2015 Πρώτη δοκιμή σε Windows 7 (είχαν γίνει σε VirtualBox με Windows 7).

Η 7η έκδοση υποστήριξη Unicode, Ομάδες (αντικείμενα χρήστη) και ιδιωτικές φόρμες διαλόγων. Τα αρχεία σώνονται σε Utf-8, αλλαγή του συστήματος Βάσεων δεδομένων από DAO σε ADO (χωρίς να φανεί η αλλαγή στο χρήστη). Μετά από 18 αναθεωρήσεις ήρθε η 8η έκδοση.

Αύγουστος-Σεπτέμβριος-Οκτώβριος 2014. Ετοιμάζω τα στοιχεία ελέγχου σε VB6. Σκοπός μου ήταν να φτιαχτούν στοιχεία Unicode τα οποία θα έβγαιναν ίδια σε κάθε λειτουργικό. Δεν ήθελα να χρησιμοποιήσω τις φόρμες της VB6 γιατί αν κάποιος κράταγε πατημένο το κουμπί κλεισίματος τότε σταματούσε η εκτέλεση του προγράμματος μέχρι να αφήσουμε το πλήκτρο (το Χ πάνω δεξιά στη φόρμα).  Ήθελα να τρέχουν τα νήματα, χωρίς να πειράζονται από τα στοιχεία ελέγχου-φόρμες. Έτσι ξεκίνησα με ένα user control, που είχα παλαιότερα φτιάξει και το άλλαξα κατάλληλα ώστε να μπορεί να χρησιμοποιηθεί ως βάση για όλα τα στοιχεία.  Οι φόρμες χρήστη έχουν ένα τέτοιο στοιχείο ως γραμμή τίτλου.




29-4-2014 Το πρώτο άρθρο για την Μ2000 στο blog.  Ένα πρόγραμμα που καλεί το singtool.exe για υπογραφή προγραμμάτων με πιστοποιητικό. Γραμμένο στην τότε 6.5 έκδοση (ANSI), ενώ παράλληλα ετοιμάζονταν η 7η έκδοση (Unicode).

7-4-14 Η πρώτη ιδέα για το πώς θα δουλεύουν οι κλάσεις σε Μ2000. Το πρόγραμμα χρησιμοποιεί την Inline για να βάζει κώδικα κατάλληλο για να προσομοιάσει αντικείμενα. Τα αντικείμενα Ομάδα εισήχθησαν στην 7η έκδοση.

2013
Στην 6 έκδοση πέρασε ο κώδικας από Vb5 σε Vb6, έχει υποστήριξη νημάτων, 32 επίπεδα πάνω από την οθόνη που μπορούν να χρησιμοποιηθούν ως πρόσθετες κονσόλες ή για sprites, μουσική με νότες, ομιλία. Επίσης μπήκαν πρώτη φορά οι αναφορές, το πέρασμα τιμής με αναφορές και όχι μόνο με αντιγραφή.

(δέκα χρόνια παύση)

2003
Η πέμπτη έκδοση (5.6) λειτουργεί από το 2003, έχει γραφικά, βάσεις δεδομένων, πολυμέσα (αυτοί ήταν οι στόχοι για τη γλώσσα). Από την πέμπτη έκδοση μπήκαν συναρτήσεις με αναδρομή και πίνακες έως δέκα διαστάσεων. Η τέσσερα δεν είχε καθόλου χρόνο λόγω πολλών βελτιώσεων έγινε πέμπτη έκδοση. Η τρίτη έκδοση είχε εκδοθεί και είχε διανεμηθεί. (από το 2003)
Ξεκίνησε η συγγραφή της γλώσσας το 1999.

Δεν υπάρχουν σχόλια:

Δημοσίευση σχολίου

You can feel free to write any suggestion, or idea on the subject.