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


22-2-2018
Η γλώσσα έχει ολοκληρωθεί και λειτουργεί σε Windows και Wine 1.8 (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).

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



Από το 2003 έως το 2013 είχα σταματήσει την ανάπτυξη της γλώσσας. Κύρια λόγω της ολοκλήρωσης της βασικής ιδέας αλλά και άλλων ασχολιών - έφτιαχνα το FotodigitalLab μια εφαρμογή για εκτυπώσεις. Από το 2013 άρχισα πάλι να φτιάχνω τη γλώσσα. Και συνεχίζω μέχρι σήμερα 2017. Ομολογώ ότι ενώ μπορούσα να χρησιμοποιήσω αντικείμενα στη Visual Basic, δεν μπορούσα να σκεφτώ πώς θα τα έβαζε σε μια Script γλώσσα όπως η M2000. Τελικά για όλα υπάρχουν λύσεις. Το 2016 έκλεισα αισίως πενήντα χρόνια ζωής, και χαίρομαι για τις δημιουργίες μου! Συνεχίζω ακάθεκτος! Δεν στερεύουν οι ιδέες παρόλο που κάποιοι φορουμίστες πρότειναν να κλείσει το έργο, σκεπτόμενοι ότι ως εργαλείο η Μ2000 δεν τους κάνει. Περισσότερο με ενδιαφέρει να κάνω κάτι όσο περισσότερο καλύτερο και ας το εκτιμήσει ένας μόνο! Δεν περιμένω να φάω ψωμί από αυτό. Είναι ένα δώρο τόσο για εκείνον που το θέλει όσο και για μένα που το φτιάχνω!

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


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

Η τρέχουσα έκδοση του διερμηνευτή είναι η 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


Εδώ γίνεται χρήση γεγονότων σε μια ομάδα, και η 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()){
            acc=0
            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 λειτουργικό και να λειτουργεί σωστά η βοήθεια.






Στην έκδοση είναι η 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 είναι αντικείμενο που μπορεί να φορτωθεί σε άλλες γλώσσες και να δώσει κονσόλα, γραφικά και άλλα για εξαγωγή. Περιλαμβάνει δικά της παράθυρα χρήστη, και παράθυρα διαλόγων. Ακόμα έχει δυο αντικείμενα την Κατάσταση Ειδών με κλειδιά με πίνακα κατακερματισμού εσωτερικά, και τη διάρθρωση μνήμης (buffer) που με δομές (struct) μπορούμε να βάζουμε δεδομένα στη μνήμη και να τα περνάμε στο λειτουργικό ή οπουδήποτε αλλού (μπορούμε να καλούμε C ρουτίνες).

Η όγδοη έκδοση έχει τις Κλάσεις ως κύρια αλλαγή καθώς και βελτιώσεις ως προς την ταχύτητα. Η έβδομη έκδοση υποστήριξη Unicode και ιδιωτικές φόρμες διαλόγων. Τα αρχεία σώνονται σε Utf-8, αλλαγή του συστήματος Βάσεων δεδομένων από DAO σε ADO (χωρίς να φανεί η αλλαγή στο χρήστη). Στην έκτη έκδοση πέρασε ο κώδικας από Vb5 σε Vb6, επιπλέον υποστήριξη νημάτων, 32 επίπεδα πάνω από την οθόνη, μουσική με νότες, ομιλία. Επίσης μπήκαν πρώτη φορά οι αναφορές, το πέρασμα τιμής με αναφορές και όχι μόνο με αντιγραφή.
Η πέμπτη έκδοση (5.6) λειτουργεί από το 2003, και είναι εξίσου γρήγορη με την όγδοη, αν και δεν έχει πολλά πράγματα, έχει όμως τα βασικά, γραφικά, βάσεις δεδομένων, πολυμέσα (αυτοί ήταν οι στόχοι για τη γλώσσα). Από την πέμπτη έκδοση μπήκαν συναρτήσεις με αναδρομή και πίνακες έως δέκα διαστάσεων. Η τέσσερα δεν είχε καθόλου χρόνο λόγω πολλών βελτιώσεων έγινε πέμπτη έκδοση. Η τρίτη έκδοση είχε εκδοθεί και είχε διανεμηθεί. (το 2003)
Ξεκίνησε η συγγραφή της γλώσσας το 1999.

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

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