Slides de la charla dada en la PyConAr

1. Live Typing
Anotación automática de tipos para lenguajes
dinámicos
Hernán A. Wilkinson - @hernanwilkinson
Fundador de 10Pines, FAST y Profesor@FCENyN, UBA
agile software development & services

2. ¿Por qué les gusta Python?

3. (entre otras características)
Es Dinámicamente Tipado
¡lo cual tiene muchas ventajas!

4. Pero también sabemos que …
tiene algunas desventajas

5. Hay “información que falta”,
que no es explícita

6. Esa información que falta es
Información de Tipos

7. Como programadores, temenos que
recordar e inferir esa información
Eso nos saca tiempo & energía

8. ¿Por qué no tomamos ese
tiempo & energía
de la computadora?

9. Dicho de Bret Victor – Inventing on a Principle
‘estamos acostumbrados a jugar a ser
computadoras’
http://worrydream.com/#!/InventingOnPrinciple

10. Dicho de programador de lenguajes dinámicos:
‘estamos acostumbrados a jugar
juegos de memoria de tipos’

11. Soluciones

12. Inferencia de Tipos

13. Inferencia de Tipos
1980 1981

14. Desventajas
•Lento
•Incompleto
•Información Incorrecta en algunos casos

15. Anotación Manual de Tipos
1982!!

16. Anotación Manual de Tipos
Strongtalk
1994

17. Anotación Manual de Tipos
TypeScript
~ 2012/2014

18. Anotación Manual de Tipos
Python 2.7 -
Type Comments
~ 2014

19. Anotación Manual de Tipos
Python 3.5 - Type Hints

20. Anotación Manual de Tipos
Ruby with Sorbet ~ 2018

21. Desventajas
•Modifican la sintaxis del lenguaje
•Dificulta la lectura del Código
• Ya no es como antes …
•Hay que hacerlo a mano
•Hay que mantenerlo!
•Se centran en chequeo de tipos aunque de manera
gradual y no se llevan bien con “Duck Typing”

22. ¿Qué es LiveTyping?

23. Anotación automática de tipos (hecho por la VM)
+
Herramientas que mejoran la experiencia del
programador
(La anotación sucede mientras el Sistema ejecuta)
LiveTyping

24. Características
•No cambia la sintaxis
•Los tipos no están en el código fuente
•No dificulta la lectura del código
•No te impide compilar o ejecutar
•No te fuerza a usarlo

25. No es una nueva idea…

26. Since 1981!
1970!!

28. No es una nueva idea pero…
Es un idea particular con una
implementación que
funciona

29. LiveTyping no tiene como
objetivo principal realizar
chequeo de tipos

30. LiveTyping tiene como objetivo
facilitar el desarrollo con
lenguajes dinámicos

31. ¿Cómo funciona?

32. TypesArray
• TypesArray: Array con los tipos (clases) de una variable
• Cada variable/parámetro/retorno de método es asociado
con un TypesArray
• Cada vez que un objeto es asignado a una variable, la VM
agrega la clase del objeto al TypesArray de esa variable
• Size de TypesArray puede variar por variable. Default es 10
• Si TypesArray es nil significa que no se anotan tipos para
esa variable

33. VM: Agregar un Tipo al TypesArray
(pseudo C)
keepTypeInformation(typesArray, assignedObject) {
if (typesArray==nil) return;
assignedObjectClass = objectMemory.classOf(assignedObject);
typesArraySize = objectMemory.lengthOf(typesArray);
for (index=0;index++;index<typesArraySize) {
if (typesArray[index]==assignedObjectClass) return;
if (typesArray[index]==nil) {
typesArray[index] = assginedObjectClass;
return; }}}

34. Ejemplos

35. Cuis Smalltalk &
CuisUniversity

36. TaTeTi
(TicTacToe)

37. Mostrando y Administrando
Types

38. Muy útil para “legacy code” o mal escrito
(Morph)

39. Autocompletion

40. DynamicType
(SelfType, ClassType, InstanceType)

41. Actual Implementors
(“a much better use of the human brain”-Tudor et al )

42. Actual Senders
Sure and Possible
(Per Message Send analysis)

43. Refactorings con Actual Scope

44. Type Checker
(we know for sure when nil is assigned!)

45. Morph & Behavior

46. Conclusión

47. Sin un gran esfuerzo,
nos deshicimos de la mayoría de
las desventajas

48. No temenos que mantener
lo tipos de la variables,
lo hace automáticamente

49. No temenos que recordar or inferir
los tipos nunca más!

50. Los tipos no molestan en la lectura
del Código

51. Es una técnica muy simple que
mejora drásticamente la
experiencia del programador

52. Creo humildemente que
respeta y honra
el espíritu de los lenguajes
dinámicos

53. ¿Cuál es mi objetivo?

54. Con Smalltalk, dejar de decir que es
‘Dynamically Typed’
y empezar a decir que es,
‘Lively Typed’

55. Que los otros lenguajes
dinámicamente tipados se suban al
tren

56. Estadísticas

57. Performance
Typed VM Stack VM Difference
Aconcagua Tests 37 ms 22 ms 1.6 x
Chalten Tests 2400 ms 2204 ms 1.08 x
Refactoring Tests 56382 ms 39650 ms 1.42 x
TicTacToe Tests 3 ms 2 ms 1.5 x
Some Kernel Tests 220 ms 151 ms 1.45 x
Average 1.41 x
No se nota un impacto cuando se está
programando

58. Memoria
Live Typing Image* Common Image Difference
22 MB 10 MB 2.2 x
(*) Configuración Default:
• Size de type arrays: 10
• Uso de variables de instancia: 8.8%
• Uso de variables de métodos: 8.4%
• Uso de tipos de retorno: 8.02%

59. Trabajo Futuro

60. En Desarrollo/Investigación
� Anotar tipos en variables de closures (Ines Sosa)
� Soporte de tipos parametrizados (Generics) (Ana Felisatti & Mariano
De Sousa)
� Implementarlo para la VM con JIT (Federico Grosso)
� Mejoras en el chequeo de tipos (Julián Mauro Luini)
Si les interesa el tema, para hacer investigación/ampliarlo
comuniquense conmigo!

61. Más ideas
 Agregar mas “type casts” al Type Checker
 Chequear tipos en parámetros (Freeze annotated types)
 Usar la infrastructura del TypeChecker para mejorar el autocomplete
 Importar información de tipos recolectada en producción al ambiente de
Desarrollo
 Mejorar el Type Checker para avisar de código muerto
 Que el Compilador, genere e inicialice PICs en tiempo de compilación!
 Mejorar análisis de dependencia

62. ¿Cómo obtenerlo?
 One Click - CuisUniversity: http://www.cuisuniversity.org/
 Repo: https://github.com/hernanwilkinson/LiveTyping

63. Soluciones Similares en Python
 pyannotate: https://github.com/dropbox/pyannotate
Colecta tipos ejecutando tests, solo para parámetros y tipos de retorno
Los guarda en un archivo
Modifica Código Fuente con la información guardada en el punto anterior
 MonkeyType: https://github.com/Instagram/MonkeyType
Solución parecida a LiveTyping pero con mayor impacto de performance (5x) y solo
para parámetros y tipos de retorno
Guarda tipos recolectados en base de datos
Modifica el Código Fuente con la información guardada

64. Herramientas de uso de tipos en Python
 Type Checkers
mypy: http://mypy-lang.org/
pytype: https://github.com/google/pytype
pyre: https://github.com/facebook/pyre-check
Evaluadores de conformidad de tipos en runtime
pytypes: https://github.com/Stewori/pytypes
pydantic: https://github.com/samuelcolvin/pydantic
enforce: https://github.com/RussBaz/enforce
Presentación interesante: https://www.youtube.com/watch?v=pMgmKJyWKn8

65. ¿Preguntas?

66. ¡Gracias!
@HernanWilkinson – hernan.wilkinson@10pines.com – www.10pines.com