Page 1 sur 2

Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 01 Mai 2019, 18:45
de critor
11124Pour la rentrée 2019, Casio sort la Graph 35+E II, une nouvelle déclinaison de son modèle Graph 35+E numéro 1 au lycée. Une des nouveautés annoncées est l'ajout d'une application Python. :bj:

Avec Victor D et Lephe, administrateur de Planète Casio, nous avons participé à la tournée pédagogique Casio à Toulouse mercredi 10 avril. Nous avons pu y utiliser une Graph 35+E II qui contrairement à l'échantillon qui nous a été remis et que nous t'avons présenté depuis, disposait bien de l'application Python intégrée.

En attendant que la mise à jour intégrant cette application Python sorte fin Mai 2019, découvrons ensemble cette version non finale.






1) Applications intégrées :

Go to top

11117
Nous constatons donc dès l'écran d'accueil de cette Graph 35+E II la présence d'une application supplémentaire, PYTHON.

Un petit tour par la mémoire de stockage ne révélant aucune trace d'un fichier .g1a associé à cette application, il s'agit donc non pas d'une application additionnelle, mais d'une application intégrée, qui donc , contrairement à l'application additionnelle non officielle CasioPython aura l'énorme avantage de rester utilisable en mode examen ! :bj:

Le nombre d'applications intégrées passe donc de 16 à 17 ! :D

Malgré donc la quantité supplémentaire de code qui a été nécessaire, nous apprécions que la mémoire de stockage conserve une capacité de 3Mio. :bj:




2) Version système :

Go to top

L'application SYSTEM intégrée nous permet d'apprendre que la calculatrice faire tourner un système d'exploitation en version 03.05.2200, plus récent donc que le 3.00.2200 de notre échantillon.

Rappelons que le numéro final à quatre chiffres ne fait pas vraiment partie de la numérotation et indique des spécificités issues du matériel ou du logiciel, dans l'ordre :
  1. zonage géographique; lié entre autres à divers options par défaut (format d'affichage des fractions, langues) ainsi qu'au comportement du mode examen :
    • 0 : aucun
    • 1 : Australie
    • 2 : France
    • 3 : Amérique du Nord
    • 4 : Chine
    • 5 : Singapour
  2. améliorations du calcul :
    • 0 : aucune
    • 1 : saisie naturelle + calcul exact (fractions uniquement) + affichage naturel (fractions uniquement) (fx-9860G Slim)
    • 2 : saisie naturelle + calcul exact + affichage naturel
    • 3 : saisie naturelle + calcul exact (fractions uniquement) + affichage naturel (fractions uniquement) (fx-9860GIIs)
    • 7 : calcul exact (fractions uniquement) (fx-9750GII)
  3. sous-version
  4. processeur :
    • 0 : SH3 (SH7355)
    • 1 : SH4 (SH7305)
Il s'agit donc plutôt d'une version 3.05.

L'année dernière pour la Graph 90+E, la version rajoutant Python sur les salons ainsi qu'à la tournée pédagogique fut la 3.15, alors que les échantillons remis étaient en 3.10 et que la mise à jour finale rajoutant Python pour la rentrée 2018 fut la 3.20.

Nous pensons donc qu'ici, la mise à jour finale rajoutant Python qui sera publiée fin Mai 2019 sera en version 3.10.

D'ailleurs si l'on fait défiler cet écran, on remarque que les langues intégrées utilisent déjà une numérotation en 3.10.

Tentons maintenant d'en découvrir davantage sur ce nouveau système d'exploitation en accédant au menu de diagnostic caché. Il suffit pour cela d'allumer la calculatrice tout en maintenant les touches
OPTN
et
×10^x
, puis de taper
F1
9
.

Si nous tapons
4
pour VERSION, nous apprenons que le système d'exploitation 3.05 a été compilé le 25 mars 2019 à 15h16, ce qui est effectivement plus récent que le 8 février 2019 à 3h03 pour la version 3.00 de notre échantillon.




3) Implémentation Python :

Go to top

Accédons donc à l'application PYTHON et ouvrons la console. Le message d'accueil nous apprend que nous sommes sur une implémentation MicroPython 1.9.4, exactement comme sur la Graph 90+E.

Pour référence, voici ce que nous avons sur les solutions concurrentes auxquelles nous allons par la suite confronter la Graph 35+E II 3.05 :
  • Casio Graph 35+E II : MicroPython 1.9.4
  • Casio Graph 90+E / fx-CG50 : MicroPython 1.9.4
  • application CasioPython sur Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII : MicroPython 1.9.4
  • application KhiCAS sur Casio Graph 90+E / fx-CG10/20/50 : couche de traduction
  • NumWorks : MicroPython 1.9.4
  • application MicroPython sur TI-Nspire : MicroPython 1.4.6
  • module externe TI-Python pour TI-83 Premium CE : CircuitPython 3.0.0
  • HP Prime : couche de traduction




4) Nombres flottants, complexes, entiers courts et longs :

Go to top

Commençons par tester les nombres flottants qui, rappelons-le, sont représentés en mémoire sous la forme
$mathjax$\pm M\times 2^{E-E_{min}}$mathjax$
avec
$mathjax$M\in [1;2[$mathjax$
. Prenons la fonction Python suivante :
Code: Tout sélectionner
def precm(b):
  k,b=0,float(b)
  while 1+b**-k-1>0:
    k+=1
  return k

L'appel precm(2) nous apprend que la mantisse M des nombres flottants peut avoir jusqu'à 53 bits, et l'appel precm(10) nous précise que cela correspond à 16 chiffres significatifs.

Continuons à creuser les flottants avec la fonction Python suivante :
Code: Tout sélectionner
def prece():
  a=-1
  while 2.**a>0:
    a*=2
  while 2.**a==0:
    a+=1
  b=1
  while str(2.**b)[0:3]!='inf':
    b*=2
  while str(2.**b)[0:3]=='inf':
    b-=1
  return [a,b]

L'appel prece() nous indique que les bits restants permettent à l'exposant des nombres flottants de prendre des valeurs allant de -1074 à +1023.

C'est identique à ce qu'apportent dans leurs dernières versions toutes les solutions concurrentes évoquées plus haut.

Les nombres complexes quant à eux sont visiblement gérés, mais le module cmath apportant les fonctions complexes qui vont avec est ici manquant. :(


MicroPython
TI-Nspire
NumWorks
Casio
Graph 35+E II
Graph 90+E
CasioPython
Graph 35+E II
Graph 35+E/USB
Graph 75/85/95
TI-Python pour
TI-83 Premium CE
firmware tiers
TI-Python pour
TI-83 Premium CE
nombres complexes
module cmath
(fonctions complexes)


D'où le classement suivant pour les nombres complexes :
  1. NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython) + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE (firmware tiers) avec nombres et fonctions complexes
  2. Casio Graph 35+E II / 90+E / fx-CG50 avec nombres complexes
  3. module externe TI-Python pour TI-83 Premium CE
La faible gestion des nombres complexes est bien dommage pour les élèves de Terminale S/STI2D/STL, même si on peut exceptionnellement passer l'éponge cette année vu que le Python n'a été imposé en Seconde qu'à la rentrée 2017.


Enfin, nous sommes sur une plateforme 32 bits (processeur SH4) et pouvant visiblement réaliser des calculs entiers nécessitant 33 ou même 65 bits. Aucun doute, la gestion des entiers longs est donc activée. :bj:

C'est ici aussi identique à ce qu'apportent dans leurs dernières versions toutes les solutions concurrentes.




5) Liste modules Python :

Go to top

Nous venons donc de voir que la Graph 35+E II ne disposait pas du module cmath. En fait elle n'a pas grand chose, exactement comme la Graph 90+E, la Graph 35+E II ne dispose que de deux modules Python permettant de rajouter des fonctions, math et random, à rajouter bien évidemment au module par défaut builtins.

Image


D'où le classement suivant en terme d'éventail de modules :
  1. 13 modules : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
  2. 8 modules : NumWorks + Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII + TI-Nspire (application MicroPython) + module externe TI-Python pour TI-83 Premium CE
  3. 3 modules : Casio Graph 35+E II / 90+E / fx-CG50

Dommage donc que la modeste sélection de modules de la Graph 90+E, déjà la plus légère parmi toutes les solutions concurrentes, ait été reprise à l'identique au lieu d'être étoffée pour la Graph 35+E II.




6) Exploration modules Python :

Go to top

Le script Python suivant nous permet d'explorer le contenu des modules que nous avons trouvés :
Code: Tout sélectionner
def sstr(obj):
  try:
    s=obj.__name__
  except:
    s=str(obj)
    a=s.find("'")
    b=s.rfind("'")
    if a>=0 and b!=a:
      s=s[a+1:b]
  return s

def isExplorable(obj):
  s=str(obj)
  return s.startswith("<module '") or s.startswith("<class '")

def explmod(pitm,pitmsl=[],reset=True):
  global curline
  if(reset):
    curline=0
    pitmsl=[sstr(pitm)]
  hd="."*(len(pitmsl)-1)
  spath=".".join(pitmsl)
  c=0
  for itms in sorted(dir(pitm)):
    c=c+1
    try:
      itm=eval(spath+"."+itms)
      print(hd+itms+"="+str(itm))
      if isExplorable(itm):
        pitmsl2=pitmsl.copy()
        pitmsl2.append(itms)
        c=c+explmod(itm,pitmsl2,False)
    except:
      print(hd+itms)
  if c>0:
    print(hd+"Total: "+str(c)+" item(s)")
  return c

Ici, nous apprenons sans surprise que les modules builtins, math et random comportent respectivement 175, 25 et 8 éléments, exactement comme sur Graph 90+E.


Il semble bien que l'application PYTHON de la Graph 35+E II soit un portage à l'identique de l'application déjà disponible pour la Graph 90+E.
Image

D'où le classement suivant en terme de richesse des modules :
  1. 354 éléments : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
  2. 310 éléments : TI-Nspire (application MicroPython)
  3. 301 éléments : NumWorks
  4. 294 éléments : Casio Graph 35+E II / 35+E/USB / 75/85/95 / fx-9750GII / fx-9860G/GII (application CasioPython)
  5. 258 éléments : module externe TI-Python pour TI-83 Premium CE
  6. 208 éléments : Casio Graph 35+E II / 90+E / fx-CG50




7) Mémoire de travail Python :

Go to top

La mémoire de travail en Python va accueillir :
  • les définitions globales (variables, fonctions, classes) issues des scripts importés
  • les arguments d'appel de la ou des fonctions en cours d'exécution
  • les définitions locales effectuées par la ou les fonctions en cours d'exécution
La taille de la mémoire de travail conditionne donc jusqu'où il sera possible d'aller en Python, nombre d'appels récursifs par exemple.

Voici quelques tailles occupées en mémoire par des variables Python :
  • 64 octets pour une liste vide
  • 8 octets par élément de liste supplémentaire
  • 24 octets pour un entier nul
  • 28 octets pour un entier court non nul
  • 49 octets pour une chaîne vide
  • 1 octet par caractère de chaîne supplémentaire

En se basant sur ces tailles, le script suivant permet d'estimer la capacité de la mémoire de travail en allouant plusieurs blocs de mémoire jusqu'à épuisement :
Code: Tout sélectionner
def mem():
  try:
    l=[]
    try:
      l+=[0]
      l+=[""]
      l[1]+="x"
      while True:
        try:
          l[1]+=l[1][l[0]:]
        except:
          if l[0]<len(l[1])-1:
            l[0]=len(l[1])-1
          else:
            raise(Exception)
    except:
      print("+",len(l)>1 and len(l[1]))
      return 64+8*len(l)+(len(l) and 24+4*(l[0]>0)+(len(l)>1 and 49+len(l[1])))+mem()
  except:
    return 0


Voici la sortie obtenue par l'appel mem() :
Graph 35+E II a écrit:>>> from mem import *
>>> mem()
+ 40961
+ 14334
+ 10239
+ 10238
+ 4111
+ 4095
+ 3071
+ 2172
+ 1534
+ 1023
+ 575
+ 350
+ 191
+ 64
+ 64
+ 15
95549
>>>


Le script arrive donc à allouer en mémoire de travail un premier bloc continu maximal de près de 41K, pour un total de 95,549 Ko. :bj:

D'où le classement suivant :
  1. 2,046 Mo : TI-Nspire (application MicroPython)
  2. 1,027 Mo : Casio Graph 90+E / fx-CG50
  3. 255,07 Ko : Casio Graph 35+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython)
  4. 95,549 Ko : Casio Graph 35+E II
  5. 28,625 Ko : Casio Graph 35+E II / 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython)
  6. 19,842 Ko : module externe TI-Python pour TI-83 Premium CE (firmware tiers)
  7. 17,192 Ko : module externe TI-Python pour TI-83 Premium CE
  8. 13,658 Ko : calculatrice NumWorks
  9. 5,946 Ko : logiciel web NumWorks
L'application non officielle CasioPython est actuellement conçue pour travailler avec 256K sur les Graph 35+E/USB / 75/95 à processeur SH4, et 32K sur les Graph 35+USB/75/85/95 à processeur SH3.

A l'heure d'écriture de ce test, sa dernière version disponible semble à tort détecter le matériel de la nouvelle Graph 35+E II comme du SH3.




8) Performances Python :

Go to top

Enfin, terminons en voyant les performances. Commençons dans le cadre des nombres entiers avec le script suivant :
Code: Tout sélectionner
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def genseed(ndigits):
  nmax,s,k=5*10**(ndigits-1),0,1
  while s<nmax:
    s+=k
    k*=2
  return s

def genarr(ndigits):
  sd,arr=genseed(ndigits),[]
  for k in range(1,ndigits):
    for j in range(ndigits):
      t=sd%10**k
      arr.extend([t,-t,10**k-t,t-10**k])
      sd=sd//10+(sd%10)*10**(ndigits-1)
  arr.extend([sd,-sd])
  return arr

def sortarr(arr,sdiff):
  segs=[0,len(arr)-1]
  while len(segs):
    iref=segs[0]
    for k in range(segs[0],segs[1]+1):
      if sdiff*(arr[k]-arr[iref])>0:
        t=arr[iref]
        arr[iref]=arr[k]
        arr[k]=arr[iref+1]
        arr[iref+1]=t
        iref+=1
    if iref>=segs[0]+2:
      segs.extend([segs[0],iref-1])
    if iref<=segs[1]-2:
      segs.extend([iref+1,segs[1]])
    segs.pop(0)
    segs.pop(0)
  return arr

def test(l,n):
  timed=hastime()
  start,stop,sdiff,arr=0 or timed and monotonic(),1,-1,[]
  arr.extend(genarr(l))
  for k in range(n):
    arr.extend(sortarr(arr,sdiff))
    sdiff=-sdiff
  stop=timed and monotonic() or 1
  return stop-start,len(arr),arr[0],arr[len(arr)//2-1],arr[len(arr)//2],arr[len(arr)-1]


11114La ligne d'appel test(9,2) se termine en 14,93s sur la Graph 35+E II.

D'où le classement suivant dans le contexte des calculs entiers :
  1. 1,41s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
  2. 1,56s : TI-Nspire CM / CX CR3- (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
  3. 2,40s : TI-Nspire CX CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
  4. 3,74s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
  5. 4,75s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  6. 8,81s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
  7. 9,56s : Casio Graph 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
  8. 10,19s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
  9. 12,99s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
  10. 14,93s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
  11. 20,73s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
  12. 23,20s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
  13. 33,48s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
  14. 60,71s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  15. 116,93s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)

Bizarrement donc, l'application Python officielle de la Graph 35+E II a des performances en calcul entier nettement inférieures à celles de l'application communautaire CasioPython, et ce alors que ces deux applications sont basées sur MicroPython.

C'est assez décevant, même si il y a pire dans les deux cas.


Passons maintenant aux nombres flottants avec le script suivant :
Code: Tout sélectionner
try:
  from time import *
except:
  pass

def hastime():
  try:
    monotonic()
    return True
  except:
    return False

def seuil(d):
  timed=hastime()
  start,stop,n,u,l,d=0 or timed and monotonic(),1,0,2.,1,d**2
  while (u-l)**2>=d: u,n=1+(1/((1-u)*(n+1))),n+1
  stop=timed and monotonic() or 1
  return [stop-start,n,u]


11116La ligne d'appel seuil(0.005) se termine en 25,19s sur la Graph 35+E II.

D'où le classement suivant dans le contexte des calculs en virgule flottante :
  1. 0,962s : HP Prime G2 (32 bits : Cortex/ARMv7 @528MHz)
  2. 1,08s : TI-Nspire CM / CX CR3- (application MicroPython) (32 bits : ARM9/ARMv5 @132MHz)
  3. 1,29s : TI-Nspire (application MicroPython) (32 bits : ARM9/ARMv5 @120MHz)
  4. 1,61s : TI-Nspire CX CR4+ (application MicroPython) (32 bits : ARM9/ARMv5 @156MHz)
  5. 2,036s : NumWorks (32 bits : Cortex/ARMv7 @100MHz)
  6. 3,068s : HP Prime G1 (32 bits : ARM9/ARMv5 @400MHz)
  7. 8,94s : Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  8. 9,68s : module externe TI-Python pour TI-83 Premium CE (32 bits : Cortex/ARMv7 @48MHz)
  9. 10,68s : Casio Graph 35+E II (application CasioPython) (32 bits : SH4 @59MHz)
  10. 11,26s : Casio 35+E/75+E / 35+USB/75/95 SH4 / fx-9750/9860GII SH4 (application CasioPython) (32 bits : SH4 @29,5MHz)
  11. 11,46s : module externe TI-Python pour TI-83 Premium CE (firmware tiers) (32 bits : Cortex/ARMv7 @48MHz)
  12. 13,87s : Casio Graph 35+USB/75/85/95 SH3 / fx-9750GII SH3 / fx-9860G/GII SH3 (application CasioPython) (32 bits : SH3 @29,5MHz)
  13. 19,98s : application KhiCAS sur Casio Graph 90+E / fx-CG50 (32 bits : SH4 @118MHz)
  14. 25,19s : Casio Graph 35+E II (32 bits : SH4 @59MHz)
  15. 35,55s : application KhiCAS sur Casio fx-CG10/20 (32 bits : SH4 @59MHz)

Avec le changement de contexte l'ordre n'est pas le même, mais nous notons ici encore des performances étrangement très inférieures pour l'application Python officielle de la Graph 35+E II, par rapport à celles de l'application communautaire CasioPython.



Conclusion :

Go to top

On peut regretter que l'application Python officielle de la nouvelle Casio Graph 35+E II en version 3.05 soit, comme celle de la Graph 90+E, l'implémentation la plus légère parmi toutes les calculatrices concernées. On regrette l'absence des fonctions complexes pour les Terminales S/STI2D/STL, ainsi que l'absence d'un module graphique pour la Physique-Chimie en Seconde. On va dire que pour 2019-2020, où seules les Seconde et Première sont concernées par l'obligation de programmer en Python, et où les enseignants ne s'y mettront certainement pas tous à fond, ça passe. Mais des mises à jour étendant l'implémentation devront rapidement être apportées par le constructeur.

Les performances comme nous l'avons vu sont également décevantes, mais elles le sont juste relativement. Le constructeur doit pouvoir mieux faire vu le matériel, et peut-être le fera-t-il dès la version 3.10 finale qui sortira fin Mai 2019.

Même si non optimale, la Casio Graph 35+E II reste une belle solution Python qui, contrairement à la concurrence, a le gros avantage de se positionner sur l'entrée de gamme. L'usage du Python sur calculatrice pour tester ses algorithmes en classe, aux devoirs, aux épreuves de contrôle continu ainsi qu'à l'épreuve terminale va enfin pouvoir se démocratiser, merci Casio ! :bj:





Merci à tous ceux qui ont aidé à notre participation à la tournée pédagogique Casio 2019 ! :D

Une pensée envers Casio qui nous a offert à chacun un échantillon de sa nouvelle Graph 35+E II, ainsi qu'envers tous ceux qui ont participé à notre campagne de financement participatif, entre autres :

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 01 Mai 2019, 20:18
de parisse
Si c'est comme pour la 90, il faut peut-etre attendre la version finale pour les performances.
Quelles sont les fonctionnalites de l'editeur de script de l'application integree?

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 01 Mai 2019, 20:20
de critor
De mémoire, interface d'édition identique à celle la Graph 90+E avec le même nombre de lignes/colonnes pour les caractères.
Juste que c'est en monochrome et non en couleur.

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 01 Mai 2019, 20:30
de critor
Quelques captures d'écran qu'il me restait de l'éditeur :
Image

Menu SYBL :
ImageImage

Ecran CHAR :
Image

Menu COMMAND :
Image

Menu OPERAT :
ImageImage

Menu JUMP :
Image

Popup JUMP/Line :
Image

C'est calqué à l'identique l'interface Graph 90+E.

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 02 Mai 2019, 07:16
de parisse
Ca ne permet pas de voir s'ils ont fait quelque chose pour mettre en evidence la syntaxe dans le texte source. De mon cote, en l'absence de couleurs de la 90, j'ai ajoute le soulignement pour les mots clefs du langage, le soulignement en pointilles pour les commandes KhiCAS, ainsi que le parenthese matching.

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 02 Mai 2019, 10:43
de critor
Rien vu de tel, non.

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 06 Mai 2019, 21:43
de critor
Merci de ne plus éditer mes posts pour remplacer mes tableaux par des images.

C'est laid/flou/illisible quand on zoom/dézoom, notamment sur smartphone, ça rend HS les liens de promotion en 1ère ligne des tableaux vers les applis/firmwares Python communautaires qui ont demandé énormément de travail...

Et pire, me concernant, là je suis sur un nouvel article, et je dois me retaper tout le bbcode en question, puisque aucune copie de sauvegarde n'a visiblement été postée, ni ici, ni dans le salon d'administration...

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 07 Mai 2019, 00:33
de Adriweb
C'était nécessaire car le mod phpBB de bbcode recursif fait de la m*rde sur ce genre de gros bbcode et le temps de chargement du post devenait immense (genre 15s), ce qui était donc inacceptable car l'article était sur le portail, donc tout le site en pâtissait. Je n'étais pas le seul à le signaler. Donc une autre solution sera a trouver dans le futur, en attendant, il ne faudra plus utiliser des tableaux qui ne sont pas petits (et plus d'un par post, en gros), sinon ca fout le portail en l'air, et par extension/propagation du blocage selon le nombre de personnes, tout le(s) site(s) que l'on a sur le serveur.
Ce n'est pas la 1ère fois que ça arrive :-[

Mais désolé pour le manque de sauvegarde juste après l'edit, cette fois là, la copie du bbcode original n'a pas été faite à cause d'une erreur (envoi au lieu de preview...), c'était donc pas voulu... Mais j'ai depuis récupéré le contenu depuis une sauvegarde de la DB, je peux poster quelque part si besoin.

(Par contre je n'ai pas de problème de lisibilité ou autre ave l'affichage par défaut, perso... (et on peut aussi faire ce qu'il faut pour un affichage zoomé, la j'ai fait dans l'urgence), comme toutes les autres fois où on a du faire la même chose.)

Vu le bazar inmaintenable que sont les tableaux en BBCode, il serait de toute façon plus efficace pour les visiteurs, et plus pratique pour toi en particulier, de faire le tableau directement en HTML, et de l'inclure dans le post avec un BBCode special, dans l'article. Ca n'aurait que des avantages, à ce que je sache...

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 07 Mai 2019, 10:41
de critor
Merci pour la réponse.

Pourquoi ne pas corriger le code en question plutôt que de faire ça à chaque fois ?

Les tableaux c'est bien, c'est clair, et je n'appellerai pas ceux de ce post énormes. Ceux du test TI-83 Premium CE Edition Python à venir sont pire, puisqu'il y a davantage de découvertes croustillantes à montrer.

Sinon, on a je crois une option quelque part pour activer le html dans les posts, oui. Et si je me souviens bien, le commentaire à côté disait que son activation était déconseillée pour raisons de sécurité.

Re: Test Casio Graph 35+E II Python (préversion 3.05)

Message non luPosté: 07 Mai 2019, 11:07
de Adriweb
Je ne sais pas si c'est vraiment un bug ou un problème de design/arche du code etc, en tout cas plus ya de bbcode imbriqués plus c'est l'enfer, et après tout je n'ai pas regardé le code du mod. Pour les tables, vu le nombre de bbcode, ça doit faire des sales trucs... faudrait benchmarker etc.

Ensuite, je ne dis pas que les tables c'est mauvais (au contraire, c'est sûrement mieux qu'un pavé de texte explicatif :p), cela on a juste un problème de backend qui nous empêche de les utiliser comme il faudrait.

Par rapport à l'usage de l'html etc directement, bien sûr qu'il ne faut pas l'autoriser (ou alors pour des membres précis seulement mais et encore), je pensais plutôt à un bbcode du genre [include]pythonCasio2019Table1[/include] qui fait ce qu'il faut avec ce fichier précisément (donc pour le coup, c'est nous sur le serveurs qui gérons le contenu, peut pas y avoir de problèmes de sécurité)