A cidade e o rio: origem e evolução da frente ribeirinha de Lisboa

Em Lisboa, ao longo dos séculos, o homem foi conquistando as águas do Tejo. Hoje, após os diversos aterros, a frente ribeirinha da cidade é uma consolidada faixa de terreno, rematada por muros que, contra a «ondulação» do Tejo, definem uma expandida área que acolhe uma intensa actividade portuária. Foi nesta faixa junto do rio que se desenrolou parte importante da história de Lisboa, desde as ocupações romana e muçulmana, e também muito particularmente aquando do período dos Descobrimentos, da reconstrução pombalina pós-terramoto e do surto industrial do século XIX. Alguns destes momentos históricos encontram-se reflectidos nas inúmeras plantas, cartas e mapas disponíveis neste estudo, desde a Planta da Cidade de Lisboa : 1650, de João Nunes Tinoco, até ao Plano de Melhoramentos do Porto de Lisboa, de 1946. É com base nessas plantas, mas também em cartas manuscritas, relatos de época, gravuras e fotografias antigas – documentos em grande parte inéditos –, que este trabalho de investigação propõe cartografar este território, realizando desenhos originais que possibilitam um novo olhar sobre o seu processo de crescimento e consolidação. Assim, este estudo concilia todos estes elementos, constituindo uma análise completa que se debruça sobre a evolução da frente ribeirinha de Lisboa e que permite descobrir inúmeros aspectos até aqui desconhecidos, ajudando a responder à pergunta que hoje se coloca: perante o cenário que o porto actual atravessa, como melhor poderá Lisboa recuperar a relação com o rio?; THE CITY AND THE RIVER: ORIGIN AND EVOLUTION OF LISBON'S RIVERFRONT ABSTRACT: In Lisbon, over the centuries, man was conquering the waters of the Tagus. Today, after the various landfills, the city's riverfront is a consolidated strip of land, finished by walls that, against the "ripple" of the Tagus, define an expanded area that hosts an intense port activity. It was in this band along the river that unfolded important part of the history of Lisbon, from the Roman and Muslim occupations, and also very particularly during the period of the Discoveries, the post-earthquake reconstruction, and the industrial boom of the nineteenth century. Some of these historical moments are reflected in many plans, charts and maps available in this study, since the plan designated Planta da Cidade de Lisboa : 1650, made by João Nunes Tinoco, to the plan called Plano de Melhoramentos do Porto de Lisboa, drawn in the year of 1946. Based on these plans, but also in handwritten letters, time reports, antique prints and photographs – documents that are mostly unpublished – this research work proposes map this territory, performing original drawings that provide a new look at their growth process and consolidation. Thereby, this study combines all these elements, providing a complete analysis which focuses on the evolution of the Lisbon riverfront and that allows you to discover many aspects unknown until now, helping to answer the question that now arises: according to the present scenario that the harbour is going through, how can Lisbon recover the relationship with the river

Constructing program animations using a pattern-based approach

The aim of this paper is to discuss how our pattern-based strategy for the visualization of data and control flow can effectively be used to animate the program and exhibit its behavior. That result allows us to propose its use for Program Comprehension. The animator uses well known compiler techniques to inspect the source code in order to extract the necessary information to visualize it and understand program execution. We convert the source program into an internal decorated (or attributed) abstract syntax tree and then we visualize the structure by traversing it, and applying visualization rules at each node according to a pre-defined rule-base. In order to calculate the next step in the program execution, a set of rewriting rules are applied to the tree. The visualization of this new tree is shown and the program animation is constructed using an iterative process. No changes are made in the source code, and the execution is simulated step by step. Several examples of visualization are shown to illustrate the approach and support our idea of applying it in the context of a Program Comprehension environment.FC

Exploring and visualizing the ”Alma” of XML documents

In this paper we introduce eXVisXML, a visual tool to explore documents annotated with the mark-up language XML, in order to easily perform over them tasks as knowledge extraction or document engineering. eXVisXML was designed mainly for two kind of users. Those who want to analyze an annotated document to explore the information contained, for them a visual inspection tool can be of great help, and a slicing functionality can be an efective complement. The other target group is composed by document engineers who might be interested in assessing the quality of the annotation created. This can be achieved through the measurements of some parameters that will allow to compare the elements and attributes of the DTD/Schema against those efectively used in the document instances. Both functionalities and the way they were delineated and implemented will be discussed along the paper.FC

ALMA versus DDD

To be a debugger is a good thing! Since the very beginning of the programming activity, debuggers are the most important and widely used tools after editors and compilers; we completely recognize their importance for software development and testing. Debuggers work at machine level, after the compilation of the source program; they deal with assembly, or binary-code, and are mainly data structure inspectors. Alma is a program animator based on its abstract representation. The main idea is to show the algorithm being implemented by the program, independently from the language used to implement it. To say that ALMA is a debugger, with no value added, is not true! ALMA is a source code inspector but it deals with programming concepts instead of machine code. This makes possible to understand the source program at a conceptual level, and not only to fix run time errors. In this paper we compare our visualizer/animator system, ALMA, with one of the most well-known and used debuggers, the graphical version of GDB, the DDD program. The aim of the paper is twofold: the immediate objective is to prove that ALMA provides new features that are not usually offered by debuggers; the main contribution is to recall the concepts of debugger and animator, and clarify the role of both tools in the field of program understanding, or program comprehension.FC

Pattern-based program visualization

The aim of this paper is to discuss how our pattern-based strategy for the visualization of data and control flow can effectively be used to animate the program and exhibit its behavior. That result allows us to propose its use for Program Comprehension. The animator uses well known compiler techniques to inspect the source code in order to extract the necessary information to visualize it and understand program execution. We convert the source program into an internal decorated (or attributed) abstract syntax tree and then we visualize the structure by traversing it, and applying visualization rules at each node according to a pre-defined rule-base. No changes are made in the source code, and the execution is simulated. Several examples of visualization are shown to illustrate the approach and support our idea of applying it in the context of a Program Comprehension environment.FC

How to interconnect operational and behavioral views of web applications

In the context of our research project, we are looking for program comprehension tools that are able to interconnect operational and behavioral views, aiming at aiding the programmer to relate problem and program domains to reach a full understanding of software systems. In particular we have been studying the adaptation of that principle to web applications. In this context, we had designed and implemented a tool called WebAppViewer. In this paper, we emphasize the development of the module (BORS) that is responsible for providing interconnection functionalities and we propose a tool demonstration. A dedicated web server is included in the system to allow the execution of the piece of code selected by the user. This feature is used to relate the source text (html, php, etc) executed by the server, with the web page received by the client. Code instrumentation is used to collect dynamic information.FC

VisualLISA: a domain specific visual language for attribute grammars

The focus of this paper is on the translation of AG formalisms into a new visual language, and on the development of the associated programming environment. We present a solution for rapid development of VisualLISA editor using DEViL . This tool uses traditional attribute grammars, to specify the language’s syntax and semantics, extended by visual representations to be associated with grammar symbols. From these specifications a visual programming environment is automatically generated. This environment allows us to edit a visual description of an AG that is automatically translated into textual notations. In this paper, we emphasize the design and implementation of VisualLISA that is intended to be helpful for beginners and rapid development of small AG s.CCTC - Universidade do Minh

VisualLISA: visual programming environment for attribute grammars

The benefits of using visual languages and graphical editors are well known. In some specific domain it is really crucial to program with graphical representations, icons, geometric objects, colors and so on. Nowadays it is possible to easily implement a visual language, constructing, automatically, visual editors for it. In this paper we want to emphasize how it is possible to easily specify a huge amount of complex information, associated with an attribute grammar, using graphical objects and a very intuitive modular approach. For that purpose we present a new visual language to specify attribute grammars (called VisualLISA) and we present also a modular approach that uses VisualLISA in an integrated editor to draw attribute grammars.GRICES - FC

Strategies for program inspection and visualization

The aim of this paper is to show the strategies involved in the implementation of two tools of PCVIA project that can be used for Program Comprehension. Both tools use known compiler techniques to inspect code in order to visualize and understand programs’ execution. On one hand we convert the source program into an internal decorated (or attributed) abstract syntax tree and then we visualize the structure traversing it, and applying visualization rules at each node according to a pre-defined rule-base. No changes are made in the source code, and the execution is simulated. On the other hand, we traverse the source program and instrument it with inspection functions. Those inspectors provide information about the function-call flow and data usage at runtime (during the actual program execution). This information is collected and gathered in an information repository that is then displayed in a suitable form for navigation. These two different approaches are used respectively by Alma (generic program animation system) and Cear (C Rooting Algorithm Visualization tool). For each tool several examples of visualization are shown in order to discuss the information that is included in the visualizations, visualization types and the use of Program Animation for Program Comprehension.FC

VisualLISA: a visual interface for an attribute grammar based compiler-compiler

The research work that we discuss in this position paper, is concerned with the implementation of a visual front-end for LISA tool in order to make easier and more attractive the work of writing an attribute grammar for a new language. LISA (Language Implementation System based on Attribute grammars) is a compiler-compiler, or a system that generates automatically a compiler/interpreter from a formal language specification based on attribute grammars. The main idea is to design a visual language to draw derivation rules in conjunction with the associated semantic rules and to develop a visual compiler to transform that graphical representation into LISA notation