[pt] Linguagens de programação tem tradicionalmente sido classificadas como estaticamente tipadas ou dinamicamente tipadas, estas últimas também sendo conhecidas como linguagens de scripting. Linguagens com tipagem dinâmica são bastante populares para a escrita de programas menores, um cenário onde a facilidade de uso e flexibilidade da linguagem são altamente valorizados. No entanto, com o passar do tempo, pequenos scripts podem se tornar grandes sistemas e a flexibilidade da linguagem pode passar a ser uma fonte de defeitos no programa. Para estes sistemas maiores, a tipagem estática, que oferece detecção de erros em tempo de compilação, melhor documentação e oportunidades de otimização, passa a ser mais atrativa. Como reescrever todo o sistema em uma linguagem estática não é ideal do ponto de um vista da engenharia de software, encontrar formas de adicionar tipos estáticos em programas dinamicamente tipados já existentes tem sido uma área de pesquisa bem rica. Nesse trabalho, nós apresentamos uma perspectiva histórica dessa pesquisa. Nos focamos em abordagens que não são específicas para uma única linguagem de programação, como as Type Hints de Common LISP, o Soft Typing de Fagan et al e o Gradual Typing de Siek et al, contrastando essas diferentes soluções a partir de uma perspectiva moderna. / [en] Programming languages have traditionally been classified as either statically typed or dynamically typed, the latter often being known as scripting languages. Dynamically typed languages are very popular for writing smaller programs, a setting where ease of use and flexibility of the language are highly valued. However, with time, small scripts tend to evolve into large systems and the flexibility of the dynamic language may become a source of program defects. For these larger systems, static typing, which offers compile-time error detection, improved documentation and optimization opportunities, becomes more attractive. Since rewriting the whole system in a statically typed language is not ideal from a software engineering point of view, investigating ways of adding static types to existing dynamically typed programs has been a thriving research area. In this work, we present a historical overview of this research. We focus on general approaches that apply to multiple programming languages, such as the Type Hints of Common LISP, the Soft Typing of Fagan et al and the Gradual Typing of Siek et al, contrasting these different solutions from a modern perspective.

[pt] Linguagens dinamicamente tipadas, tais como Lua, não usam tipos estáticos em favor de simplicidade e exibilidade, porque a ausência de tipos estáticos significa que programadores não precisam se preocupar em abstrair tipos que devem ser validados por um verificador de tipos. Por outro lado, linguagens estaticamente tipadas ajudam na detecção prévia de diversos bugs e também ajudam na estruturação de programas grandes. Tais pontos geralmente são vistos como duas vantagens que levam programadores a migrar de uma linguagem dinamicamente tipada para uma linguagem estaticamente tipada, quando os pequenos scripts deles evoluem para programas complexos. Sistemas de tipos opcionais nos permitem combinar tipagem dinâmica e estática na mesma linguagem, sem afetar a semântica original da linguagem, tornando mais fácil a evolução de código tipado dinamicamente para código tipado estaticamente. Desenvolver um sistema de tipos opcional para uma linguagem dinamicamente tipada é uma tarefa desafiadora, pois ele deve ser o mais natural possível para os programadores que já estão familiarizados com essa linguagem. Neste trabalho nós apresentamos e formalizamos Typed Lua, um sistema de tipos opcional para Lua, o qual introduz novas características para tipar estaticamente alguns idiomas e características de Lua. Embora Lua compartilhe várias características com outras linguagens dinamicamente tipadas, em particular JavaScript, Lua também possui várias características não usuais, as quais não estão presentes nos sistemas de tipos dessas linguagens. Essas características incluem funções com aridade flexível, atribuições múltiplas, funções que são sobrecarregadas no número de valores de retorno e a evolução incremental de registros e objetos. Nós discutimos como Typed Lua tipa estaticamente essas características e também discutimos nossas decisões de projeto. Finalmente, apresentamos uma avaliação de resultados, a qual obtivemos ao usar Typed Lua para tipar código Lua existente. / [en] Dynamically typed languages such as Lua avoid static types in favor of simplicity and exibility, because the absence of static types means that programmers do not need to bother with abstracting types that should be validated by a type checker. In contrast, statically typed languages provide the early detection of many bugs, and a better framework for structuring large programs. These are two advantages of static typing that may lead programmers to migrate from a dynamically typed to a statically typed language, when their simple scripts evolve into complex programs. Optional type systems allow combining dynamic and static typing in the same language, without affecting its original semantics, making easier this code evolution from dynamic to static typing. Designing an optional type system for a dynamically typed language is challenging, as it should feel natural to programmers that are already familiar with this language. In this work we present and formalize the design of Typed Lua, an optional type system for Lua that introduces novel features to statically type check some Lua idioms and features. Even though Lua shares several characteristics with other dynamically typed languages such as JavaScript, Lua also has several unusual features that are not present in the type system of these languages. These features include functions with exible arity, multiple assignment, functions that are overloaded on the number of return values, and the incremental evolution of record and object types. We discuss how Typed Lua handles these features and our design decisions. Finally, we present the evaluation results that we achieved while using Typed Lua to type existing Lua code.