Home-grown CASE tools with XML and XSLT

This paper demonstrates an approach to software generation where xml representations of models are transformed to implementations by XSLT style sheets. Although XSLT was not primarily intended for this use, it serves quite well. There are only few problems in this approach, and we identify these based on our examples

Detecting and parsing embedded lightweight structures

Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2005.Includes bibliographical references (p. 71-72).Text documents, web pages, and source code are all documents that contain language structures that can be parsed with corresponding parsers. Some documents, like JSP pages, Java tutorial pages, and Java source code, often have language structures that are nested within another language structure. Although parsers exist exclusively for the outer and inner language structure, neither is suited for parsing the embedded structures in the context of the document. This thesis presents a new technique for selectively applying existing parsers on intelligently transformed document content. The task of parsing these embedded structures can be broken up into two phases: detection of embedded structures and parsing of those embedded structures. In order to detect embedded structures, we take advantage of the fact that there are natural boundaries in any given language in which these embedded structures can appear. We use these natural boundaries to narrow our search space for embedded structures. We further reduce the search space by using statistical analysis of token frequency for different language types. By combining the use of natural boundaries and the use of token frequency analysis, we can, for any given document, generate a set of regions that have a high probability of being an embedded structure.(cont.) To parse the embedded structures, the text of the region must often be transformed into a form that is readable by the intended parser. Our approach provides a systematic way to transform the document content into a form that is appropriate for the embedded structure parser using simple replacement rules. Using our knowledge of natural boundaries and statistical analysis of token frequency, we are able to locate regions of embedded structures. Combined with replacement rules which transform document content into a parsable form, we are successfully able to parse a range of documents with embedded structures using existing parsers.by Philip Rha.M.Eng

SWI-Prolog and the Web

Where Prolog is commonly seen as a component in a Web application that is either embedded or communicates using a proprietary protocol, we propose an architecture where Prolog communicates to other components in a Web application using the standard HTTP protocol. By avoiding embedding in external Web servers development and deployment become much easier. To support this architecture, in addition to the transfer protocol, we must also support parsing, representing and generating the key Web document types such as HTML, XML and RDF. This paper motivates the design decisions in the libraries and extensions to Prolog for handling Web documents and protocols. The design has been guided by the requirement to handle large documents efficiently. The described libraries support a wide range of Web applications ranging from HTML and XML documents to Semantic Web RDF processing. To appear in Theory and Practice of Logic Programming (TPLP)Comment: 31 pages, 24 figures and 2 tables. To appear in Theory and Practice of Logic Programming (TPLP

Development of an Automated Migration Strategy from JSP to JSF

Trabajo de Fin de Máster en Máster en Ingeniería Informática, Facultad de Informática UCM, Departamento de Sistemas Informáticos y Computación, Curso 2019/2020. El código se puede encontrar en: https://github.com/sanbefo/jsp-to-jsfAl desarrollar una aplicación web es muy conveniente usar un framework, ya que reduce el tiempo para implementar nuevas funcionalidades. Un desarrollo web puede llegar a involucrar muchas tecnologías, y un framework puede ayudar a reducir el conocimiento necesario al facilitar la integración de todas esas tecnologías para que funcionen bien juntas. JSP (JavaServer Pages) está desarrollado principalmente para crear páginas web dinámicas para pequeñas aplicaciones. Sin embargo, es muy difícil usarlo para aplicaciones a gran escala, ya que JSP es muy flexible, por lo que permite poner lógica correspondiente al modelo de negocio o a un controlador en la vista. Esto provoca que cuanto más crece una aplicación web desarrollada en JSP, más difícil es mantenerla. Por otro lado, JSF (JavaServer Faces) es un sistema basado en componentes que es muy útil para proyectos a gran escala. Este framework utiliza la arquitectura MVC (Modelo, Vista, Controlador) y, por lo tanto, incluso las interfaces de usuario y sus componentes son reutilizables en una página web en particular. La principal diferencia entre JSP y JSF radica en la forma en que operan. En JSP, un componente tiene un impacto mínimo en otro componente y la comunicación entre componentes depende del programador y no de un framework. Por lo tanto, es posible crear vistas sin tener que escribir el modelo, por lo que la aplicación puede ser más flexible. Pero cuando se trata de aplicaciones web complejas, es difícil mantener la estructura del desarrollo a diferencia de cuando se desarrollan aplicaciones más pequeñas. Puede haber duplicación de código, la estructura puede complicarse y el mantenimiento suele ser difícil. Es por eso que las grandes empresas evitan JSP para aplicaciones grandes ya que podría haber muchos errores aun después de la integración. Por otro lado, JSF se puede dividir en seis fases de desarrollo (restaurar vista, aplicar valores de solicitud, validación del proceso, actualizar los valores del modelo, solicitud de invocación, respuesta de procesamiento) que le dan una estructura rígida al framework. La integración de componentes es perfecta ya que es una tecnología basada en componentes y diseñada para aplicaciones a gran escala. El código se puede encontrar en: https://github.com/sanbefo/jsp-to-jsfIn migrating a web development project the best thing to use is a framework, because it reduces the time for implementing new functionalities. A web development project includes many technologies. A framework can help reduce the knowledge needed by making it easier to integrate all those technologies so they work well together. JSP (JavaServer Pages) is primarily developed to create dynamic web pages for small applications. However, it is very di cult to use it for large-scale applications, since JSP is very flexible, allowing it to put logic corresponding to the business model or a controller in view. This means that the more a web application developed in JSP grows, the more dificult it is to maintain it. On the other hand, JSF (JavaServer Faces) is a component-based system that is very useful for large-scale projects. This framework uses the MVC (Model, View, Controller) architecture and therefore even user interfaces and their components are reusable on a particular web page. The main difeerence between JSP and JSF lies in the way they operate. In JSP, one component has minimal impact on the other component. Therefore, it is possible to créate views without having to write the model, so the application can be more flexible. But, when it comes to complex web applications, it is di cult to maintain the structure while developing small-scale applications. There can be code duplication, the structure can become a mess and maintenance can be di cult. That is why big companies avoid JSP for large-scale applications and there could be a lot of bugs and errors after integration. On the other hand, JSF can be divided into six phases of development (Restore View, Apply Request Values, Process Validation, Update Model Values, Invoke Application, Render Response) that allow the framework to grow smoothly. The integration of components is seamless as it is a component-based technology and designed for large-scale applications. The code can be found in: https://github.com/sanbefo/jsp-to-jsfDepto. de Sistemas Informáticos y ComputaciónFac. de InformáticaTRUEunpu

Estudio de la herramienta de desarrollo JASPERREPORTS en aplicaciones web con tecnología JSP

Sistema de administración y control de recursos tecnológicos para la Cooperativa de Ahorro y Crédito Atuntaqui Ltda.El presente trabajo de investigación se fundamenta en el uso de la herramienta de desarrollo JasperReports para la generación de documentos listos para imprimir desde nuestras aplicaciones de escritorio o portales web; mismos que permitirán disponer de información clara, precisa y oportuna, necesaria para el cumplimiento de nuestras tareas cotidianas, como la planificación de actividades, la toma de decisiones, generación de informes, entre otras. La implementación de un sistema informático en la Cooperativa de Ahorro y Crédito "Atuntaqui" Ltda., simplificó notablemente el proceso de administración y control de los recursos tecnológicos con la automatización de tareas repetitivas y registro de manera organizada de todas las actividades. Además, con la puesta en marcha del sistema en la Cooperativa de Ahorro y Crédito Atuntaqui Ltda., se dispone de información eficiente, precisa, clara y oportuna de los recursos tecnológicos existentes y de sus respectivas modificaciones y adaptaciones

Block-scoped access restriction technique for HTML content in web browsers

Web sites, web browsers, web site authors, web component authors, and end users interact in a complicated environment with many recognized and unrecognized trust relationships. The web browser is the arena in which many important trust relationships interact, thus it bears a considerable burden in protecting the interests and security of web end users as well as web site authors. Existing proposals, draft standards, implemented features, and web application techniques go a long way towards allowing rich and compelling content interactions, but they do not provide for rich, mutually-distrusting content to be safely embedded in a single page. This proposal suggests a declarative policy mechanism that permits untrusted content to be safely embedded in a web site while still retaining some richness. It also suggests a policy integration approach to allow multiple cooperative (but not necessarily trusting) parties to provide components of a policy that combine together in a safe manner. It incorporates techniques including fine-grained and coarse-grained permission dropping and white-listing protections for retained capabilities. Finally, the proposed concepts are applied to a number of real-world CVE vulnerabilities, and it is explained how the proposal does or does not prevent or mitigate the attack. The solution is shown to be effective against cross-style-scripting style attacks, and to not be effective at preventing incoming cross-site request forgery attacks

General Interface Description of Websites using CLICK and UIML

This paper explores the domain of programming paradigm for Multi-Platform User Interfaces using XML based languages. The main focus of this work is User Interface Markup Language (UIML), an XML based language for describing user interfaces in a platform-independent manner. We have explored the capabilities of UIML as an interface description language for describing interactive websites. We have selected an end-user web programming tool called CLICK, which also uses an XML based interface description for the websites created through it. We have analyzed both the representations and devised a conversion process from CLICK XML to UIML. We have found that UIML is expressive enough to represent applications built using CLICK. UIML provides various benefits over the interface description generated by CLICK especially that of facilitating the development of web based interfaces for multiple platforms through CLICK

Automatic generation of descriptions for Prolog programs

It is often hard for students and newcomers used to imperative languages to learn a declarative language such as Prolog. One of their main difficulties is understanding the procedural component of Prolog. Despite being a declarative language, Prolog allows for the creation of procedures whose structure is very different from the more common imperative languages. To tackle this issue, we try to facilitate code comprehension of procedural Prolog through the generation of formal and natural descriptions. First, we represent the workflow of Prolog encoded procedures through formal descriptions similar to imperative languages. To do this, we identify programming patterns that represent the basic blocks of certain classes of Prolog programs. Then we view more complex Prolog programs as coherent compositions of instances of the basic patterns. By using formal templates, we formally describe these individual patterns into an intermediate formal language. Afterwards, we generate natural language descriptions by using templates to describe the formal constructs. Using this two-step approach, we obtain two descriptions (one formal and one in natural language) that are both explanatory of the original program.Normalmente é difícil para alunos e iniciantes que estão habituados a linguagens imperativas, aprender uma linguagem declarativa como o Prolog. Uma das suas principais dificuldades é entender a componente procedimental do Prolog. Apesar de ser uma linguagem declarativa, o Prolog permite a criação de procedimentos cuja estrutura é bastante diferente da usada nas linguagens imperativas. Para abordar este problema tentámos facilitar a compreensão de código do Prolog procedimental através da geração de descrições formais e em linguagem natural. Primeiro, representamos a lógica dos procedimentos em Prolog através de descrições formais similares a linguagens imperativas. Para isto, identificamos os padrões que representam os blocos básicos de certas classes de programas. Depois, consideramos os programas mais complexos como composições destes padrões básicos. Através da utilização de templates formais, descrevemos formalmente estes padrões individuais numa linguagem formal intermédia. Seguidamente, geramos descrições em linguagem natural utilizando templates para descrever os construtos formais. Ao usar esta abordagem de dois passos obtemos duas descrições (uma formal e uma em linguagem natural) que são ambas explanatórias do programa original