Πέμπτη, 24 Δεκεμβρίου 2020

Ανανέωση του βιβλίου Μαθαίνω Προγραμματισμό

Το βιβλίο Μαθαίνω Προγραμματισμό συμπλήρωσε 8 κεφάλαια. Θα συνεχιστεί η προσθήκη. Απαιτείται η τελευταία έκδοση 10 με την τελευταία αναθεώρηση 18 (ειδικά για το 8ο κεφάλαιο, γιατί βρήκα bug και το διόρθωσα).

Τα κεφάλαια που έχουν γραφτεί:

1. Το πρώτο μου πρόγραμμα!

2. Παιχνίδι: Μάντεψε έναν Αριθμό

3. Το κόσκινο του Ερατοσθένη

4. Το δένδρο του Πυθαγόρα

5. Παραγγελία Αυγών

6. Απόσταση Λιβενστέϊν

7. Ακολουθία Φιμπονάτσι με πολύ μεγάλους αριθμούς

8. Δυαδικός Αθροιστής

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

Σκοπίμως δεν έχει μπει η αναδρομή, και στην ακολουθία Φιμπονάτσι και στο δένδρο του Πυθαγόρα έχει αποφευχθεί η αναδρομή.

Υπάρχουν πολλά ιστορικά θέματα που σχετίζονται με τα κεφάλαια. Ειδικά στο κεφάλαιο 8 υπάρχουν τέσσερις σελίδες με την Ιστορία των Υπολογιστικών Μηχανών.

Ακόμα δεν έχω ιδέα για τα επόμενα κεφάλαια. Αν υπάρχει κάποια σκέψη ας γραφτεί εδώ!

Κατεβάστε το βιβλίο εδώ!


Τετάρτη, 23 Δεκεμβρίου 2020

Revision 18, Version 10

 A Bug removed so a Boolean type now written as boolean and not as string when push to stack of values, like in a multi assignment as in this example:

def k(a, b)=(a<10, b<5)
(a, b)=k(1, 20)
Print a, b

Σάββατο, 19 Δεκεμβρίου 2020

Μαθαίνω Προγραμματισμό - Τα πρώτα κεφάλαια!

Ξεκίνησα ένα βιβλίο εκπαιδευτικό για τον προγραμματισμό. Προς το παρόν έχει 7 κεφάλαια. Κάθε κεφάλαιο είναι ένα πρόγραμμα λίγων γραμμών. (22-12-20 μπήκαν τα κεφάλαια 6ο και 7ο, και αφιέρωση στην εγγονή μου Κατερίνα που έχει σήμερα γενέθλια)

Χρειάζεται να χρησιμοποιήσει ο εκπαιδευόμενος το περιβάλλον της Μ2000 και να ακολουθήσει τις οδηγίες. Υπάρχουν και ασκήσεις.

Όποιος τελειώσει το τέταρτο κεφάλαιο θα μπορεί με λίγη τύχη να φτιάξει αυτό εδώ:



Κατεβάστε το βιβλίο εδώ!

Τρίτη, 8 Δεκεμβρίου 2020

Καμπύλη Πεάνο

 

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

Το πρόγραμμα που δημιούργησε τηνjpg εικόνα αυτή είναι αυτό:

move 0,0
image "g1.emf"
a$=""
copy scale.x, scale.y to a$
image a$ export "g1.jpg", 80

Πήρε την εξαγωγή του επόμενου προγράμματος, που ήταν σε emf (σχέδιο, είναι μέγεθος 32MB, γιατί έχει όλες τις εντολές γραμμών, και εδώ το σχέδιο γίνεται με πάρα πολλές γραμμές), το εμφάνισε στην κονσόλα της Μ2000, το αντέγραψε ως Bitmap, και το έσωσε ως jpg.


Και αυτό εδώ είναι ο Εξερευνητής Πεάνο. Λογικά όλοι δημιουργούν μια καμπύλη Πεάνο με χρήση ακεραίων. Εδώ γίνεται χρήση διπλής ακρίβειας πραγματικών. Το σχέδιο γίνεται μέσα σε ένα μπλοκ Drawing (Σχέδιο) το οποίο παραδίδει μια διάρθρωση μνήμης, εδώ το B. Με μια Len(B) η Μήκος() μπορούμε να δούμε το μήκος σε Bytes. Εδώ έχει 32 εκατομμύρια Bytes. Στο τέλος την γράφουμε ως δυαδικό αρχείο, με τρεις εντολές Open, Put, Close. Η διάρθρωση B έχει φτιαχτεί ως emf, από την εντολή Drawing, δηλαδή σαν ένα αρχείο στη μνήμη. Έτσι η  εντολή εικόνα ή Image μπορεί να την διαχειριστεί.

Όπως βλέπουμε η καμπύλη δημιουργείται από μια ρουτίνα (υποπρόγραμμα), που καλεί τον εαυτό του (recursion, αναδρομή).

Την ρουτίνα την πήρα από εδώ: http://rosettacode.org/wiki/Peano_curve στην οποία έχω αναρτήσει και ένα πιο απλό πρόγραμμα!


Module Peano_Explorer {
      cls 1, 0
      once=true
      Flush
      data 3.9, 3
      for i= 3.4 to 4 step 0.018
            data i
      next i
      Drawing scale.x, scale.y {
            while not empty
                  read k
                  wi=k^4
                  n=twipsX*int(K/3*12)
                  wi2=wi*(3/k)^1.5
                  (dx, dy)=((scale.x-wi2*n)/2, (scale.y-wi2*n)/2)
                  move dx , dy
                  if once then fill wi2*n, wi2*n, 0
                  dx+=k*1.2*twipsX
                  dy+=k*1.2*twipsY
                  move dx, dy
                  if not once then Pen 15-int((k mod 0.7)*8+2) {Peano(0,0,wi,0, 0)}
                  once=false
                  next
            end while
      } as B
      Move 0,0
      image B
      open "g1.emf" for output as #f
      put #f, B
      close #f

      Sub Peano(x, y, lg, i1, i2)
            If lg ==1 Then
                  Draw to x*n+dx , y*n+dy
                  Exit sub
            end if
            lg/=k
            Peano(x+2*i1*lg, y+2*i1*lg, lg, i1, i2)
            Peano(x+(i1-i2+1)*lg, y+(i1+i2)*lg, lg, i1, 1-i2)
            Peano(x+lg, y+lg, lg, i1, 1-i2)
            Peano(x+(i1+i2)*lg, y+(i1-i2+1)*lg, lg, 1-i1, 1-i2)
            Peano(x+2*i2*lg, y+2*(1-i2)*lg, lg, i1, i2)
            Peano(x+(1+i2-i1)*lg, y+(2-i1-i2)*lg, lg, i1, i2)
            Peano(x+2*(1-i1)*lg, y+2*(1-i1)*lg, lg, i1, i2)
            Peano(x+(2-i1-i2)*lg, y+(1+i2-i1)*lg, lg, 1-i1, i2)
            Peano(x+2*(1-i2)*lg, y+2*i2*lg, lg, 1-i1, i2)
      End Sub
}

Παρασκευή, 4 Δεκεμβρίου 2020

Αναθεώρηση 12, Έκδοση 10 και ένα πρόγραμμα!

Μια μικρή διόρθωση στην αναθεώρηση 12. Όταν έβαλα το xmldata αντικείμενο, άλλαξα ένα εσωτερικό αντικείμενο mHandler, να μπορεί να βγει στη Μ2000, όχι όμως όλη η λειτουργικότητά του. Αυτό το τελευταίο επιτυγχάνεται με δηλώσεις τύπου Friend στις μεθόδους-ιδιότητες. Όταν λοιπόν εσωτερικά πρέπει να χρησιμοποιήσω αυτές τις ιδιότητες, τότε το αντικείμενο πρέπει να είναι mHandler, και όχι ένα Object που να είναι mHandler (επειδή το object έχει το dispatch interface, και αυτό εμφανίζει μόνο τις Public ιδιότητες). To mHandler είναι φορέας άλλων αντικειμένων, σε μια ιδιότητα objref, και αυτή είναι friend. Έτσι όπου χρησιμοποιούσα το mHandler ως οbject (το γενικό αντικείμενο που παίρνει τα πάντα), απλά το έγραψα σε μια μεταβλητή τύπου mHandler, οπότε αυτή χρησιμοποιεί το mHandler interface, άρα βλέπει τις Friend). Τα enumarators, λειτουργούν με φορέα το mHander, οπότε κάπου ξέχασα στη μετατροπή και άφησα ένα  objref το οποίο δεν έπρεπε να ήταν εκεί. Το module που χτύπησε στο info, ήταν το H1 το οποίο τώρα τρέχει!  Το ίδιο module (τμήμα) υπάρχει εδώ: https://georgekarras.blogspot.com/2018/11/oop-group-as-enumaration-variable-with.html


Χθες έγραψα σε ένα task στο rosetta.org, στο http://rosettacode.org/wiki/Amb

Δεν το έχω βρει το θέμα του Amb, που βγαίνει από τη λέξη ambiguous, αμφίσημος. Στο task (έργο) καλούμαστε να φτιάξουμε το χειριστή Amb ή κάποια συνάρτηση που να κάνει την ίδια δουλειά. Πραγματικά μου είναι δύσκολο να το περιγράψω στα ελληνικά!

Ένας ψευδοκώδικας δείχνει την λειτουργία του:

let x = Amb(1, 2, 3)
let y = Amb(7, 6, 4, 5)
Amb(x * y = 8)
print x, y

Το Amb πρέπει να βρει τα x και y που ικανοποιούν την συνθήκη x*y=8.

Το συγκεκριμένο έργο ζητάει από τα τέσσερα παρακάτω (δηλαδή σαν να έχουμε τέσσερις λίστες, ή πίνακες), να βρεθούν οι τέσσερις λέξεις που δίνουν "that thing grows slowly" και η συνθήκη λέει ότι κάθε λέξη με τις διπλανές τις θα έχει το ίδιο γράμμα, έτσι το thing ξεκινάει με t όπως τελειώνει το that, και τελειώνει σε g όπως ξεκινάει το grows.

  1. "the" "that" "a"
  2. "frog" "elephant" "thing"
  3. "walked" "treaded" "grows"
  4. "slowly" "quickly"

Το ενδιαφέρον εδώ δεν είναι να δώσουμε ένα πρόγραμμα με προκαθορισμένες επαναλήψεις. Για το λόγο αυτό λέγεται και ανήκει στο "non-deterministic finite automaton". Εδώ τα δεδομένα πρέπει να καθορίσουν τον αριθμό ελέγχων, ή ακόμα και επαναλήψεων.

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

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

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

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

Στο πρώτο πρόγραμμα ο έλεγχος γίνεται σε μια λάμδα που ζητάει πίνακες (ενός στοιχείου) οπότε μέσα στη λάμδα αυτή έχουμε δώσει το τρόπο που θα διαβαστούν οι τιμές με τις συνοδευτικές συναρτήσεις #Val() ή #Val$() αντίστοιχα. Το # στο όνομα δηλώνει ότι αυτές εφαρμόζονται στον αυτόματο πίνακα, ή tuple, (είναι ένα είδος linq στην Μ2000, δηλαδή σαν μια ενσωματωμένη γλώσσα ερωτημάτων, και υπάρχουν αρκετές, μερικές από τις οποίες δίνουν νέα tuple, και έτσι μπορούμε να έχουμε μια σειρά από αυτές τις "συνοδευτικές" συναρτήσεις, και να εξάγουμε στοιχεία υπό κάποια διαμόρφωση).

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

Module AmbFunction {
      Function Amb (failure) {
            // get an array of s items, return an array of 1 item
            // we do this so we forget the type of element
            getitem=lambda (n, c) -> {
                  dim z(1) :link c to c()
                  stock c(n) keep 1, z(0) // copy from c(n) to z(0) one item
                  =z()
            }
            read a
            c1=lambda a, getitem (i, &any, &ret) ->{
                  any=getitem(i, a)
                  ret=any
                  =true
            }
            m=stack.size
            if m=0 then Error "At least two arrays needed"
            c=c1
            while m>1 {
                  read b
                  c1=lambda c2=c, j=0, m=len(a), b, failure, getitem (i, &any, &ret) ->{
                        any=getitem(i, b)
                        ret=(,) : ok=false : anyother=(,)
                        do
                              if c2(j, &anyother, &ret) then
                                    if not failure(any, anyother) then
                                          ok=true
                                          ret=cons(ret, any)
                                    end if
                              end if
                              j++
                        until ok or j=m
                        if j=m then j=0
                        =ok
                  }
                  c=c1 : a=b : m--
            }
            read b
            amb1=lambda c2=c, j=0, m=len(a), b, failure, getitem (&ret) ->{
                  ret=(,) : ok=false: anyother=(,)
                  k=each(b)
                  while k
                        any=getitem(k^, b)
                        do
                              if c2(j, &anyother, &ret) then
                                    if not failure(any, anyother) then
                                          ok=true
                                          ret=cons(ret, any)
                                    end if
                              end if
                              j++
                        until ok or j=m
                        if j=m then j=0
                        if ok then exit
                  end while
                  =ok
            }
            ret=(,)
            if amb1(&ret) then =ret
      }

      a=(1, 2, 3)
      b=(7, 6, 4, 5)
      failure=lambda (a,b)->{
            =a#val(0)*b#val(0)<>8
      }
      Print amb(failure, a, b)#str$()
      a=("the", "that", "a")
      b=("frog", "elephant", "thing")
      c=("walked", "treaded", "grows")
      d=("slowly", "quickly")
      failure=lambda (a,b)->{
            =left$(a#val$(0),1)<>right$(b#val$(0),1)
      }
      Print amb(failure, a, b, c, d)#str$()
}
AmbFunction


2 4
that thing grows slowly


Η δεύτερη λύση

Module AmbFunction {
      Enum Solution {First, Any=-1}
      Function Amb(way as Solution, failure) {
            // get an array of s items, return an array of 1 item
            // we do this so we forget the type of element
            getitem=lambda (n, c) -> {
                  dim z(1) :link c to c()
                  stock c(n) keep 1, z(0) // copy from c(n) to z(0) one item
                  =z()
            }
            read a
            c1=lambda i=0, a, getitem (&any, &ret) ->{
                  any=getitem(i, a)
                  ret=any
                  i++
                  ok=i=len(a)
                  if ok then i=0
                  =ok
            }
            m=stack.size
            if m=0 then Error "At least two arrays needed"
            c=c1
            while m>0 {
                  read a
                  c1=lambda c2=c, i=0, a, getitem (&any, &ret) ->{
                        any=getitem(i, a)
                        ret=(,) : ok=false : anyother=(,)
                        ok=c2(&anyother, &ret)
                        ret=cons(ret, any)
                        if ok then i++
                        ok=i=len(a)
                        if ok then i=0
                        =ok
                  }
                  c=c1 : m--
            }
            ok=false
            any=(,)
            flush
            while not ok
                  ret=(,)
                  ok=c(&any, &ret)
                  s=stack(ret)
                  if not failure(! s) then data ret : if way>0 then ok=true
            End While
            if empty then
                   ret=(("",),)
             else
                    ret=array([])
             end if
             =ret
      }

      a=(1, 2, 3)
      b=(7, 6, 4, 5)
      failure=lambda (a,b)->{
            =a*b<>8
      }
      Print Amb(First, failure, a, b)#val(0)#str$()
      a=("the", "that", "a")
      b=("frog", "elephant", "thing")
      c=("walked", "treaded", "grows")
      d=("slowly", "quickly")
      failure=lambda (a$, b$, c$, d$)->{
            def amb(x$, y$)=right$(x$,1)<>left$(y$,1)
            =amb(a$,b$) or amb(b$,c$) or amb(c$, d$)
      }
      Print amb(First, failure, a, b, c, d)#Val(0)#str$()
      Range=lambda (a, f) ->{
            for i=a to f-1: data i: next
            =array([])
      }
      Print "Small Pythagorean triples problem:"
      a=range(1,11)
      b=a
      z=a
      failure=lambda (a, b, z)->{
            =not (a^2+b^2=z^2)
      }
      all=amb(Any,failure, a, b, z)
      k=each(all)
      while k
            z=array(k)
            Print z#str$()
      end while

}
AmbFunction

2 4
that thing grows slowly
Small Pythagorean triples problem:
4 3 5
3 4 5
8 6 10
6 8 10



Τετάρτη, 2 Δεκεμβρίου 2020

Αναθεώρηση 11, Έκδοση 10

 Σε αυτήν την αναθεώρηση διόρθωσα δυο λάθη, και έβαλα δυο αντικείμενα για χειρισμό json αρχείων. Είχα γράψει έναν parser για Json αρχεία, σε M2000, αλλά τώρα έγραψα έναν πολύ γρήγορο σε VB6, με δυο αντικείμενα, ανάλογα με τι ξεκινάει το αρχείο (πίνακας ή αντικείμενο). Αν δεν ξεκινάει με κάτι από αυτά τότε είναι η λεγόμενη json value, και για να την πάρουμε σωστά πρέπει να την περάσουμε σε πίνακα, δηλαδή να βάλουμε τα "[" και "]" και να την χειριστούμε ως το στοιχείο με το δείκτη 0.

Ένα λάθος είχε να κάνει με το τμήμα Tuple στο info. Το άλλο ήταν ένα λογικό λάθος βάσει σχεδιασμού. Αν έχουμε ορίσει την Α()  ως ιδιότητα αρχείου COM (εσωτερικό ή εξωτερικό δεν έχει σημασία) τότε μια δήλωση α(1)=α(1) δούλευε αλλά  λόγω ότι έπαιρνε το δείκτη 1 δεξιά και τον εφάρμοζε στην αριστερή έκφραση. Τώρα δουλεύει σωστά γιατί κρατάω το δείκτη αριστερά και όταν εκτελεστεί η ιδιότητα δεξιά τότε εφαρμόζω το δείκτη. Το α(1) μοιάζει με πίνακα αλλά δεν είναι εδώ, και ο δείκτης μπορεί να είναι αλφαριθμητικό (και μάλιστα για την ίδια ιδιότητα μπορεί να χρησιμοποιούνται οποιοδήποτε από τα δύο).. Στους πίνακες δεν έχουμε τέτοιο θέμα γιατί ο διερμηνευτής υπολογίζει τη θέση του στοιχείου και την κρατάει για να την εφαρμόσει στο τέλος.

Στην επόμενη αναθεώρηση, ήδη έχω κάνει την προετοιμασία, θα βάλω την δυνατότητα να χειριζόμαστε ιδιότητες COM αντικειμένων με περισσότερους από έναν δείκτη.

Σε λίγες μέρες....η επόμενη αναθεώρηση!



Τρίτη, 17 Νοεμβρίου 2020

Αναθεώρηση 9, Έκδοση 10

 Σε αυτήν την αναθεώρηση πρόσθεσα την διαφάνεια του τίτλου μιας φόρμας χρήστη. Εκτός από τη διαφάνεια μπορούμε να ορίσουμε το χρώμα των γραμμάτων του τίτλου και το χρώμα των εικονιδίων για το κλείσιμο, την επέκταση στην οθόνη (maximize), και την απόκρυψη (minimize).

Υπάρχουν παραδείγματα στο info, που προσαρμόστηκαν για να δείχνουν τις νέες δυνατότητες:

Στο List33, έχει περαστεί πίσω ένα φόντο με διαβάθμιση οριζόντια. Μπορούμε να αλλάζουμε το μέγεθος του παράθυρου, και άμεσα αναπροσαρμόσεται το φόντο και η θέση του Hello World. Το στοιχείο Λίστα (ListBox) είναι διάφανο και η μπάρα ολίσθησης είναι κρυμμένη.






Στη ΓΛΩΣΣΑ, το φόντο έχει διαβάθμιση, και έχει αλλαχθεί το χρώμα των εικονιδίων (δείτε τα τρια δεξιά και ένα στα αριστερά στο τίτλο). Επίσης έχει αλλαχθεί το χρώμα του τίτλου.  Επειδή τα στοιχεία ελέγχου παίρνουν το χρώμα από το τίτλο, αν κάναμε την αλλαγή στη αρχή, θα βλέπαμε και στο Κείμενο (EditBox) να άλλαζε το βασικό χρώμα.


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



Παράδειγμα Textonly. Εδώ υπάρχει ένα νήμα που αλλάζει το μέγεθος της μαύρης έλλειψης. Όπως βλέπουμε έχει φτάσει στο τίτλο. Παρόλο που ο τίτλος, το κείμενο (Editbox, σε διαμόρφωση που απλά βλέπουμε κείμενο) και η εισαγωγή (TextBox), δεν είναι πραγματικά διάφανα, αλλά λογικά, δηλαδή αντιγράφουν το φόντο, η αυξομείωση του μεγέθους της μαύρης έλλειψης γίνεται σαν να είναι διάφανα, επειδή η ανανέωση της φόρμας γίνεται ταυτόχρονα για όλα τα στοιχεία. Μποορύμε να γράφουμε ή να ολισθαίνουμε το κείμενο, και η αυξομοίωση θα συμβαίνει χωρίς να έχουμε "αναβοσβήματα" ή flickering (η απουσία flickering, είναι ένα από τα υπερ του στοιχείου που έχω γράψει, εξολοκλήρου, και περιέχεται και στο τίτλο, και στο κείμενο και στη γραμμή εισαγωής, και σε όλα τα στοιχεία για φόρμες της Μ2000, με αντικείμενα που κληρονομούν το βασικό αυτό αντικείμενο).



Κυριακή, 15 Νοεμβρίου 2020

A like record in C# 9.0 object in M2000

Reading https://docs.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-9, I found record type that can be emulated in M2000:

In the example bellow, we have a class Person, with 2 readonly properties (they have only the value part, the set part is omitted). A property is a group, and the definition is a syntactic sugar, which define a private variable, so for name$ the private is [name]$  (characters "[" and "]" can be used for names).

We make a synthesized property, the tuple. A group inside a group (a class make a group) can't read parent values, except we explicitly declare and only for parent some linked variables (we can link functions too, but no modules). Here we link the private members. Links are references. So the tuple (name$, last$) return the values of parent [name]$ and [last$].

We make an operator "==" for equality. In the expression person == brother, the calling to operator done to brother, so the Read other is the by value pass of person. We check to see if we have the type Person, so if we don't we get error. We can use push other.[name]$=.[name]$ and other.[last]$=.[last]$ which directly check private variables, because the reading group has the same type (Person) with current group, so the private members of group other exist also as public for this function (operator "=="). The push statement pus the boolean number to the current stack, and this stack reading from the expression evaluator (expect one value, otherwise we get error).

Info: Stack in M2000 is for values only, has nothing to do with return or process stack. A module pass the current stack to any calling module. A function (as those we make with Function {} statement, and the lambda functions) start with a new stack (and any parameter) when call it from expression. There are static functions (created at the end of the code (in any module or non static function) with Function / End Function) which use the current stack and called with @ before the name. Non static functions and modules can change code dynamically (for the next execution), static functions and subs can't change code. Also static functions and subs haven't a namespace, the have the same where they belong. So we have to use Local to make local variables. In modules and standard functions, and lambda functions, all variables are local by default to the name space which computed from the name and the order of execution. To finish this info, we can use GOTO and GOSUB inside module's boundaries (also standard functions). A Gosub call a code by  number or alphanumeric label, and expect to find a bare Return statement, using same namespace, same stack and without introducing local variables (it is just some line of code which we want to execute and we want to not repeat it).

To execute this example: Run m2000.exe, write Edit A, press enter, paste the code, press Esc and write A and press enter. You can save it using Save CSharpLike  so after that give a New or press Break key, and the give a Load CharpLike and with Ctrl+N you get the list of modules in ChsarpLike.gsb (the name of file, which you just load), and this list has one module the A.


Class Person {
      // read only
      property name$ {value}
      property last$ {value}
      // a synthesized property
      group tuple {
            value {
                  link parent [name]$ to name$
                  link parent [last]$ to last$
                  =(name$, last$)
            }
      }
      operator "==" {
            // check the type of other
            read other as Person
            push other.name$=.name$ and other.last$=.last$
      }
Class:
      // class: part. Here anything exist only at contruction
      // .[name]$ is the private variable under .name$ property
      module Person (.[name]$, .[last]$) {
      // no code here,
      // (.[name]$, .[last]$) is a syntactic sugar for statement Read .[name]$, .[last]$
      }
}
Function FirstName(name$) {
      group fake {
      // groups have no types
      // we can use type: Person if we wish to add one type manual
      // or we can put a list of type names: type: Person, Student
      private:
            [name]$=name$
      }
      =fake
}
Function One(what$, value$) {
      // no need to change value$ to  something like "{1}" in format$()
      // because a group definition executed in the same name space where belong,
      // for right expressions, so =value$ read the value$ of function One()
      // for left add a new name space:
      // the expanded name of this namespace with name fake
      // internal interperter compute the namespaces by the calling order, to be short for faster execution
      a$=format$({private: [{0}]$=value$ }, filter$(what$,"$"))
      // this is a way to pass a string as type,
      // not a class type, but in code type, if we use standard string,
      // but here isn't that case, we only pass a computed definition
      group fake type a$
      =fake
}
person=Person("Bill", "Vagner")
Print person.name$, person.last$
// export values as tuple
(first$, last$)=person.tuple
A=person.tuple
Print first$, last$, A#val$(0)=first$
sister = person with FirstName("Susan")
(first$, last$)=sister.tuple
// we can print tuple (not converted to string, Print statement make an iterator automatic and get each item)
Print first$, last$, sister.tuple
brother = person with one("name$","Paul")
(first$, last$)=brother.tuple
Print first$, last$
Print person == person
Print person == sister
Print person == brother



Παρασκευή, 13 Νοεμβρίου 2020

Revision 8, Version 10

 A bug in XMLdata fixed. Additions for Listbox, Editobox, Combo (also with combo we make menu, so this is for menu two). 

1. All lists (including EditBox) now display the part of line if exist in the bottom:



2. We can change color for vertical scroll bar:

      Method Pad, "SetBarStyle", color(50, 100, 200), 5, 15

15 is for white (0 to 15 are the standard colors, color() return a negative number for RGB)

5 is for the hatch type, and white is the hatch color. 


The cs example change colors for editbox, here are the dark colors. So here we have another statement:
        Method Pad, "SetBarStyle", #DD9033, -1
The -1 remove the hatch, so all parts of the bar has one color. The bar is normally hidden and open if we move the mouse pointer over it, or if we use the keyboard page up and page down, or  if we push a line up or down holding the left mouse button down, or if we handle the mouse wheel (is same as page up/page down). In editor page up/down done at half actual page.size). All controls are made from one control. So the title of form, the combo box and the edit box have the same type control, but the have different objects which inherits the base class, the one control.


I am thinking now for adding some controls (that belongs to environment). From the language part, some day I would make an Ast Interpreter. Also I have to make some books, for kids.

For this version (10) I have to put 3D hardware accelerated graphics, using DirectX 11. I am looking for a solution, with a nice interface, so kids may use them without hard maths. There is something interesting here: 

https://www.vbforums.com/showthread.php?889232-VB6-DirectX-11-for-VB6-1-0-Type-Library

Τετάρτη, 11 Νοεμβρίου 2020

Αναθεώρηση 7, Έκδοση 10

 Τελειοποίησα το XMLData αντικείμενο. Η βασική ιδιότητα, xml δίνει το δένδρο σαν κείμενο και παίρνει το δένδρο σαν κείμενο (διαγράφοντας το τρέχον δένδρο). Αυτό γίνεται σε κάθε κλαδί (το οποίο είναι επίσης ένα δένδρο). Μπορούμε να στήνουμε το δένδρο προγραμματιστικά με εντολές αντί να δώσουμε το κείμενο. Τώρα προστέθηκαν και εντολές για διαγραφή. Στο info προστέθηκε το xml2, που δείχνει πως βγάζουμε τα κλαδιά (με δείκτες σε αντικείμενο) σε μια λίστα, όπου τα ταξινομούμε και μετά στήνουμε γρήγορα το δένδρο, αντί να βάζουμε XMLnode, απευθείας με XMLdata.

To XMLNode είναι ένα αντικείμενο που μας δίνει το XMLdata και πάνω σε αυτό κάνουμε προσθήκες σε χαρακτηριστικά (attributes),  προσθήκη σε τιμή, και το βάζουμε σε ένα αρχικά απροετοίμαστο XMLNode του λείπει το XMLNode. Δεν μπορούμε να χειριστούμε κάτι από το XMLNode γιατί είναι κλειστό για μας. Απλά το δίνουμε στο   XMLdata και αυτό το χειρίζεται, μέχρι να το δώσουμε για "πάντα",  και έτσι να κάνουμε το XMLdata να λειτουργεί. Στην ουσία υπάρχει ένα άλλο αντικείμενο εσωτερικά στο XMLData το οποίο έχει διαφορετικό όνομα και αυτό δεν το προσεγγίζουμε άμεσα. Το XMLData εμφανίζεται σαν XMLmono τύπος, είναι ένας Adapter, όπου το αυθεντικό XMLmonoInternal απλά βρίσκεται μέσα του. Όλο το δένδρο είναι φτιαγμένο μόνο με το XMLmonoInternal, αλλά η πρόσβαση σε αυτό γίνεται με τους Adapters. Πχ όταν κάνει αναζήτηση ενός tag (ετικέτας) για να δημιουργήσει μια λίστα, εσωτερικά το XMLmonoInternal χρησιμοποιεί το αντικείμενο Collection (της VB), και το αποτέλεσμα το παίρνει το εξωτερικό αντικείμενο XMLmono, και το μεταγράφει σε αντικείμενο της Μ2000, που μπορούμε να το δουλέψουμε πιο εύκολα (σε αντικείμενο σωρό τιμών). Όταν ζητάμε ένα δείκτη για ένα δένδρο εσωτερικό του δένδρου, τότε το XMLmono φτιάχνει ένα νέο XMLmono (λέγεται και wrapper), και σε αυτό δίνει τον "κρυφό" δείκτη του XMLmonoInternal.

Δείτε πως έχει το πράγμα. Τα αντικείμενα που χειριζόμαστε στη Μ2000 είναι τριών ειδών. Το ένα είναι το Group ή Ομάδα, και λέγεται και αντικείμενο χρήστη γιατί το φτιάχνει όπως θέλει, εδώ χρησιμοποιούμε την τελεία για να δείξουμε τα μέλη της ομάδας που θα χρησιμοποιήσουμε, Το δεύτερο είναι τα αντικείμενα που παρέχει η γλώσσα για να βάζουμε στοιχεία, όπως οι πίνακες, οι δείκτες σε πίνακες (τουπλέ),, οι λίστες, οι σωροί, και άλλα. Αυτά έχουν εντολές που γράφουμε περιφραστικά, είναι ενσωματωμένα στο συντακτικό της γλώσσας. Τέλος έχουμε τα εξωτερικά, τα λεγόμενα COM. Αυτά μπορεί να είναι από το σύστημα ή ιδιωτικά. Ορισμένα αντικείμενα εσωτερικά της Μ2000 μπορούν να χρησιμοποιηθούν από άλλα προγράμματα, όπως η λίστα. Όλα αυτά τα COM αντικείμενα (και οι φόρμες και τα στοιχεία ελέγχου του GUI) τα χειριζόμαστε με τις εντολές Όρισε (Declare), ή και με την Όρισε ΜεΓεγονοτα (Declare WithEvents),   Μέθοδος (Method) και συνδέουμε μεταβλητές με ιδιότητες με την Με (With),. Επειδή αυτά γίνονται ενώ εκτελείται το περιβάλλον, δηλαδή για το περιβάλλον εκτέλεσης είναι Late Bound, η προσπέλαση στα αντικείμενα γίνεται μόνο από τις μεθόδους και τις ιδιότητες που δηλώνονται Pubic στη VB6 ή όποια άλλη γλώσσα (τα COM αντικείμενα μπορούν να γραφτούν σε διάφορες γλώσσες, στην ουσία αυτό που έχουμε είναι γλώσσα μηχανής και σύνδεση με βιβλιοθήκες).  Για να επικοινωνούν τώρα αντικείμενα και κώδικας μέσα από το περιβάλλον (τον εκτελέσιμο κώδικα), υπάρχουν οι μέθοδοι και ιδιότητες που ορίζονται ως Friend, φιλικές, δηλαδή μπορούν να χρησιμοποιηθούν μόνο από τον "ιδιοκτήτη" ή "κατασκευαστή" ενός αντικειμένου. Στην περίπτωσή εδώ από τη Μ2000. Έτσι με αυτό το επίπεδο "ασφάλειας", υπάρχει απομόνωση από το μέρος του προγράμματος σε Μ2000 και του εκτελέσιμου του περιβάλλοντος της Μ2000.

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

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

Γενικά οι γλώσσες όπως η VB6 λειτουργεί με tlb βιβλιοθήκες, τiς λεγόμενες Type Libraries. Τα αντικείμενα COM έχουν για τη διεπαφή iDispatch ενσωματωμένη βιβλιοθήκη και η Μ2000 μπορεί να την δείξει. Δείτε το παράδειγμα FS με ποιο τρόπο εμφανίζουμε στη κονσόλα της Μ2000 τις μεθόδους και τις ιδιότητες ενός αντικειμένου  COM.

Αυτά προς το παρόν.

ΓΚ