Hola. En este curso,
nosotros repasaremos cómo funciona la ejecución de Pharo,
qué tipo de archivos se utilizan, cuando y donde.
Hasta ahora has estado usando
.imagen, .source y .changes,
y probablemente no esté claro para ti.
Funciona, pero me gustaría explicar exactamente lo que hace,
para que puedas evitar futuros errores y controlar mejor tu sistema.
En resumen, el modelo de ejecución de Pharo
es una maquina virtual que ejecuta el código compilado.
Esta maquina virtual es específica de la plataforma,
y las máquinas virtuales existen para diferentes versiones de MacOS, Windows, Linux,
iOS, ARM y Android.
Es el mismo modelo de ejecución. como para C# y Java.
En Pharo es exactamente lo mismo.
Tenemos lo que se llama compilación en múltiples etapas.
Esto significa que el código que programas se compila a primero a bytecodes,
que es un conjunto de instrucciones neutrales de la plataforma.
Y la máquina virtual transforma bytecodes en código ensamblador.
Así es como funciona Pharo.
Es lo mismo en otros lenguajes orientados a objetos.
La máquina virtual es el archivo
según tu sistema operativo, un .exe o .app con MAC.
Son máquinas virtuales.
Pueden ejecutarse en dos modos,
ya sea desde una línea de comando,
o en modo interactivo con una interfaz gráfica.
Por ejemplo, con Linux, cuando usas Pharo en un servidor
usualmente usas la línea de comandos.
La máquina virtual ejecuta código compilado
y genera ensamblador al vuelo.
Este código compilado
está empaquetado y almacenado en una imagen.
Una instantánea de memoria.
Esta imagen representa una sistema virtualizado para objetos Pharo.
Lo veremos a continuación.
La máquina virtual necesita solo la imagen para ejecutar programas.
Porque aquí es donde se compila el código y donde están los objetos.
Además, tenemos 3 archivos.
Imagen, cambios y fuentes.
Explicaré cada uno de estos archivos y su papel.
El archivo .image es una instantánea de memoria que contiene los objetos.
Contiene objetos normales como puntos, strings, etc.
Todo lo que usamos.
Pero también contiene métodos compilados
y concretamente clases compiladas.
Entonces, cada vez que guardas tu imagen, todos los objetos se guardan en el disco.
La imagen es realmente un sistema de virtualización. adelantado a su tiempo.
Al iniciar,
recuperas todos los objetos que guardaste.
Concretamente el contador del programa,
que también se guardará
y setá restaurado exactamente donde estaba antes de guardarlo.
Lo importante es que tienes un sistema operativo y una máquina virtual,
y por encima de la máquina virtual, tienes este sistema,
que es un espacio de memoria donde viven tus objetos
y que puedes guardar a tu disco o no.
Y contiene tus objetos compilados.
Es por eso que puse "1s" y "0s".
Adicionalmente, tienes el archivo de cambios.
Un archivo de cambios es un archivo que contiene copias de seguridad.
Todo lo que haces en Pharo se registra
y almacena en una especie de gran cinta virtual,
que contiene todas tus adiciones y modificaciones.
Es como el Gran Hermano, solo que es para Pharo.
Puedes divertirte con él y utilizarlo para reproducir ciertas secuencias.
Es una cinta
que contiene copias de seguridad de cada acción que modifica Pharo.
Lo que sucede es que, un archivo de cambios está asociado a un archivo de imagen.
¿Cuál es el propósito de esto?
Cuando defines una nueva clase,
el código de la clase no se almacena en el archivo de imagen,
se almacena en el archivo de cambios.
Entonces si desasocias los dos, podrías perder tu código
El programa seguirá ejecutándose,
pero puedes perder el código fuente de tu aplicación.
Si miramos de cerca,
tenemos un archivo de imagen que contiene
mi bytecode y los objetos compilados en forma binaria,
y al lado, un archivo de cambios que contiene una lista de cambios.
Por ejemplo, aquí agregué "counter", increase y decrease.
Del mismo modo con otras clases.
Y tenemos herramientas que te permiten reproducir estos cambios.
En Pharo, puedes navegar por varias versiones de los métodos.
Las herramientas que usan diferentes versiones de los métodos usan el archivo .changes.
Dibujé una línea de puntos alrededor de esta pareja. porque es muy importante
que los .changes y .image permanezcan sincronizados.
No empieces a editar el texto con Emacs dentro del archivo de cambios.
Puedes hacerlo, pero no tiene ningún interés real.
Solo romperás tu archivo .change.
El archivo de imagen continuará ejecutándose
porque solo usa .change para mostrar datos en el modo de programación.
Pero no lo aconsejo.
Generalmente hablando,
las imágenes son útiles para desarrollar.
Estas trabajando y alguien te interrumpe.
Guardas tu imagen y tomas un descanso.
Cuando vuelvas, estás exactamente en la misma situación.
El estado completo de su sistema se almacena en el disco.
Puedes volver 3 años después
y encontrar exactamente el mismo estado que hace 3 años.
Pero para un ingeniero de software, no es una buena práctica.
Está bien para el desarrollo. y prototipos.
Por favor use un sistema de control de versiones.
Tenemos Monticello,
un sistema de control de versiones escrito en Pharo,
y tenemos un backend para Git.
Guarda tu código en un sistema de control de versiones,
y luego usa integración continua con Jenkins o Travis
para construir tus imágenes.
La gente a menudo confunde estas dos cosas en Pharo.
Las imágenes son extremadamente prácticas para desarrollo.
Pero cuando quieras
desarrollo más estructurado y mayor control,
debes usar absolutamente herramientas clásicas.
Funcionan bien.
Hay un modo prototipo,
pero en algún momento debes guardar en un sistema de control de versiones,
entonces puedes acceder a todas las versiones en tu ambiente.
Hay videos que explican la clase Counter, por ejemplo.
Hay un tercer archivo del que no he hablado todavía.
Es el archivo de fuentes.
Un archivo de fuentes es un tipo de archivo de con cambios específicos.
Contiene todas las definiciones textuales del sistema en .0.
Para cada nueva versión de Pharo, hay un nuevo archivo .sources,
y este archivo .sources contendrá definiciones para Array, Set, etc.
Todos los métodos que se definen
en las bibliotecas centrales de Pharo.
Generalmente hablando, querrá compartir este archivo fuente
y estará solo en lectura.
Los archivos de cambios están en modo escritura y hay uno por imagen.
Vamos a ver.
Esta es una instantánea del estado del sistema.
al inicio de la nueva versión de Pharo 4.0,
que correspondía a este universo.
Luego definimos nuevas clases. Definí la clase Node.
Creé nuevos objetos en forma binaria,
y en el archivo de cambios asociado con mi imagen,
agregué mis nuevas definiciones, que se escriben aquí.
Como dije, este archivo está en modo de solo lectura.
Y esta está en modo de escritura.
Una vez más podemos decir eso, conceptualmente hablando
la imagen y los archivos de cambios funcionan juntas.
Espero que esto haya aclarado los roles de estos 3 archivos.
Lo que necesitas saber es que estamos armando
un nuevo sistema de gestión de cambios
para que puedas recuperar tus archivos más fácilmente
o reproducir varias versiones de tu sistema.
En el futuro, habrá una mejor integración con Git,
y ofreceremos nuevas formas para producir imágenes industrialmente.