Gene ado de aplicaciones na i as pa a Snap!
Uni e sidad Poli écnica de Ca aluña (UPC)
Facul ad de In o má ica de Ba celona (FIB)
T abajo inal de G ado en Ingenie ía In o má ica
Especialidad de compu ación
Au o : Ad ian Hin ze Mole o
Di ec o : Jo di Delgado Pin (Dep . CS, UPC)
Oc ub e 2014
Índice
1 Abs ac ..................................................................................................................1
1.1 Cas ellano........................................................................................................1
1.2 Ca alà...............................................................................................................1
1.3 English..............................................................................................................2
2 In oducción..........................................................................................................3
2.1 Snap!................................................................................................................4
2.2 Obje i os..........................................................................................................5
2.3 Impac o social, ambien al y económico...........................................................6
2.3.1 Impac o social.......................................................................................................6
2.3.2 Impac o ambien al................................................................................................6
2.3.3 Impac o económico..............................................................................................6
2.4 Es ado del a e.................................................................................................7
3 Plani icación........................................................................................................10
3.1 Plani icación inicial.........................................................................................10
3.2 Implemen ación de la Pa e Técnica..............................................................11
3.3 P epa ación de la En ega Final.....................................................................11
4 P esupues o........................................................................................................12
4.1 Recu sos Humanos........................................................................................12
4.2 Recu sos no Humanos...................................................................................13
4.2.1 Ha dwa e............................................................................................................13
4.2.2 So wa e.............................................................................................................14
4.2.3 To al....................................................................................................................14
4.3 To al................................................................................................................14
5 Gene ación de ejecu ables.................................................................................15
5.1 NW.js..............................................................................................................15
6 Gene ación del en o no de ejecución...............................................................18
6.1 Es ilo del código de Snap...............................................................................18
6.2 Es uc u a gene al del código........................................................................20
6.3 Viabilidad de la modi icación p og amá ica del código uen e de Snap.........20
6.4 In e aces........................................................................................................22
6.4.1 In o mación sob e el código a elimina ..............................................................23
6.5 Jus i icación del sis ema................................................................................24
6.6 G amá ica.......................................................................................................25
6.6.1 ANTLR4..............................................................................................................25
6.6.2 G amá ica pe sonalizada...................................................................................28
6.6.3 P oceso de c eación de la g amá ica.................................................................28
6.7 Algo i mo........................................................................................................29
6.7.1 Iden i icación de elemen os ele an es..............................................................29
6.7.2 De inición............................................................................................................30
7 Implemen ación...................................................................................................32
7.1 Es ilo de aplicación........................................................................................32
7.2 Módulos de la aplicación................................................................................33
7.3 In e aces........................................................................................................33
7.3.1 A ibu os p agma................................................................................................34
7.3.2 Uso de las in e aces..........................................................................................36
7.3.3 P agmas en el código.........................................................................................36
7.4 Modi icado de código Snap...........................................................................37
7.4.1 Es uc u as de da os..........................................................................................37
7.4.2 Pa se /ANTLR4..................................................................................................38
7.4.2.1 SnapT eeWalke .........................................................................................38
7.4.3 Pun o de en ada................................................................................................39
7.4.4 P agmaPa se ....................................................................................................40
7.4.5 WalkLis ene .......................................................................................................40
7.4.6 CheckLis ene .....................................................................................................41
7.5 Aplicación Web...............................................................................................42
7.5.1 Página Web........................................................................................................42
7.5.1.1 Cue po de la página....................................................................................42
7.5.1.2 Es ilo de la página.......................................................................................43
7.5.1.3 Sc ip s de la página.....................................................................................43
7.5.2 Web Se ice.......................................................................................................46
8 Resul ados...........................................................................................................47
8.1 Gene ación de ejecu ables............................................................................47
8.2 In e aces y P agmas.....................................................................................47
8.3 Modi icación del código uen e.......................................................................49
9 Mejo as u u as...................................................................................................51
10 Conclusiones.....................................................................................................52
11 Bibliog a ía.........................................................................................................53
1 Abs ac
1.1 Cas ellano
Es e p oyec o es la implemen ación de una inicia i a del cen o Ci ilab Co nellà.
Conc e amen e, se ha a ado de c ea una he amien a que amplíe las posibilidades del
lenguaje de p og amación po bloques Snap!, desa ollado po la uni e sidad de Be keley.
El obje i o p incipal ha sido desa olla un sis ema que pe mi a gene a ejecu ables pa a
di e sas pla a o mas a pa i de un p oyec o c eado en Snap!. Es o se ealiza con i iendo
la aplicación de Snap!, que po de ec o es un en o no de desa ollo comple o, en un
simple en o no de ejecución en el que solo se mues e y enga acceso al esul ado de la
ejecución del código.
Pa a c ea es e en o no se ha desa ollado una he amien a que es capaz de gene a lo a
pa i del código uen e o iginal de Snap!, el cual es á esc i o en Ja aSc ip , dada una
cie a can idad de in o mación sob e el mismo. En es e en o no se puede inse a
ácilmen e un p oyec o Snap! y gene a , in eg ando es e conjun o con o as ecnologías, el
ejecu able pa a el usua io inal de mane a au oma izada.
1.2 Ca alà
Aques p ojec e és la implemen ació d'una inicia i a del cen e Ci ilab Co nellà. En
conc e , s'ha ac a de c ea una eina que pe me i amplia les possibili a s del llengua ge
de p og amació pe blocs Snap!, desen olupa pe la uni e si a de Be keley.
L'objec iu p incipal ha es a desen olupa un sis ema que pe me i gene a execu ables pe
a di e ses pla a o mes a pa i d'un p ojec e c ea en Snap!. Aques a asca es eali za
con e in l'en o n de desen olupamen de Snap!, que pe de ec e és un en o n de
desen olupamen comple , en un en o n d'execució simple en el que només es mos i i
ingui accés al esul a de la execució del codi Snap!.
Pe c ea aques en o n s'ha desen olupa una eina que és capaç de gene a -lo a pa i
del codi on o iginal de Snap!, el qual es à esc i en Ja aSc ip , donada una ce a
quan i a d'in o mació sob e el ma eix. En aques en o n es po inse i amb acili a un
p ojec e Snap! i gene a , in eg an aques conjun amb al es ecnologies, l'execu able pe
a l'usua i inal de mane a au oma i zada.
1
1.3 English
This p ojec is he implemen a ion o an idea by he Ci ilab Co nellà cen e . Mo e
conc e ely, i has been he de elopmen o a ool ha expands he unc ionali y o he
isual p og amming language Snap!, which has been de eloped by he Be keley
uni e si y.
The p ime objec i e has been o de elop a sys em ha allows he gene a ion o
execu able iles o di e en pla o ms om a p ojec c ea ed wi h Snap!. This is
accomplished by ans o ming Snap!, which is by de aul an in eg a ed de elopmen
en i onmen , in o a simple execu ion en i onmen ha only shows and allows access o
he code's execu ion esul .
To c ea e his en i onmen a ool has been de eloped ha is able o gene a e i
au oma ically gi en a ce ain amoun o in o ma ion abou Snap!'s sou ce code and he
sou ce code i sel , which is w i en in Ja aSc ip . I is hen simple o inse in o his
en i onmen a Snap! p ojec and gene a e, au oma ically, in eg a ing i wi h o he
echnologies, an execu able ile o he end use .
2

2 In oducción
Los lenguajes de p og amación g á icos, y en e ellos los educa i os, como po ejemplo
Sc a ch1 (desa ollado po el MIT2), lle an despe ando g an in e és desde hace años en
di e en es sec o es an o den o del ámbi o de la in o má ica como ue a de es e.
El hecho de se una aplicación g á ica los hace mucho más amigables a usua ios con
poca o nula expe iencia en el campo de la p og amación, abs ayéndolos de aspec os
écnicos que no son pa e de la lógica de la aplicación que se quie e desa olla . Un
ejemplo pod ía se la eliminación de e o es sin ác icos, los cuales suelen se una g an
ba e a pa a p og amado es no eles.
Uno de es os lenguajes que han apa ecido ecien emen e (año 2011) es Snap!3 (de aquí
en adelan e simplemen e Snap), una eimplemen ación de Sc a ch esc i a comple amen e
en Ja aSc ip pa a pode se ejecu ada en cualquie na egado independien emen e del
en o no.
El lenguaje dispone de odos los elemen os que se espe an de un lenguaje de
p og amación compe en e, como pueden se lis as (de lis as), unciones, e c. Es o lo ha
con e ido en una he amien a a ene en cuen a a la ho a de in oduci al público a la
p og amación. Po ejemplo, la uni e sidad de Be keley ha desa ollado un cu so al ededo
de la he amien a llamado “The Beau y and Joy o Compu ing” 4.
A pesa de odo, es e ipo de lenguajes aún son is os po muchos como he amien as
poco se ias que no son ú iles a la la ga. Es e hecho ha lle ado a cen os como Ci ilab a
pensa , e implemen a , mejo as pa a el lenguaje. Una de es as mejo as, que es la que se
ha lle ado a cabo en es e abajo, es la posibilidad de, una ez c eado un p oyec o5
Snap, gene a un ejecu able pa a cualquie a de los en o nos de esc i o io p incipales que
exis en hoy en día [1][2] (no mó iles) : Windows, Mac OS X y Linux.
C eemos que pode c ea una aplicación que pueda se expo ada y u ilizada
independien emen e del en o no de Snap da á a la he amien a una dimensión o almen e
nue a y que ha á que ap ende a usa lo se ea como algo ealmen e ú il que pe mi e
ob ene un esul ado palpable y no una simple “cu iosidad”, que desapa ece en cuan o se
cie a el na egado .
1h ps://sc a ch.mi .edu/abou /
2 Massachusse s Ins i u e o Technology
3h p://snap.be keley.edu/
4h p://bjc.be keley.edu/websi e/Mission.h ml
5 Un p oyec o Snap se e ie e a un código c eado a pa i de bloques de Snap, a chi os mul imedia y o os
elemen os in e nos a Snap que en conjun o o man un p og ama que puede se in e p e ado y ejecu ado
po Snap.
3
2.1 Snap!
Debido a que Snap es la base de es e TFG6 pa ece con enien e ealiza una pequeña
in oducción a es a he amien a.
Snap es un lenguaje de p og amación g á ico po bloques implemen ado en sus o alidad
en Ja aSc ip 7, de mane a que es ejecu able desde cualquie na egado (mode no). Es o
quie e deci que los p og amas se cons uyen a as ando y conec ando bloques den o
del en o no de la aplicación. A la ez que se cons uye el p og ama es posible ejecu a
es e código y isualiza sus esul ados en la pa e de la aplicación llamada S age.
Snap es pues, un in é p e e de código donde es e, en ez de ep esen a se en o ma de
ex o, se ep esen a con bloques.
Snap, como eimplemen ación de Sc a ch, compa e una de sus ca ac e ís icas más
impo an es. No solo es un in é p e e de un lenguaje de p og amación, sino que se a a
ambién de un en o no de ejecución y p og amación en i o basado en lenguajes de la
amilia Small alk8 (como pod ían se Small alk-80, Squeak o Pha o).
6 T abajo de Fin de G ado
7h ps://en.wikipedia.o g/wiki/Ja aSc ip
8h p://c2.com/cgi/wiki?Small alkLanguage
4
Figu a 1: In e az de la aplicación Snap siendo ejecu ada en un na egado .
En la esquina supe io de echa podemos e la S age mos ando el esul ado
de la ejecución del código cons uido en el panel cen al
El obje i o p incipal de Snap es se una he amien a educa i a que pe mi a a gen e que
no es á amilia izada con la p og amación in oduci se en el ema de o ma más sencilla.
Eso no quie e deci que Snap sea un lenguaje limi ado, dispone de múl iples he amien as
p opias de lenguajes de al o ni el como pod ían se :
•Lis as he e ogéneas
•Funciones de o den supe io
•Con inuaciones
Todo es o hace que Snap pueda se ambién una he amien a di igida a alumnos de
ins i u o o incluso es udian es uni e si a ios (de p ime año o de o as especialidades que
no sea la in o má ica).
2.2 Obje i os
Es e abajo iene dos obje i os p incipales.
El p ime o y más impo an e consis e en consegui que los usua ios inales de Snap
engan una mane a de, una ez han c eado su p oyec o en Snap, pode c ea un
ejecu able a pa i del mismo. Es deci , ene una o ma de ex ae su p og ama de la
aplicación Snap de mane a que puedan u iliza lo de o ma independien e en múl iples
pla a o mas, compa i lo con o as pe sonas, e c.
Es e ejecu able al inicia se mos a á solamen e la S age de Snap y el esul ado de la
ejecución del p og ama. Básicamen e se quie e imi a la compilación de un p og ama
esc i o en un lenguaje con encional como pod ía se C, siendo el esul ado de es a
ope ación un ejecu able que se puede u iliza independien emen e de la he amien a de
desa ollo que se haya u ilizado y pudiendo aslada es e ejecu able a di e en es
máquinas.
El segundo obje i o del p oyec o iene de i ado de las necesidades écnicas que su gen
del p ime o. Hemos comen ado como que emos que el ejecu able solamen e mues e la
S age de Snap, la cual, po un lado, no es más que un pequeño subconjun o de la in e az
de Snap y po o o solo necesi a de una acción del código uen e. Debido a es o, pa a la
gene ación del ejecu able no que emos u iliza el código uen e o iginal de Snap, sino una
e sión modi icada que nos p opo cione la uncionalidad eque ida y no con enga
elemen os innecesa ios. Es a e sión ob iamen e se pod ía desa olla manualmen e,
pe o debido a que Snap es un p oyec o en desa ollo, su icien es cambios al p oyec o
o iginal pueden deja obsole o es e en o no de ejecución gene ado manualmen e. Es o
quie e deci que hab ía que man ene una nue a ama de código de mane a pa alela al
código p incipal de Snap. El obje i o es pues consegui aho a es e abajo,
au oma izando la c eación del en o no de ejecución a pa i del código uen e de Snap.
5
2.3 Impac o social, ambien al y económico
Debido a que es e p oyec o se a a más de una p ueba pilo o pa a e como esponde a
ella los usua ios y desa ollado es de Snap que no cumpli un obje i o pe ec amen e
delimi ado, es algo di ícil cuan i ica con exac i ud el impac o que end á. Aún así podemos
habla , en lineas gene ales que espe amos de él.
2.3.1 Impac o social
A pesa de la impo ancia de la in o má ica en la sociedad mode na, una g an pa e de la
población iene poco o nulo conocimien o del aspec o écnico o de como in e ac ua
di ec amen e con un o denado pa a que es e ealice una a ea a bi a ia, es deci ,
p og ama lo. Lenguajes como Snap es án in en ando disminui es a disonancia haciendo
la p og amación un concep o más accesible y menos lejano al público gene al. Pe o su
alcance aún es limi ado debido a una g an can idad de p ejuicios que eciben es os
lenguajes. Se espe a que el desa ollo de nue as aplicaciones y la ampliación y mejo a de
exis en es (lo que ealiza es e p oyec o) ayude a popula iza es as he amien as y en
consecuencia, aumen e el in e és y el es udio de la p og amación y la in o má ica en
gene al.
2.3.2 Impac o ambien al
El p oyec o consis e en el desa ollo de un so wa e que no a ec a á a ningún p oceso
ex e no. Apa e del impac o indi ec o de i ado po su uso (gene ación de elec icidad pa a
hace unciona los o denado es), no se puede habla ealmen e de un impac o ambien al
se io y es e pun o es negligible.
2.3.3 Impac o económico
No se espe a ningún impac o económico di ec o ya que an o Snap como la he amien a
que desa ollada son lib es y de código abie o. Indi ec amen e se espe a que es e abajo
po encie y siga empujando hacia delan e el desa ollo de lenguajes de p og amación
educa i os y accesibles. Hoy en día la in o má ica es una pieza cla e en una g an
can idad de ac i idades económicas, y una sociedad más educada en es e ámbi o se á
capaz de u iliza la más e icien emen e y se más p oduc i a.
6
4.2 Recu sos no Humanos
En es e p oyec o los gas os en ecu sos no humanos básicamen e se han di idido en
gas os en ha dwa e y so wa e.
Pa a los cálculos de la amo ización de los ecu sos no humanos se han u ilizado los
siguien es da os:
•Días labo ables en un año: 249
•Ho as de abajo en un día: 4 (media jo nada, igual que se ha abajado en es e
p oyec o)
•Du ación del p oyec o: 500 ho as
4.2.1 Ha dwa e
Recu so P ecio (€) Unidades Vida ú il (años) Amo ización
(€)
O denado de
sob emesa
(pe sonalizado)
1100,00 1 5 110,44
Pan alla
Samsung
LS23C350
HS/ZA
150,00 1 5 15,10
Ra ón Raze
Taipan
80,00 1 2 17,00
Teclado Logi ech
K290
31,00 1 2 6,60
Po á il Asus
N61JQ
1000,00 1 4 106,30
To al 2361,00 5 255,44
13

4.2.2 So wa e
Solo se ha con ado una licencia de Mic oso Windows, ya que el po á il incluía una
p eins alada.
Recu so P ecio (€) Unidades Vida ú il (años) Amo ización
(€)
Windows 7
Home P emium
64 bi s
360,00 1 4 38,27
Ubun u 14.04.2
64 bi s
0,00 1 4 0,00
OpenO ice 4.1.1 0,00 1 3 0,00
LaTex 0,00 1 3 0,00
Node.js 0,00 1 2 0,00
Eclipse Luna 0,00 1 3 0,00
To al 360,00 6 38,27
4.2.3 To al
Cos e o al de los ecu sos no humanos:
Tipo P ecio (€)
Ha dwa e 255,44
So wa e 38,27
To al 293,71
4.3 To al
Cos e del p oyec o:
Tipo P ecio (€)
Recu sos humanos 17.360
Recu sos no humanos 293,71
O os gas os 270,00
To al 17.923,71
A pesa de que ha habido cambios meno es espec o a la plani icación inicial el
p esupues o se ha man enido al inicialmen e p opues o.
14
5 Gene ación de ejecu ables
Como se ha comen ado, se p e ende gene a ejecu ables (conc e amen e pa a las
pla a o mas: Windows, Mac OS X y Linux) a pa i de p og amas esc i os en Snap,
u ilizando un en o no de ejecución de i ado del código uen e del mismo. Rápidamen e
podemos e que no es posible ob ene un ejecu able adicional ya que Snap es á esc i o
en Ja aSc ip el cual es un lenguaje in e p e ado (y no iene posibilidad de se compilado).
Como pequeño inciso, indica que écnicamen e es posible aduci un cie o subconjun o
de Ja aSc ip a o os lenguajes [11] y e en ualmen e a uno compilable, como pod ía se
C. Pe o es e es un p oceso limi ado y ue a del alcance de es e abajo.
Una solución se ía ol ida se comple amen e del en o no de ejecución en Ja aSc ip e
implemen a uno en C++, Ja a, e c, pe o es o se ía una can idad de abajo de en ada
muy g ande y el man enimien o se ía ambién inc eíblemen e cos oso, ya que hab ía que
man ene se al día con odos los cambios que su a el código de Snap y asegu a se de
que el in é p e e se compo a igual que el o iginal.
La solución po la que se ha op ado inalmen e es u iliza una ecnología, en conc e o
NW.js11, que nos pe mi a c ea es e ejecu able de mane a indi ec a, encapsulando el
en o no de ejecución de Snap.
5.1 NW.js
NW.js pe mi e dos cosas undamen ales. Pode ejecu a aplicaciones web en local y la
posibilidad de c ea ejecu ables a pa i de es as aplicaciones. Po de ec o pa a ab i un
p oyec o con NW.js, es e equie e que el código uen e sea empaque ado en un a chi o
ZIP jun o a un pequeño iche o de con igu ación. Al e na i amen e, es e ZIP se puede
in eg a (de di e sas mane as, según la pla a o ma) jun o al ejecu able. De es a mane a
se e i a que el usua io enga que ene NW.js ins alado p e iamen e en su sis ema y el
ejecu able no end á ninguna dependencia de e ce os.
Una limi ación de es e p oceso es que equie e acompaña el ejecu able de las lib e ías y
demás ecu sos u ilizados po NW.js, po lo que no pod emos en ia un solo iche o al
usua io (a no se de que la pla a o ma pe mi a encapsula odo el ejecu able y sus
dependencias como po ejemplo Mac OS X). Hab á que en ia un a chi o comp imido que
con enga el ejecu able y los ecu sos. Aún así, se c ee que es a solución es el mejo
comp omiso al que se puede llega ac ualmen e.
11 He amien a c eada pa a pode ejecu a localmen e aplicaciones esc i as en Ja aSc ip , HTML, node.js y
o as ecnologías web - h ps://gi hub.com/nwjs/nw.js/blob/nw13/README.md
15
El esul ado inal que ob iene un usua io al gene a un ejecu able con nues a aplicación
es:
•Un a chi o comp imido que el usua io puede anspo a y compa i con acilidad
•El con enido de es e a chi o es:
◦Un ejecu able pa a la pla a o ma que le usua io haya escogido
▪Windows
▪Linux
▪Mac OS X
◦Las lib e ías necesa ias pa a pode u iliza lo
16
Figu a 2: Aplicación gene ada pa a Windows. Podemos e el ejecu able
co espondien e al p oyec o jun o o os iche os eque idos po NW.js
17
Figu a 3: El mismo ejecu able gene ado pa a Mac OS X ( isualizado en
Windows). Podemos e que el o ma o es mucho más sencillo ya que
se educe a un solo di ec o io .app
Figu a 4: El mismo ejecu able gene ado pa a Linux. Ap o echamos la
exis encia de a chi os .desk op pa a encapsula lo en un di ec o io de
mane a pa ecida a Mac OS X
6 Gene ación del en o no de ejecución
6.1 Es ilo del código de Snap
An es de con inua hablando sob e el segundo obje i o pa ece adecuado hace una
in oducción al código uen e de Snap ya que es una pa e in eg al pa a pode analiza los
equisi os y decisiones del segundo obje i o.
Snap u iliza un solo elemen o HTML5, un Can as sob e el cual es dibujada oda la
aplicación median e el código Ja aSc ip . Tiene como base Mo phic.js (c eado po el
mismo au o de Snap), un en o no básico basado en Squeak que o ece las
uncionalidades básicas del sis ema [12]. Algunos ejemplos se ían:
•D ag and d op
•In e acción a iempo eal del usua io con el sis ema
•He amien a de mano
Sob e es e amewo k es á cons uido Snap p opiamen e dicho. Snap amplía en g an
medida es e en o no añadiendo odo el lenguaje de p og amación po bloques (lo cual
incluye el in é p e e, la ep esen ación g á ica...), di e en es á eas a la in e az, e c.
También dispone de he amien as adicionales como un edi o g á ico sencillo o un sis ema
pa a gua da y ca ga p oyec os de la nube, en e o os.
El código uen e de Snap es á esc i o en Ja aSc ip , pe o con es icciones, es as ienen
dadas po el es ilo de p og amación y con enciones seguidas po los au o es, pe o
ambién po es icciones impues as po la he amien a JSLin .
Los únicos iche o que no siguen exac amen e es as eglas de es ilo son Mo phic.js,
debido a que como base de odo el sis ema necesi a u iliza algunas uncionalidades de
Ja aSc ip que no se en en el es o del código, y S o e.js, la clase que se enca ga de
ca ga y gua da p oyec os Snap.
18

Las eglas de es ilo más ele an es (no odas) se ían:
JSLin [13][14]
•P ohíbe el uso de di e sos ope ado es p oblemá icos como pod ían se wi h o ==
•P ohíbe el uso asignaciones en posiciones en las que se espe a una exp esión, po
ejemplo en la condición de una ins ucción i
•Pun o y coma obliga o io
•E i a el uso de bucles de ipo o en la mayo ía de si uaciones, sus i uyéndolo po
unciones que i e an colecciones como pod ía se o Each
•E i a el uso de -- y ++
•E i a el uso de his
•Reglas de inden ación es ic as
Snap [15]
•E i a amewo ks (po ejemplo jQue y12)
•E i a accede al DOM13
•E i a namespaces y módulos
•E i a pasa his como a gumen o (u iliza una a iable llamada mysel a la que se
le haya asignado his)
•E i a c ea odas las clases de la misma mane a es anda izada y añadi odas las
p opiedades en la cons uc o a o bien en un mé odo ini llamado desde la misma.
•E i a ope ado es e na ios anidados
•E i a el uso de exp esiones egula es
•E i a unciones excesi amen e la gas, especialmen e unciones que necesi en
unciones auxilia es
•E i a llamadas a unciones con un núme o de a gumen os di e en e al decla ado
12 La lib e ía Ja aSc ip con uso más ex endido hoy en día. Su obje i o es simpli ica la p og amación en el
clien e.
13 Del inglés Documen Objec Model. Se e ie e a la API (Applica ion P og amming In e ace) que pe mi e
acceso a elemen os en documen os XML, HTML y XHTML
19
6.2 Es uc u a gene al del código
Es e código apa e de las con enciones de es ilo seguidas a iba iene o as
ca ac e ís icas impo an es.
•To almen e o ien ado a obje os: es o quie e deci que odo el código (excep o
unas pocas unciones auxilia es) es o bien unciones cons uc o as o bien
decla ación de mé odos y a ibu os pa a las di e en es clases.
•El código es á di idido lo máximo posible en di e en es mé odos lo que lle a a
ozos de código co os y no excesi amen e complejos.
•Se e i a añadi o elimina a ibu os de obje os y/o clases en iempo de
ejecución: es o solo se ealiza o bien en la cons uc o a o en una unción ini de la
clase, la cual se llama desde la unción cons uc o a.
•Va iables suelen con ene siemp e el mismo ipo de obje o: de no se así,
ienden a se obje os es echamen e elacionados en e si, como po ejemplo
obje os que he edan de la misma clase.
6.3 Viabilidad de la modi icación p og amá ica del código uen e de
Snap
Teniendo en cuen a las ca ac e ís icas de Ja aSc ip [16] hay que analiza si es siquie a
posible modi ica un código esc i o en él, al e ando su uncionamien o de o ma
p og amá ica du an e un análisis es á ico. Al se Ja aSc ip un lenguaje in e p e ado iene
una g an can idad de uncionalidades que hacen es a a ea complicada. Algunos ejemplos
que nos a ec an se ían:
•Tipado dinámico
a a = 5; //a's alue is a Numbe
a = { oo: unc ion () { e u n 'hello';} }; //a's alue is an Objec wi h one p ope y
a = 'hello'; //a's alue is a S ing
a. oo(); //won' cause an e o un il his line o code is execu ed
•Capacidad de añadi y elimina p opiedades a obje os y clases en iempo de
ejecución
a obj = { };
obj.a = 5;
console.log(obj.a); //p in s 5
dele e obj.a;
console.log(obj.a); //p in s unde ined
20
•Acceso de o ma no explíci a a es as p opiedades
a obj = { a: 'hello' };
console.log(obj.a); //p in s hello
a p op = 'a';
console.log(obj.[p op]); //p in s hello
•Llamadas a unciones con más o menos a gumen os de los decla ados
a oo = unc ion (a, b) { i (b) e u n a + b; else e u n a; }
oo(5); // e u ns 5;
oo(5, 6); // e u n 11
Como podemos e hay ba e as impo an es que hacen que la a ea sea inc eíblemen e
compleja. De hecho modi ica de la mane a p e endida código a bi a io Ja aSc ip es
segu amen e una a ea imposible. Pe o es e abajo no a a con código a bi a io sino con
uno muy conc e o, el código uen e de Snap.
Como hemos is o en el pun o an e io , el lenguaje en el que es á esc i o Snap es
ealmen e un subconjun o de Ja aSc ip con un es ilo y una es uc u a muy conc e as.
El p oblema p incipal a la ho a de modi ica p og amá icamen e el código se ían las
he amien as dinámicas de las que dispone el lenguaje y Snap las u iliza poco y en
si uaciones de inidas y conc e as. O o pun o impo an e es que la modi icación es
ela i amen e sencilla, siemp e es amos eliminando código, y en caso de modi ica lo, es
solo pa a man ene su uncionamien o co ec o eniendo en cuen a las pa es de código
que ya no exis en. No añadimos código ni hacemos modi icaciones a bi a ias.
G acias a es o, podemos a on a el p oblema como si es u iésemos abajando con un
lenguaje mucho más es ic o y es á ico, usando nues o conocimien o sob e el código
Snap en caso de que nos encon emos con alguna si uación ambigua.
Aún así, oda ía queda una cues ión abie a. Si que emos ealiza un análisis es á ico del
código, necesi amos sabe el ipo de las a iables, e o no de unciones, e c. Es a
in o mación no se encuen a en ninguna pa e del código ya que no o ma pa e de la
sin axis del lenguaje y po lo an o es imposible de ob ene sin ayuda ex e na (du an e un
análisis es á ico). Ve emos como se ha solucionado es e p oblema en el siguien e
apa ado.
21
6.4 In e aces
Nos encon amos con la necesidad de conoce p e iamen e los ipos que ienen los
di e en es elemen os del código. En conc e o necesi amos:
•Tipo de e o no de unciones
•Tipo de a gumen os de unciones
•Tipo de las p opiedades de clases
Los ipos de las a iables no se han incluido ya que pueden induci se di ec amen e del
código, e aluando las exp esiones que les asignan un alo , si enemos la in o mación
an es mencionada. Y como en Snap siemp e se decla a y asigna un alo a las a iables
an es de su uso14, es o no ep esen a un p oblema.
La solución po la que se ha op ado inalmen e es c ea In e aces. Es as son a chi os a
las que llama emos de es a mane a en e e encia a las in e aces de Ja a, las cuales son
muy pa ecidas en o ma y pa cialmen e en su obje i o.
Su uncionamien o es sencillo. El usua io esc ibe en ellas, en ningún o den en conc e o:
•Los ipos de e o no y el ipo de los a gumen os de odas las unciones decla adas
a ni el de documen o
•Pa a cada clase con enida en el documen o el usua io esc ibi á los ipos de sus
a ibu os e, igual que con las unciones globales, los ipos de e o no y de los
a gumen os de sus mé odos.
Con es os a chi os pues, se iene oda la in o mación necesa ia pa a pode analiza
es á icamen e el código ya que podemos sabe en odo momen o el ipo de odas las
a iables, llamadas a unciones, e c, y oma po lo an o decisiones in o madas sob e
como modi ica lo co ec amen e.
14 Con una excepción, e : 8.2 In e aces y P agmas
22
6.7 Algo i mo
Hemos is o a lo la go de es e documen o los di e en es elemen os que necesi amos en
p epa ación a a pode implemen a el código que modi ica á el en o no. Analiza emos
aho a como es el código que ealiza es a ope ación y de ini emos el algo i mo. Es a
de inición se á en pseudocódigo y en al o ni el, no en a emos en como la e iciencia. Es o
se á comen ado en el apa ado de implemen ación.
6.7.1 Iden i icación de elemen os ele an es
Pa a pode analiza el código y modi ica lo hay una se ie de a eas que hab á que ealiza
du an e el algo i mo, eamos cuáles son:
•P opagación co ec a de ipos: necesi amos sabe en cada momen o que ipo
iene en cada momen o cada a iable pa a pode comp oba si los accesos a sus
p opiedades son álidos en el con ex o de las in e aces que se han p opo cionado.
También enemos que con ola que ipo e o nan di e en es ins ucciones, como
po ejemplo llamadas a unciones. G acias a las in e aces es e p oceso es
ela i amen e sencillo. Básicamen e bas a con e alua el código siguiendo las
eglas del lenguaje y u iliza los me ada os de las in e aces cuando sea necesa io.
•De ec a en que pun o del código nos encon amos: una misma ins ucción
puede ene que se a ada de o ma algo dis in a según el con ex o en el que se
encuen e den o del código. Es o se ealiza con la ayuda del Pa se T ee como se
ha comen ado apa ados an e io es.
•Validez: cada nodo debe á de comp oba su alidez, es a depende á de di e en es
aspec os, como la alidez de sus hijos, acceso a clases que no apa ecen en las
in e aces, e c.
•Reesc i u a del código: en caso de que el nodo no sea álido pueden da se dos
casos:
◦El nodo se in alida y su código desapa ece del esul ado inal
◦El código del nodo se eesc ibe de o ma que sea álido en el nue o código
modi icado
•Re o no de in o mación: simila men e a como nodos pad es ienen que indica el
con ex o del código, cada nodo hijo end á que de ol e a su pad e in o mación
sob e él. Po ejemplo su código, su alidez, e c.
29

6.7.2 De inición
I. Si el ipo del nodo en que nos encon amos se puede ob ene e aluando solamen e
el nodo e o namos es e di ec amen e. Po ejemplo:
◦Una llamada a un mé odo de una clase. El ipo de e o no se ob iene
di ec amen e de la in e az.
◦Un li e al de ipo Numbe . Su ipo siemp e es el mismo, siemp e que se
encuen e uno en el código sabemos au omá icamen e cuál es.
II. Si el nodo en que nos encon amos calcula su ipo a pa i de sus hijos ob enemos
el ipo de es os, calculamos el p opio y lo e o namos. Po ejemplo:
◦El ipo de una ope ación de suma de i a del ipo de sus ope andos.
III. Si nos encon amos en una decla ación o asignación, y el ipo de la pa e izquie da
no iene ya de inido po la in e az (p opiedad de una clase), el ipo de la pa e
izquie da pasa a se el que ob engamos de e alua la pa e de echa.
El algo i mo de modi icación de código es:
I. Visi a la aíz del á bol, es deci el nodo que ep esen a la egla de en ada al
código de la g amá ica.
II. En cada nodo, después de ejecu a el mé odo de en ada:
Si nos queda algún hijo sin isi a :
Visi a el p ime hijo sin isi a que nos encon emos
En caso con a io:
Sali del nodo
El código pa a es as dos ope aciones es:
Visi a un nodo:
Ejecu a el mé odo de en ada del nodo. En es e:
I. Modi ica adecuadamen e la in o mación de con ex o de la egla, la cual da a los
hijos in o mación sob e el con ex o del código en el que se encuen an
II. Hace las ope aciones de p ep ocesamien o p opias a la egla que se es é
a ando. Es as pueden se a iadas y dependen en g an medida de que egla se
es é a ando, su núme o de hijos, e c.
30
Sali de un nodo:
Ejecu a el mé odo de salida del nodo. En es e:
I. Comp oba la alidez de los hijos. Es a ope ación es sencilla ya que cada nodo
in o ma a su pad e de su alidez.
II. Comp oba la alidez p opia. Un nodo es álido si y solo si:
1. Todos sus hijos son álidos
2. No accede ninguna clase, p opiedad de clase ni unción global que no apa ezca
en las in e aces
3. Si accede a una a iable local es a iene que se álida. Es deci , le ha sido
asignado un alo y la ope ación ha sido álida siguiendo es as eglas
III. Si el nodo esul a no se álido:
1. Si es posible, eesc ibi el código y acep a como álido el nodo. Es e p oceso
es di e en e pa a cada egla, pe o iene que man ene las es condiciones
an es mencionadas po lo que que las ope aciones que se pueden ealiza pa a
ecupe a la alidez son:
i. Reesc ibi el código e i ando u iliza el pe enecien e a hijos no álidos
ii. Reesc ibi el código e i ando accede elemen os no decla ados
2. En caso con a io ma camos el nodo como in álido.
IV. Si el nodo es álido de ec a su ipo pa a ealiza la p opagación
V. De ol e el código del nodo, su ipo y su alidez al pad e
31
7 Implemen ación
7.1 Es ilo de aplicación
Como es a aplicación es á pensada pa a se usada po los usua ios de Snap, el p ime
paso ue escoge que ipo de aplicación íbamos a desa olla . Se ba aja on dos opciones
p incipales:
•Aplicación web
•Aplicación de esc i o io
A pesa de que la aplicación de esc i o io iene algunas en ajas, ápidamen e se op ó po
c ea una aplicación web. Es os son los mo i os p incipales:
•Mayo acilidad de uso y comodidad pa a el usua io inal: una aplicación web
no iene que se desca gada ni ins alada po el usua io. Es e simplemen e accede
a ella desde su na egado y al acaba de u iliza la la cie a y se ol ida. Que emos
es a sencillez de uso en nues a aplicación ya que en caso con a io pod ía echa
a ás a po enciales usua ios.
•Mismo es ilo que Snap: Snap ambién es una aplicación pensada pa a se
u ilizada desde el na egado po mo i os simila es a los expues os. Escoge es e
es ilo pa a nues a aplicación nos pe mi e man ene una con inuidad con Snap y
da un sensación de amilia idad al usua io.
•Posibili a la in eg ación con Snap: A pesa de que aho a mismo nues a
aplicación se accede desde su p opia página, si e en ualmen e se in eg a en la
Snap se pod á hace muy ácilmen e. Bas a á con mo e el código que hace la
llamada al Web Se ice a Snap.
•Man enimien o más sencillo: al encon a se oda la aplicación en un se ido
con olado po el desa ollado es mucho más sencillo modi ica , amplia o aplica
pa ches a la aplicación en caso necesa io, de o ma anspa en e al usua io inal.
32
7.2 Módulos de la aplicación
Se han c eado dos módulos di e enciados que abajan conjun amen e pa a cumpli los
obje i os.
•Aplicación web: o mada po una página web que el usua io inal u iliza á pa a
accede a la uncionalidad del sis ema. También disponemos de un Web Se ice
que se ejecu a á en un se ido y se á el enca gado de gene a y en ia al usua io
los ejecu ables a pa i de sus p og amas.
•C eado del en o no de ejecución: es e p og ama es el enca gado de ob ene la
in o mación sob e el código Snap y el código uen e o iginal del mismo y, a pa i de
es os, gene a el en o no de ejecución educido que se u iliza á pa a gene a los
ejecu ables y deja lo a disposición del Web Se ice.
Pa a implemen a ambas pa es del abajo se han u ilizado ecnologías lo más po ables,
ex endidas y es anda izadas posibles. Es o es así po que el sis ema acaba á
ejecu ándose en un se ido del cual desconocemos sus ca ac e ís icas, además es
posible que a lo la go de su ida ú il sea asladado a di e en es máquinas y que emos
que sea posible ejecu a lo en odas. También se quie e e i a de es a mane a que alguna
de las ecnologías u ilizadas acabe siendo obsole a o el sis ema sea di ícil de man ene en
el u u o.
7.3 In e aces
Como se ha comen ado p e iamen e en es e documen o oda la in o mación ex e na
sob e el código que es necesa ia pa a modi ica lo se in oduce en el p og ama median e
es os a chi os, que esc ibi á o bien el enca gado de la aplicación o o a pe sona que
enga un cie o conocimien o del código Snap. Aunque écnicamen e son una pa e del
modi icado de código debido a su impo ancia las explica emos aquí en de alle.
Las in e aces se c ea án u ilizando lo que llama emos p agmas. Es os se llaman así ya
que se u iliza án en nues a aplicación de mane a simila a los que u ilizan compilado es
de o os lenguajes. Es os end án el siguien e o ma o:
/*@ {
[pass h ough]
name: nomb e,
class: ipo,
[ a ],
[ ype: ipo_de_elemen os_de_lis a],
[ e u n: ipo_ e o no_ unción],
[pa ame e s: pa áme os_ unción],
[p ope ies: p opiedades_del_obje o]
} !*/
Las p opiedades pueden es a en cualquie o den. Impo an e des aca que es e o ma o
es que es ecu si o, excep o la ape u a (/*@) y el cie e (!*/), los cuales se u ilizan solo
una ez el es o puede es a anidado. Es o nos pe mi e ep esen a cualquie obje o o
clase Ja aSc ip de complejidad a bi a ia.
33
Se ha u ilizado po un lado el o ma o de comen a ios mul ilínea Ja aSc ip . Es o es así ya
que es os p agmas ambién pueden es a embebidos en el mismo código Ja aSc ip
o iginal y que emos que es e siga siendo uncional. Po o o, u ilizamos un o ma o muy
simila a JSON18 [21]. Es a decisión se ha omado debido a que es ácil de pa sea y a a
simul áneamen e, además Snap es á muy elacionado con Ja aSc ip y así man enemos
una cie a con inuidad. Como hemos implemen ado nues o p opio pa se , hemos
implemen ado alguna sin axis que no es del odo co espondien e con la de JSON pa a
acili a la decla ación de los p agmas.
7.3.1 A ibu os p agma
pass h ough
Es e a ibu o debe de u iliza se solo. Su obje i o es indica que la in o mación de la
in e az es necesa ia du an e la ejecución del p og ama, pe o no que emos modi ica el
código de es e iche o.
name
Siemp e obliga o io. Indica el nomb e de la a iable, p opiedad de obje o, e c, que es é
ep esen ando el p agma.
class
La clase del í em. Sopo amos ambién obje os mul iclase. Es o es impo an e ya que a
eces algunas a iables u ilizadas en Snap pueden con ene alo es de clases di e en es.
En caso de una sola clase podemos esc ibi simplemen e su nomb e.
class : oo
Es a clase puede es a ep esen ada po un p agma si es compleja. Si u ilizamos un
p agma es e iene que es a en e lla es como si se a ase de una lis a de clases:
class : { {class: A ay, ype: oo} }
Pa a mul iclase se u iliza una lis a sepa ada po comas ce ada po lla es. Los elemen os
de la lis a pueden se s ings o p agmas.
class : { {class: A ay, ype: oo}, ba , Numbe }
a
Campo que ienen que lle a obliga o iamen e a iables y unciones decla adas a ni el de
documen o. Es o es necesa io pa a di e encia unciones cons uc o as de la clase de la
cual c ean obje os.
18 Ja aSc ip Objec No a ion
34

ype
Solamen e es necesa io si el í em es de la clase A ay. Es e campo indica el ipo de los
elemen os. Puede ambién se mul iclase.
/*@ { name: a , class: A ay, ype: oo } !*/
e u n
Solamen e es necesa io si el í em es de la clase Func ion. Es e campo indica el ipo de los
elemen os. Puede ambién se mul iclase. En caso de una unción que de uel a oid 19 se
puede esc ibi de mane a simpli icada.
/*@ { name: oo, class: Func ion, e u n: Numbe } !*/ // e u ns a Numbe
/*@ { name: ba , class: Func ion} !*/ // oid
pa ame e s
Solamen e es necesa io si el í em es de la clase Func ion. Es e campo indica el nomb e y
ipo de sus a gumen os. Los a gumen os pueden se mul iclase.
/*@ {
name: oo, class: Func ion,
pa ame e s: { {name: a g1, class: {Numbe , S ing}} }
}!*/
p ope ies
Igual en su o ma o a pa ame e s pe o indica las p opiedades de un obje o o clase.
/*@{
name : Cus omRepo e BlockMo ph,
class : Repo e BlockMo ph,
p ope ies :
{{
name : ini , class : Func ion,
pa ame e s : { {name : isP edica e, class : Boolean} }
}}
}!*/
Es e ejemplo de ine una clase llamada Cus omRepo e BlockMo ph que he eda de la
clase Repo e BlockMo ph y iene un mé odo llamado ini que e o na oid y dispone de
un pa áme o llamado isP edica e, el cual es un Boolean. Podemos e como se puede
usa es a es uc u a pa a de ini cualquie clase que nos encon emos en el código Snap
u ilizando siemp e la misma es uc u a.
19 En Ja aSc ip una unción que no e o na ningún alo e o na unde ined.
35
7.3.2 Uso de las in e aces
Las in e aces se u ilizan de la siguien e mane a:
•La in e az con iene un p agma pa a cada unción decla ada a ni el de documen o.
También iene uno pa a cada clase decla ada en el documen o. Ob iamen e solo
hay que inclui los que se quie an man ene en el código modi icado. Cada uno de
es os p agmas incluye in o mación sob e las p opiedades que se quie en man ene
en el código inal.
•Se c ea una in e az po cada iche o del código uen e de Snap que end á el
mismo nomb e que el o iginal pe o una ex ensión .in o.
•En caso de que un iche o no con enga ningún código que que amos man ene en
el código modi icado no es necesa io c ea una in e az pa a él.
•Si que emos man ene el iche o en e o y es e no con iene ningún código que sea
u ilizado ue a del mismo bas a con c ea una in e az que solo con enga un
p agma de pass h ough.
•Si que emos man ene el iche o sin modi ica lo, pe o es e con iene clases
u ilizadas en o as pa es del código (po ejemplo Mo phic.js), podemos omi i los
a ibu os pa ame e en la in e az debido a que es os solo son necesa ios pa a la
modi icación. Además si sabemos muy bien que mé odos y a ibu os se u ilizan
ue a del iche o solo necesi amos da in o mación pa a es os (y podemos omi i
odo lo que sea au ocon enido).
Exis e ambién un iche o ex a llamado sys em.in o que con iene in o mación sob e
clases, unciones, e c, de Ja aSc ip . Es e iche o con iene odos los elemen os
p opo cionados po el lenguaje que u iliza Snap (y algunos más en caso de que algún día
se u ilicen).
7.3.3 P agmas en el código
Como se e á más adelan e en el apa ado de esul ados hay algunas excepciones en
que una in e az no es su icien e pa a da oda la in o mación necesa ia ya que se
equie e indica p opiedades de a iables locales. Pod ían ob iamen e añadi se en el
a chi o de in e az, pe o se ha encon ado que es e sis ema es poco p ác ico así que se
ha decidido que es a in o mación se añada di ec amen e en el código, an es de la a iable
co espondien e.
Es e mismo sis ema ambién pod ía u iliza se pa a in o ma sob e unciones decla adas
en el in e io de o as. Pe o es o no ha sido necesa io ya Snap las u iliza muy poco20 y en
luga es que son eliminados del código de ejecución educido.
20 Si que u iliza muchas unciones anónimas co as como a gumen o de unciones. Pe o es as se a an
di e en e.
36
7.4 Modi icado de código Snap
El p og ama enca gado de modi ica el código uen e o iginal de Snap y con e i lo en la
e sión educida que desc iban las in e aces.
Se a a de un solo p og ama esc i o en su o alidad en Ja a, lo que pe mi e mo e lo a la
misma máquina en la que alojemos el Web Se ice sin demasiada di icul ad. Es o úl imo
no es es ic amen e necesa io, ya que pa a el uncionamien o co ec o del Web Se ice
solo es necesa io que disponga de los iche os Ja aSc ip que componen el en o no de
ejecución, pe o si se ejecu an en la mismo máquina, el p og ama Ja a deja á los iche os
de mane a au omá ica en el luga co espondien e. También ab e la pue a a pe mi i que
el Web Se ice llame a la aplicación en caso de que sea necesa io en alguna ampliación
u u a del sis ema.
G acias a la can idad de he amien as que o ece Ja a po de ec o no ha sido necesa io
u iliza ninguna lib e ía ex e na a excepción de ANTLR4.
Los únicos p e equisi os que necesi a pa a ejecu a se son:
•Tene a disposición una ca pe a con el código uen e o iginal de Snap
•Dispone de una ca pe a con las in e aces que el usua io ha enido que gene a
p e iamen e
Analiza emos aho a las pa es más impo an es del p og ama.
7.4.1 Es uc u as de da os
Es e p oyec o no necesi a es uc u as de da os demasiado especializadas pe o si que
u iliza una g an can idad y a iedad de ellas. Las es uc u as pe sonalizadas que hemos
necesi ado suelen encapsula o as más básicas y si en sob e odo pa a acili a y
es anda iza el acceso a los da os a a és de odo el p og ama o eciendo mé odos de
acceso y modi icación de los da os.
•Es uc u as es ánda : en odos es os casos hemos u ilizado di ec amen e la
implemen ación dada po Ja a. Se han u ilizado colas, pilas, maps, lis as y se s. El
uso mas impo an e ha sido una pila de lis as que se u iliza pa a gua da la
in o mación de e o no de los nodos. An es de en a en un nue o nodo se empila
una nue a cola. En es a odos los hijos colocan su in o mación de e o no, es o
pe mi e al pad e accede la en o den. Se u iliza una pila pa a que imi e el s ack que
c ea el eco ido ecu si o del á bol. Finalmen e al abandona el nodo se ejecu a
una ope ación de pop y queda en p ime a posición la cola del siguien e nodo al que
se e o na á.
El es o de es uc u as han sido u ilizadas pa a implemen a el es o de es uc u as
de da os y pa a a ibu os necesa ios en a ias clases.
37
•ClassIn o: una es uc u a sencilla pe o i al pa a la aplicación. Consis e en una
upla que almacena oda la in o mación dada en las in e aces pa a cada elemen o
decla ado en ellas. También se u iliza pa a las a iables que se ayan decla ando a
lo la go del código. Lo in e esan e de es a es uc u a es que si e an o pa a odos
los elemen os que nos podamos encon a en el código como pod ían se
a iables, unciones, clases, e c. Es o hace el p ocesado más sencillo y
homogéneo, además hace muy sencillo in oduci los da os de los p agma en la
aplicación.
•Scope: una es uc u a ecu si a que almacena las a iables de un ámbi o de
isibilidad, los cuales es án o mados po clausu as en Ja aSc ip [22].
Implemen an lo que en un compilado se ía la Symbol Table [23].
Cada Scope iene un pun e o a su pad e, lo que pe mi e es au a lo una ez el
Scope ac ual es abandonado y des uido y ambién pe mi e busca símbolos po
oda la cadena de ámbi os de isibilidad has a llega a ni el de documen o (el
úl imo ámbi o exis en e en Ja aSc ip ). Pa a implemen a lo se ha u ilizado un Map
que elaciona el nomb e de la a iable con el ClassIn o que gua da su in o mación.
A pesa de que exis en o as posibilidades más so is icadas, en Snap siemp e
abajamos con ámbi os de isibilidad pequeños debido a su es uc u a, po lo que
un Map es más que su icien e en é minos de endimien o y uncionalidad.
•WalkIn o: es a es uc u a ambién se a a de una upla, pe o en es e caso si e
pa a almacena la in o mación de e o no de los nodos. Con iene in o mación an
i al como su alidez, el código que lo ep esen a, su ipo, e c.
7.4.2 Pa se /ANTLR4
Las clases enca gadas de pa sea el código y c ea la es uc u a de da os con la que se
eco e á el á bol esul an e son las gene adas po ANTLR4 a pa i de nues a g amá ica.
Es as simplemen e han sido añadidas a nues o p oyec o jun o a las lib e ías de ANTLR4
p opiamen e dicho. El obje i o de usa ANTLR4 e a aho a nos abajo así que
simplemen e hemos supues o que uncionan co ec amen e y no hemos in es igado
excesi amen e su uncionamien o. Una excepción es la clase SnapT eeWalke , que
ealiza el abajo de camina po el á bol gene ado.
7.4.2.1 SnapT eeWalke
Consis e en una modi icación del código po de ec o que u iliza ANTLR4 pa a eco e el
Pa se T ee gene ado a pa i de un código Snap. La modi icación in oduce el concep o de
sal a se la isi a a un hijo. Es o se ha hecho po emas de e iciencia, ya que muchas
eces podemos e que un nodo es in álido y en ese caso no iene sen ido isi a a sus
hijos.
38
45
Figu a 9: Página web de Snap! isualizada en el mismo sis ema que la an e io igu a
Figu a 8: Aspec o de la página en el mismo en o no después de una pe ición al se ido ,
espe ando su espues a

7.5.2 Web Se ice
Es e es el p og ama que se ejecu a á en el se ido y a ende á las pe iciones en iadas
desde la página web. Es á implemen ado en Node.js (que u iliza Ja aSc ip ) y el mismo
p og ama hace a su ez de se ido web, escuchando el pue o que se le haya asignado,
manejando el p o ocolo H p, e c. G acias a que Node hace es o ex emadamen e sencillo
se e i a ene que ins ala más p og amas en el se ido .
El Web Se ice si e po un lado la página web que se ha explicado en el pun o an e io a
las pe iciones GET que lleguen po el pue o asignado a la aplicación. Po o o se enca ga
de a ende pe iciones POST que lleguen po el mismo pue o, pe o a la di ección
/gen_exec. Las pe iciones a es a di ección son las que en ía la página web pa a pedi la
gene ación de un ejecu able. Una ez llega una de es as pe iciones el p oceso es el
siguien e:
•Valida la in o mación con enida en el POST: es e p oceso e i a in oduci da os
inco ec os, co up os o diseñados po un usua io malin encionado en el sis ema.
•C ea el ejecu able: odo el p oceso se ealiza en memo ia po lo que e i amos
ene que esc ibi iche os, lo que alen iza ía el sis ema, obliga ía a ealiza a eas
de cleanup, e c:
◦Añadi el p oyec o del usua io al en o no de ejecución seleccionado po el
mismo, el cual puede se una Snap comple o o el en o no de ejecución educido
que hemos c eado en es e abajo. Es a a ea es sencilla ya que el p oyec o
comple o consis i á en una s ing en o ma o XML que c ea el p opio Snap.
◦Seguidamen e se gene a un a chi o ZIP con el esul ado del pun o an e io y el
a chi o de con igu ación usado po NW.js, en el que se incluyen las
p e e encias indicada po el usua io.
◦Es e ZIP se adjun a al bina io y las lib e ías de NW.js co espondien es con al
de c ea un ejecu able po able. El p oceso es di e en e pa a cada sis ema.
•O ece al clien e el a chi o como desca ga: inalmen e se o ece el iche o con
odo el con enido gene ado en los pasos an e io es como desca ga al clien e que
ha hecho la pe ición.
•Manejo de e o es: si du an e alguna de las ope aciones en el POST se p oduce
un e o se en ia á un código de e o 500 al clien e pa a que pueda in o ma al
usua io de que no se ha podido gene a su ejecu able. También si alguien accede a
una di ección equi ocada se le edi ecciona á a una página de e o 404.
46
8 Resul ados
A con inuación analiza emos los esul ados del sis ema, en que medida cumple los
di e sos obje i os que nos habíamos p opues o y su uncionamien o en gene al.
El esul ado más impo an e a des aca , es el hecho de que el sis ema unciona
co ec amen e y nos o ece la uncionalidad que deseábamos. Somos capaces de, a pa i
del código uen e o iginal de Snap, gene a un en o no de ejecución educido sin
necesidad de ene que modi ica código manualmen e. El Web Se ice po su pa e es
capaz de c ea ejecu ables pa a odas las pla a o mas escogidas, ecibiendo solamen e
un documen o XML que con enga un p oyec o Snap. Es os ejecu ables
independien emen e de la pla a o ma pa a la que sean c eados, son o almen e
au ocon enidos, po lo an o pueden usa se y mo e se lib emen e sin depende de o as
he amien as.
8.1 Gene ación de ejecu ables
El esul ado de la gene ación de ejecu ables ha sido excelen e y exac amen e como se
había p e is o. Somos capaces de gene a en el se ido , a pa i de cualquie p oyec o
Snap, ejecu ables pa a las es pla a o mas que nos habíamos p opues o y es os son
o almen e po ables y no ienen ninguna dependencia a e ce os.
La gene ación de ejecu ables es sencilla y no equie e de la desca ga ni ins alación de
ningún ipo de so wa e adicional po pa e del usua io.
Los ejecu ables además de unciona co ec amen e ambién cumplen o os aspec os no
uncionales, como mos a un icono ele an e a Snap, ene í ulos y nomb es de en ana
que dependen del p oyec o in oducido, e c.
8.2 In e aces y P agmas
El sis ema de in e aces y p agmas que hemos implemen ado cumple los equisi os que
espe ábamos. Somos capaces de in oduci in o mación al sis ema sob e odas las clases
que con o man el código ellenando con p agmas los a chi os de in e aces
co espondien es. Uno de los obje i os de las in e aces e a e i a ene que in oduci
p agmas en el mismo código, es o no se ha podido consegui del odo.
47
P agmas en el código
Ha sido necesa io apa e de las in e aces añadi cua o p agmas en el código. Pasemos
a e en que con ex o y como a ec a es o a la usabilidad del sis ema:
•Adición dinámica de p opiedades a un obje o: pa a pode ealiza la
modi icación de código necesi amos sabe p e iamen e que p opiedades a a ene
un obje o. Si en el código es as an siendo añadidas dinámicamen e necesi amos
un p agma an es de su decla ación que nos indique cuáles a a posee , ya que en
caso con a io, debido al uncionamien o de las in e aces, enemos que supone
que la p opiedad accedida iene que se eliminada.
Como hemos is o, Snap no u iliza es a o ma de p og ama que o ece Ja aSc ip
en gene al. Pe o en S o e.js, al es a algo al ma gen del es ilo gene al de Snap,
es o ocu e dos eces y además en una a iable local, lo que impide que podamos
añadi la in o mación a la in e az co espondien e. Aún así, al ocu i solo en un
a chi o en el que ya espe ábamos que pudiese da se el caso y solo ocu e con dos
obje os, los cuales apa ecen en el mismo mé odo, no c eemos que sea un
p oblema muy g a e que a ec e nega i amen e a nues a solución. Si inalmen e
es e abajo se une a Snap se ía an sencillo como eesc ibi la decla ación de los
obje os pa a pe mi i induci el ipo de sus p opiedades en el análisis es á ico o bien
man ene los p agmas.
•Loops: más conc e amen e el uso de una a iable pa a gua da el úl imo elemen o
a ado en el loop.
a cell, las Cell;
o (i = 0; i < end; i += 3) {
cell = his. ame.con en s.child en[i];
label = his. ame.con en s.child en[i + 1];
bu on = his. ame.con en s.child en[i + 2];
i (las Cell) {
cell.se Top(las Cell.bo om());
}
// i ele an code
las Cell = cell;
}
Como podemos obse a , las Cell no es asignada has a el inal del loop, pe o se
u iliza p e iamen e. Has a su asignación no podemos induci su ipo, po es e
mo i o la llamada a su mé odo bo om se conside a ía in álido a la ho a de analiza
el código (ya que en el análisis es á ico el i es analizado an es que la asignación).
Po es e mo i o se necesi a un p agma que nos indique p e iamen e el ipo de
las Cell. Es e caso a di e encia del an e io se pod ía e i a median e el uso de
algo i mos más complejos y se comen a en el apa ado de mejo as u u as.
Es e uso se encuen a dos eces en el código y a di e encia del an e io si que es
más impo an e ene lo en cuen a ya que las eglas de es ilo no impiden que en un
u u o se añadan más asignaciones de es e ipo en loops, po lo que eesc ibi el
código en es e caso no se ía una solución álida. Nues o modi icado de código es
el que iene que sabe maneja es e caso.
48
8.3 Modi icación del código uen e
Pa a ealiza la modi icación del código uen e que es e p oyec o eque ía hemos
necesi ado c ea in e aces pa a 10 de los 15 iche os del código uen e de Snap
( écnicamen e son 46, pe o la di e encia a pesa de se código Ja aSc ip simplemen e
de inen obje os con las aducciones pa a di e en es idiomas). Los a chi os que no han
ecibido in e az son eliminados comple amen e y odas sus clases que sean
e e enciadas en o os a chi os desapa ecen del código gene ado.
De los diez a chi os man enidos, cua o no son a ados y su in e az exis e simplemen e
pa a in oduci in o mación sob e sus clases en el p og ama pa a pe mi i su modi icación.
En es os casos la in e az se puede educi solo a las p opiedades que se usen ue a de
ellas, aho ando abajo. El hecho de que es os a chi os no se modi iquen es que o man
pa e de la undación del sis ema de Snap, de inen clases que son o almen e
independien es del es o y de las cuales se necesi a oda su uncionalidad pa a que Snap
pueda unciona . Po es os mo i os no me ece la pena in e i iempo en c ea una
in e az comple a pa a es os a chi os ya que nunca se da á el caso de que usen clases o
mé odos que se quie an elimina del en o no de ejecución educido. Conc e amen e los
a chi os son:
•Mo phic.js: como se ha comen ado con an e io idad la undación de odo Snap y
un iche o algo especial ya que no sigue odas las con enciones de es ilo de Snap.
•xml.js: implemen a un pa se y codi icado xml sencillos. Es un sis ema
comple amen e desconec ado de Snap y se u iliza básicamen e en ope aciones de
gua dado y ca gado de p oyec os.
• h eads.js: es e a chi o con iene clases que se enca gan de maneja oda la
in e p e ación del código ep esen ado po los bloques de Snap.
•blocks.js: es e a chi o con iene la de inición de los bloques de código y o ma la
base del lenguaje de Snap.
El es o de a chi os son odos pe enecien es a di e en es pa es de Snap, odos ellos son
p ocesados ya que se e e encian en e ellos, po lo an o cada uno de es os a chi os ha
ecibido una in e az comple a. Con comple a nos e e imos a una que de ina
comple amen e odos los elemen os mien as que amos que es os se man engan en el
código inal.
La modi icación de código unciona co ec amen e, pe o es algo di ícil jus i ica la po
esc i o. La co ección se ha comp obado expe imen almen e, modi icando las di e en es
ac ualizaciones de Snap que han ido apa eciendo a lo la go del p oyec o y c eando
ejecu ables pa a múl iples p oyec os Snap u ilizando el en o no modi icado, que en
conjun o engloban odas las uncionalidades eque idas, odos ellos se han ejecu ado
sa is ac o iamen e.
49
Un da o in e esan e es la can idad de código eliminado, es deci , que no es necesa io
pa a la la in e p e ación del código y el ende izado de la S age en Snap, en nues o
en o no de ejecución educido. El cálculo que ha emos se á ap oximado, pe o nos da á
una idea gene al de en que medida se ha educido el en o no de Snap. Es a compa ación
iene sen ido ya que el ou pu del modi icado de código u iliza el mismo es ilo que el
código o iginal.
Reducción de código en los a chi os a ados
A chi o Líneas de código
a chi o o iginal
Líneas de código
a chi o educido
Reducción (%)
byob.js 3422 251 92.7
gui.js 6719 267 96.0
lis s.js 702 471 32.0
objec s.js 7801 3999 48.7
s o e.js 1975 756 61.7
widge s.js 3293 1199 63.6
To al 23912 6943 71.0
La can idad eal eliminada debe de se algo in e io debido a elemen os como los
comen a ios. Aún así, es in e esan e e que se ha eliminado una can idad de código
impo an e. La mayo ía del código exis e pa a ende iza y p ocesa pa es de Snap que
no nos in e esan en nues o en o no de ejecución educido, así que iene sen ido
elimina las. Es o se no a especialmen e en los dos a chi os que mas in luyen en la
in e az, byob.js y gui.js. Los cuales han sido educidos casi comple amen e. También
emos que nues o modi icado de código abaja con una can idad de código g ande, lo
cual es o a p ueba indi ec a que sopo a su co ección.
50

9 Mejo as u u as
A pesa de que los esul ados de la aplicación han sido los espe ados es o no quie e deci
que es e inalizada. Debido a la limi ación de iempo y ecu sos de es e p oyec o no se
han podido inclui odos los elemen os que se p e endían, además ambién hay a eas de
man enimien o y nue as ea u es que se pod ían añadi que no o maban pa e de los
obje i os iniciales. Los pun os más impo an es se ían:
•A eglo de bugs: a pesa de que no hemos de ec ado ninguno hacia el inal del
desa ollo y se ha dedicado bas an e iempo a busca y elimina an os como ha
sido posible, es muy p obable que aún exis an di e sos e o es en el código que no
han salido a la luz con el inpu que se ha dado al p og ama has a aho a. Es os
debe ían de se eliminados cuando ayan su giendo a medida que se u ilice la
aplicación.
•Ac ualización pa a nue as e siones de ECMASc ip : no an o una mejo a
como un man enimien o. ECMASc ip es un lenguaje que hoy en día aún ecibe
nume osas e isiones y, en caso de que Snap pase a u iliza nue as he amien as
que se añadan al lenguaje, es as ienen que inclui se en la aplicación.
•In oducción de algo i mos más so is icados de análisis de código: a pesa de
que es a aplicación no iene que ealiza ope aciones an complicadas como un
compilado y unciona con los algo i mos algo más básicos empleados du an e el
desa ollo, se bene icia ía del uso de algo i mos más complejos y con más alcance
pa a, po ejemplo, pode educi algo de la in o mación que iene que indica el
usua io o educiendo la edundancia del código gene ado. Po ejemplo se pod ían
acaba de elimina odos los p agma que ac ualmen e hay que añadi al código
median e un algo i mo que, en caso de encon a se un loop lo analizase po
adelan ado pa a pode ob ene los ipos de las a iables y e i a casos como el
comen ado en el apa ado an e io .
•Pe mi i ejecu ables pa a más pla a o mas: aho a mismo es e es capaz de
gene a odos los ipos de ejecu ables que se habían p opues o en el abajo. Pe o
se ía in e esan e inclui aún más pla a o mas, como po ejemplo las mó iles.
•Amplia las posibilidades de los ejecu ables c eados con un en o no
comple o de Snap pa a pe mi i el uso de odas sus ea u es e incluso amplia las
(ap o echando la ecnología NW.js) pa a pode , e en ualmen e, llega a una
e sión de esc i o io de Snap que sea capaz de lee y esc ibi en disco, e c.
51
10 Conclusiones
En es e p oyec o hemos desa ollado una aplicación capaz de educi el código uen e de
Snap a un subconjun o a bi a io que de ine el usua io. Es a he amien a se ha u ilizado
pa a pode gene a un en o no de ejecución educido pa a p oyec os Snap que a su ez
se ha hecho se i pa a c ea ejecu ables pa a dis in os sis emas ope a i os a pa i de
p og amas Snap.
El esul ado ha sido sa is ac o io, con in o mación básica sob e las clases que componen
el código podemos c ea un código Ja aSc ip co ec o y uncional que cumple los
equisi os que nos habíamos p opues o. Los ejecu ables gene ados po la aplicación
mues an solamen e el esul ado de la ejecución del código y son áciles de ob ene ,
aslada y usa po el usua io, sin necesidad po su pa e de ealiza abajo ex a. Todo el
abajo es ealizado de o ma anspa en e en nues o se ido y los ejecu ables
gene ados no necesi an ningún p og ama de e ce os pa a unciona .
Todo el sis ema, an o el Web Se ice como el modi icado de código es o almen e
po able, u ilizando ecnologías que no es án ligadas a una pla a o ma conc e a.
A pesa de odo, debido a limi aciones de iempo y ecu sos han quedado algunos pun os
de mejo a pendien es. El más impo an e se ía elimina comple amen e la necesidad de
añadi p agmas en el mismo código uen e ya que es e es un pun o impo an e pa a los
desa ollado es o iginales de Snap (la no modi icación del código uen e o iginal) y
ayuda ía a la in eg ación de es a he amien a en Snap, de la misma mane a que o as
pa es de Snap que comenza on como plugins de e ce os han acabado in eg ándose en
su ama p incipal. O o pun o in e esan e se ía la implemen ación de algo i mos,
exis en es o nue os, que mejo asen la e iciencia del modi icado de código, educiendo
edundancia, esol iendo ambigüedades de o ma más obus a, e c. Algunos han enido
que queda ue a debido a que su complejidad hab ía eque ido mucho más iempo de
desa ollo y es eo del que se ha dispues o y no son es ic amen e necesa ios pa a
alcanza la uncionalidad deseada.
En conclusión, se ha conseguido c ea una aplicación in e esan e y po en e que puede
se , y se espe a que sea, la base de u u as mejo as, expe imen os y p oyec os
elacionados con Snap.
52
11 Bibliog a ía
1: Usage sha e o ope a ing sys ems [En línea]
<h ps://en.wikipedia.o g/wiki/Usage_sha e_o _ope a ing_sys ems>
[Consul a: oc ub e 2015]
2: OS Pla o m S a is ics [En línea]
<h p://www.w3schools.com/b owse s/b owse s_os.asp>
[Consul a: oc ub e 2015]
3: In e p e ed language, Languages usually compiled o a by ecode [En línea]
<h ps://en.wikipedia.o g/wiki/In e p e ed_language#Languages_usually_compiled_ o_a_by ecode>
[Consul a: oc ub e 2015]
4: ACM Re e ence Fo ma : Maloney, J., Resnick, M., Rusk, N., Sil e man, B., and
Eas mond, E. 2010. The sc a ch p og amming language and en i onmen . ACM
T ans. Compu . Educ. 10, 4, A icle 16 (No embe 2010), 15 pages. DOI =
10.1145/1868358.1868363. h p://doi.acm.o g/10.1145/1868358.1868363.
5: BYOB (Sc a ch Modi ica ion) [En línea]
<h p://wiki.sc a ch.mi .edu/wiki/Build_You _Own_Blocks_(Sc a ch_Modi ica ion)>
[Consul a: oc ub e 2015]
6: Po ing Sc a ch P ojec s [En línea]
<h p://wiki.sc a ch.mi .edu/wiki/Po ing_Sc a ch_P ojec s>
[Consul a: oc ub e 2015]
7: Buil in Sc a ch2exe [En línea]
<h ps://web.a chi e.o g/web/20120101192818/h p://sugges .sc a ch.mi .edu/ o um
s/60449-sugges ions/sugges ions/1240331-buil -in-sc a ch2exe>
[Consul a: oc ub e 2015]
8: Sc a chToJAR [En línea]
<h ps://gi hub.com/Gbea 605/Sc a chToJAR/blob/mas e /README>
[Consul a: oc ub e 2015]
9: Sc a ch To SWF [En línea]
<h ps://si es.google.com/si e/junebee le23/home>
[Consul a: oc ub e 2015]
10: Sc a ch compile [En línea]
<h ps://sc a ch.mi .edu/discuss/ opic/27690/>
[Consul a: oc ub e 2015]
11: pinecone: A Ja aSc ip ->Lua con e e [En línea]
<h ps://gi hub.com/zekesonxx/pinecone/blob/mas e /README.md>
[Consul a: oc ub e 2015]
53
12: mo phic.js - a li ely WEB_GUY inspi ed by Squeak [En línea]
<h ps://gi hub.com/jmoenig/Snap--Build-You -Own-Blocks/blob/mas e /mo phic. x >
[Consul a: oc ub e 2015]
13: JSLin Help [En línea]
<h p://www.jslin .com/help.h ml>
[Consul a: oc ub e 2015]
14: Code con en ions [En línea]
<h p://ja asc ip .c ock o d.com/code.h ml>
[Consul a: oc ub e 2015]
15: con ibu ing o BYOB4 [En línea]
<h ps://gi hub.com/jmoenig/Snap--Build-You -Own-Blocks/blob/mas e /con ibu ing%20 o%20BYOB4. x >
[Consul a: oc ub e 2015]
16: ECMASc ip Language Speci ica ion [En línea]
<h p://www.ecma-in e na ional.o g/ecma-262/5.1/Ecma-262.pd >
[Consul a: oc ub e 2015]
17: Pa sing – Compu e Languages [En línea]
<h ps://en.wikipedia.o g/wiki/Pa sing#Compu e _languages>
[Consul a: oc ub e 2015]
18: Pa sing – Compu e Languages [En línea]
<h ps://www.cs. oches e .edu/~nelson/cou ses/csc_173/g amma s/c g.h ml>
[Consul a: oc ub e 2015]
19: Pa sing – Compu e Languages [En línea]
<h p://www.an l .o g/abou .h ml>
[Consul a: oc ub e 2015]
20: ECMASc ip [En línea]
<h p://www.ecma-in e na ional.o g/publica ions/ iles/ECMA-ST/Ecma-262.pd >
[Consul a: oc ub e 2015]
21: JSON [En línea]
<h p://www.ecma-in e na ional.o g/publica ions/ iles/ECMA-ST/ECMA-404.pd >
[Consul a: oc ub e 2015]
22: Ja aSc ip Closu es [En línea]
<h ps://de elope .mozilla.o g/en-US/docs/Web/Ja aSc ip /Closu es>
[Consul a: oc ub e 2015]
23: Symbol Table [En línea]
<h p://www.cse.aucegyp .edu/~ a ea/csce447/slides/ able.pd >
[Consul a: oc ub e 2015]
54