En 2013, Sami Vaarala a commencé à travailler sur
Duktape, un moteur JavaScript engine axé sur la portabilité et une faible empreinte, avec une intégration aisée au sein d'autres programmes C/C++.
Entre autre, Duktape est utilisé en tant qu'interpreteur JS dans les appareils d'AllJoyn (https://allseenalliance.org) IoT (
Internet of Things), dans l'
Atomic Game Engine, etc.
Plusieurs mois après le port de
MicroPython sur la plateforme Nspire, dont nous
avons parlé plus tôt, un port de Duktape pour Nspire platform a été effectué par Legimet (d'après une suggestion de Lionel Debroux), et il s'avère que le travail initial pour le faire compiler a été
remarquablement concis, preuve de code de qualité
Il a cependant fallu
un peu plus de code pour avoir une console etc. sur la calculatrice.
In 2013, Sami Vaarala started working on
Duktape, a JavaScript engine focused on portability and a small footprint, with easy embeddability in other C/C++ programs.
Among other purposes, Duktape is used as the JS interpreter in AllJoyn (https://allseenalliance.org) IoT (
Internet of Things) devices, the
Atomic Game Engine, etc.
Six months after a port of
MicroPython to the Nspire platform, which
we covered earlier, a port of Duktape to the Nspire platform was performed by Legimet (on Lionel Debroux’s suggestion), and in fact the initial work to make it compile for it was
remarkably concise, proof of good coding
Though
a bit more code had to be written to have a console etc. for the calculator.
Veuillez noter que
Ndless est requis pour pouvoir profiter de Duktape. Veuillez bien suivre le tutorial... Mais attention, si vous avez une CX (CAS) avec un OS 4.0 (ou ultérieur), ce qui est le cas de toutes les machines CX (CAS) neuves récemment, Ndless n'y existant pas, vous pouvez continuer à envoyer un mail de protestation contre le verrouillage de la plate-forme à
ti-cares@ti.com et en faveur de son ouverture... un modèle est proposé à la fin de
la news précédente à propos de Micro Python.
Please note that
Ndless is required to enjoy Duktape. Please follow the tutorial(s) ... But beware, if you have an Nspire CX (CAS) with OS 4.0 (or later), which is the case of all recent CX (CAS) devices, Ndless not existing for this OS, you can continue to send an email of protest against the locking of the platform to
ti-cares@ti.com and wish for a more open view... a template is proposed at the end of the
previous Micro Python news article.
2) Duktape exécute du code JavaScript
2) Duktape runs JavaScript code
Go to topEnfin, du code "ECMAScript", techniquement, mais tout le monde connaît plutôt le terme "JavaScript".
Duktape gère l'ECMAScript 5.1 et implèmente même un très petit nombre de fonctionnalités du récent ECMAScript 6, aussi connu sous le nom d'Harmony.
Well, "ECMAScript" code, technically, but everyone rather knows the "JavaScript" term.
Duktape supports ECMAScript 5.1 and even implements very few features from the recently released ECMAScript 6, also known as Harmony.
Voici un exemple simple (Calcul de fibonacci(n)) écrit de la même façon dans les différentes langages désormais disponibles sur la TI-Nspire :
Here is a simple example (computing fibonacci(n)) written the same way in the different languages now available on the TI-Nspire:
Basic | Lua | Python | JavaScript |
- Code basic-nspire : Select all
Define fibo(n)
Func
If (n <= 1) Then
return n
Else
return fibo(n-1)+fibo(n-2)
EndIf
EndFunc
fibo(30)
| - Code lua : Select all
function fibo(n)
if (n <= 1) then
return n
else
return fibo(n-1)+fibo(n-2)
end
end
print(fibo(30))
| - Code python : Select all
def fibo(n):
if (n <= 1):
return n
else:
return fibo(n-1)+fibo(n-2)
print(fibo(30))
| - Code js : Select all
function fibo(n) {
if (n <= 1) {
return n;
} else {
return fibo(n-1)+fibo(n-2);
}
}
print(fibo(30));
|
Note: ce code JavaScript là est plus lent que son équivalent Lua ou Python à cause d'un
problème connu dans Duktape.
Mais même s'il est plus lent que le Lua ou le Python, il en demeure bien plus rapide que le TI-Basic intégré !
Note: this particular JavaScript code runs slower than Lua or Python due to a specific
known issue in Duktape.
But still, while it is currently slower than the integrated Lua, it is much faster than the integrated TI-Basic!
Un autre exemple classique est le tracé d'un Mandelbrot. Pour ceci, le TI-Basic n'est tout simplement pas capable de le faire, puisqu'il n'existe pas de moyens de contrôler des pixels sur un/l'écran graphique…. Mais Duktape peut le faire
Alors qu'une version Lua optimisée et une version Micro Python finissent le tracé (16 itérations) en environ 30 secondes,
la version Duktape est plus lente, avec environ une minute au chrono.
Note: Une version C, sans optimisation particulière, les ridiculise tous, en quelques secondes...Another classic example is a Mandelbrot set plot. For that, TI-Basic is simply not capable of doing it since there is no way to control pixels from a/the graph screen
It is however possible to do it with Duktape
While optimized Lua and Micro Python finish the plot (16 iterations) in about 30 seconds,
Duktape's version is slower and takes about a minute.
Note: A C version, without any specific optimization, blows them all out of the water, in a few seconds...Voici quelques autres exemples en lien avec les maths:
Here are some other math-related examples:
Changement de base numérique
Numerical base conversion
Renvoie une liste des "chiffres" de l'écriture de n en base b / Returns list of the "figures" of the representation of n in the b base
Le chiffre de poids le plus fort est le plus à gauche / The most significant figure is leftmost
Show/Hide spoilerAfficher/Masquer le spoiler
Basic | Lua | Python | JavaScript |
- Code basic-nspire : Select all
Define baseb(n,b)=
Func
Local rep
{}->rep
While n>0
augment({mod(n,base)},rep)->rep
intdiv(n,base)->n
EndWhile
Return rep
EndFunc
| - Code lua : Select all
function baseb(n, b)
local t = {}
local tmp = 0
while n > 0 do
n, tmp = math.floor(n/b), n%b
table.insert(t, 1, tmp)
end
return t
end
| - Code python : Select all
def baseb(n, b):
t = []
while n > 0:
n, tmp = divmod(n, b)
t = [tmp] + t
return t
| - Code js : Select all
function baseb(n, b) {
var t = [];
while (n > 0) {
t = [n%b] + t;
n = Math.floor(n/b);
}
return t;
}
|
Calcul de Pi (algorithme du compte-goutte)
Compute Pi digits
Renvoie une chaîne contenant les n premières décimales de Pi / Returns a string containing the n first digits of Pi
Show/Hide spoilerAfficher/Masquer le spoiler
Basic | Lua | Python | JavaScript |
- Code basic-nspire : Select all
Define cpi(n)=
Func
Local a,b,a1,b1,a0,b0,s,p,q,d,d1
4->a:1->b
12->a1:4->b1
""->s
1->p:3->q
While n >= 0
p+q->p: q+2->q
a->a0: b->b0
a1->a: b1->b
p*a0+q*a1->a1
p*b0+q*b1->b1
intdiv(a,b)->d
intdiv(a1,b1)->d1
While d = d1 and n >= 0
s & string(d)->s
n-1->n
10*mod(a,b)->a
10*mod(a1,b1)->a1
intdiv(a,b)->d
intdiv(a1,b1)->d1
EndWhile
EndWhile
Return left(s,1)&","&mid(s,2)
EndFunc
| - Code lua : Select all
local floor = math.floor
function cpi(n)
local a, b, a1, b1 = 4, 1, 12, 4
local s = ""
local p, q = 1, 3
while n >= 0 do
p, q = p+q, q+2
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
d, d1 = floor(a/b), floor(a1/b1)
while d == d1 and n >= 0 do
s = s .. d
n = n-1
a, a1 = 10*(a%b), 10*(a1%b1)
d, d1 = floor(a/b), floor(a1/b1)
end
end
return s:sub(1,1) .. "," .. s:sub(2)
end
| - Code python : Select all
def cpi(N):
a, b, a1, b1 = 4, 1, 12, 4
s = ""
p, q = 1, 3
while N >= 0:
p, q = p+q, q+2
a, b, a1, b1 = a1, b1, p*a+q*a1, p*b+q*b1
d, d1 = a//b, a1//b1
while d == d1 and N >= 0:
s += str(d)
N -= 1
a, a1 = 10*(a%b), 10*(a1%b1)
d, d1 = a//b, a1//b1
return s[0] + "," + s[1:]
| - Code js : Select all
function cpi(n) {
var floor = Math.floor;
var a = 4, b = 1, a1 = 12, b1 = 4, a0, b0, d, d1;
var s = "";
var p = 1, q = 3;
while (n >= 0) {
p = p + q, q = q + 2;
a0 = a1, b0 = b1;
a1 = p*a+q*a1, b1 = p*b+q*b1;
a = a0, b = b0;
d = floor(a/b), d1 = floor(a1/b1);
while (d == d1 && n >= 0) {
s += d;
n--;
a = 10*(a%b), a1 = 10*(a1%b1);
d = floor(a/b), d1 = floor(a1/b1);
}
}
return s[0] + ',' + s.substr(1);
}
|
Liste des premiers nombres premiers (crible d'Eratosthène)
List of the first prime numbers (Eratostenes' sieve)
Renvoie la liste des nombres premiers inférieurs ou égaux à n par le crible d'Ératosthène / Returns the list of the prime numbers <= n using Eratostenes' sieve
Show/Hide spoilerAfficher/Masquer le spoiler
Basic | Lua | Python | JavaScript |
- Code basic-nspire : Select all
Define primes_list(n)=
Func
Local t,r,i,j
seq(when(i=1 or (mod(i,2)=0 and i>2),_,i),i,1,n)->t
floor(sqrt(n))->r
3->i
While i <= r
If not(isvoid(t[i])) Then
For j,i^2,n,i
_->t[j]
EndFor
Endif
i+2->i
EndWhile
Return delvoid(t)
EndFunc
| - Code lua : Select all
function primes_list(n)
if n < 2 then return {} end
local t = {false}
local max = math.sqrt(n)
for i = 2, n do
t[i] = true
end
for i = 2, max do
if t[i] then
for j = i*i, n, i do
t[j] = false
end
end
end
local primes = {}
for i = 2, n do
if t[i] then
primes[#primes+1] = i
end
end
return primes
end
| - Code python : Select all
def primes_upto(limit):
is_prime = [False] * 2 + [True] * (limit - 1)
for n in range(int(limit**0.5 + 1.5)):
if is_prime[n]:
for i in range(n*n, limit+1, n):
is_prime[i] = False
return [i for i, prime in enumerate(is_prime) if prime]
| - Code js : Select all
function primes_list(n) {
if (n < 2)
return [];
var t = [false, false];
var max = Math.sqrt(n);
for (var i = 2; i <= n; i++)
t[i] = true;
for (var i = 2; i <= max; i++)
if (t[i])
for (var j = i*i; j <= n; j+=i)
t[j] = false;
return t.reduce(function(a, e, i) {
if (e)
a.push(i);
return a;
}, []);
}
|
4) Comparaison globale des langages disponibles
4) Overall comparison of available languages
Go to top | Nspire-Basic | Nspire-Lua | Micro Python | JavaScript (Duktape) | C / C++ |
Supporté officiellement par TI | Oui | Oui
(OS 3.x+ requis) | Non
(Ndless requis) | Non
(Ndless requis) | Non
(Ndless requis) |
Répandu dans l'informatique en général | Non
(calculatrices TI seulement) | Oui (plugins)
Faiblement (standalone) | Très
(tous domaines) | Très
(souvent sur le Web) | Très
(tous domaines) |
Intérêt potentiel de professeurs | Bon | Moyen + | Elevé | Plutôt élevé | Moyen - |
Vitesse d'exécution | Basse | Moyenne | Moyenne + | Moyenne - | La plus élevée |
Commandes graphiques | Non | Oui | Oui | Oui | Oui |
Lecture du clavier | Non
(sauf popup d'input) | Oui
(une touche à la fois) | Non
(console pour le moment) | Oui
(une touche à la fois) | Oui
(multi-touches possible) |
Lecture du touchpad | Non | Non
(sauf clics) | Non
(pour le moment) | Non
(pour le moment) | Oui |
Intégration au moteur de calcul & CAS | Oui | Oui | Non (*) | Non (*) | Non (*) |
Editable directement sur calculatrice | Oui | Oui
(éditeurs tiers) | Oui
(console interactive
et éditeur tiers) | Oui
(console interactive
et éditeur tiers) | Non
(nécessiterait un compilateur) |
Peut utiliser des fichiers externes | Non | Non | Oui | Oui | Oui |
Idéal pour apprendre à programmer | Oui
(algorithmes) | Oui | Oui | Oui | Moyennement
(plus bas niveau, plus difficile) |
| Nspire-Basic | (Nspire-)Lua | Micro Python | JavaScript (Duktape) | C / C++ |
Official support by TI | Yes | Yes
(OS 3.x+ required) | No
(Ndless required) | No
(Ndless required) | No
(Ndless required) |
Widely used in general computer science | No
(TI calculators only) | Yes (plugins)
Low (standalone) | Very
(everywhere) | Very
(Web especially) | Very
(everywhere) |
Potential interest for teachers | Good | Average + | High | High | Average - |
Execution speed | Low | Average | Average + | Average - | Highest |
Graphical commands | No | Yes | Yes | Yes | Yes |
Keyboard input | No
(except input popup) | Yes
(single key at a time) | No
(console only for now) | Yes
(single key at a time) | Yes
(multiple keys at a time) |
Touchpad reading | No | No
(except clicks) | No
(for now) | No
(for now) | Yes |
Integration to the built-in
computation engine & CAS | Yes | Yes | No (*) | No (*) | No (*) |
Direct calculator-side edit | Yes | Yes
(third-party editors) | Yes
(interactive console
and third-party editors) | Yes
(interactive console
and third-party editors) | No
(would require a compiler) |
Can use external files | No | No | Yes | Yes | Yes |
Good choice for a
first programming language | Yes
(algorithms) | Yes | Yes | Yes | Midly
(lower level, harder) |
(*): intégration au CAS difficile à réaliser sans doc de TI, même s'il y a eu les PoC de
Lionel Debroux et
Excale.
(*): CAS integration is hard without documentation from TI, even if
Lionel Debroux and
Excale made PoC programs.
5) Et pour la suite...
5) What's next?
Go to top- Davantage de liasons ("bindings") avec l'OS, comme une API de graphique étendue, et l'accès à d'autres fonctionnalités de l'OS
- debugage -- c'est géré depuis Duktape 1.2.0, mais il faut maintenant programmer la couche de transport et l'interface graphique
- gestion du multi-ligne dans le "REPL" (la console, en gros)
- gestion du JavaScript dans PyWrite
- gestion de modules externes natifs (ce qui nécessiterait le support de bibliothèques partagées dans Ndless)
- more OS bindings, such as an expanded graphics API and access to other OS features
- debugging -- support was added in Duktape 1.2.0, but a debug transport and UI would have to be written
- multiline support in the REPL
- JavaScript support in PyWrite
- support for external native modules (would require shared library support in Ndless)
6) Liens / Ressources
6) Links / Resources
Go to topHave fun
Article by/par Adriweb & Legimet
by 
)
