2,193 research outputs found
Survey of Technologies for Web Application Development
Web-based application developers face a dizzying array of platforms,
languages, frameworks and technical artifacts to choose from. We survey,
classify, and compare technologies supporting Web application development. The
classification is based on (1) foundational technologies; (2)integration with
other information sources; and (3) dynamic content generation. We further
survey and classify software engineering techniques and tools that have been
adopted from traditional programming into Web programming. We conclude that,
although the infrastructure problems of the Web have largely been solved, the
cacophony of technologies for Web-based applications reflects the lack of a
solid model tailored for this domain.Comment: 43 page
1957-2007: 50 Years of Higher Order Programming Languages
Fifty years ago one of the greatest breakthroughs in computer programming and in the history of computers happened – the appearance of FORTRAN, the first higher-order programming language. From that time until now hundreds of programming languages were invented, different programming paradigms were defined, all with the main goal to make computer programming easier and closer to as many people as possible. Many battles were fought among scientists as well as among developers around concepts of programming, programming languages and paradigms. It can be said that programming paradigms and programming languages were very often a trigger for many changes and improvements in computer science as well as in computer industry. Definitely, computer programming is one of the cornerstones of computer science. Today there are many tools that give a help in the process of programming, but there is still a programming tasks that can be solved only manually. Therefore, programming is still one of the most creative parts of interaction with computers. Programmers should chose programming language in accordance to task they have to solve, but very often, they chose it in accordance to their personal preferences, their beliefs and many other subjective reasons. Nevertheless, the market of programming languages can be merciless to languages as history was merciless to some people, even whole nations. Programming languages and developers get born, live and die leaving more or less tracks and successors, and not always the best survives. The history of programming languages is closely connected to the history of computers and computer science itself. Every single thing from one of them has its reflexions onto the other. This paper gives a short overview of last fifty years of computer programming and computer programming languages, but also gives many ideas that influenced other aspects of computer science. Particularly, programming paradigms are described, their intentions and goals, as well as the most of the significant languages of all paradigms
Dynamically typed languages
Dynamically typed languages such as Python and Ruby have experienced a rapid grown in popularity in recent times. However, there is much confusion as to what makes these languages interesting relative to statically typed languages, and little knowledge of their rich history. In this chapter I explore the general topic of dynamically typed languages, how they differ from statically typed languages, their history, and their defining features
Out-Of-Place debugging: a debugging architecture to reduce debugging interference
Context. Recent studies show that developers spend most of their programming
time testing, verifying and debugging software. As applications become more and
more complex, developers demand more advanced debugging support to ease the
software development process.
Inquiry. Since the 70's many debugging solutions were introduced. Amongst
them, online debuggers provide a good insight on the conditions that led to a
bug, allowing inspection and interaction with the variables of the program.
However, most of the online debugging solutions introduce \textit{debugging
interference} to the execution of the program, i.e. pauses, latency, and
evaluation of code containing side-effects.
Approach. This paper investigates a novel debugging technique called
\outofplace debugging. The goal is to minimize the debugging interference
characteristic of online debugging while allowing online remote capabilities.
An \outofplace debugger transfers the program execution and application state
from the debugged application to the debugger application, both running in
different processes.
Knowledge. On the one hand, \outofplace debugging allows developers to debug
applications remotely, overcoming the need of physical access to the machine
where the debugged application is running. On the other hand, debugging happens
locally on the remote machine avoiding latency. That makes it suitable to be
deployed on a distributed system and handle the debugging of several processes
running in parallel.
Grounding. We implemented a concrete out-of-place debugger for the Pharo
Smalltalk programming language. We show that our approach is practical by
performing several benchmarks, comparing our approach with a classic remote
online debugger. We show that our prototype debugger outperforms by a 1000
times a traditional remote debugger in several scenarios. Moreover, we show
that the presence of our debugger does not impact the overall performance of an
application.
Importance. This work combines remote debugging with the debugging experience
of a local online debugger. Out-of-place debugging is the first online
debugging technique that can minimize debugging interference while debugging a
remote application. Yet, it still keeps the benefits of online debugging ( e.g.
step-by-step execution). This makes the technique suitable for modern
applications which are increasingly parallel, distributed and reactive to
streams of data from various sources like sensors, UI, network, etc
Energyware engineering: techniques and tools for green software development
Tese de Doutoramento em Informática (MAP-i)Energy consumption is nowadays one of the most important concerns worldwide. While
hardware is generally seen as the main culprit for a computer’s energy usage, software
too has a tremendous impact on the energy spent, as it can cancel the efficiency introduced
by the hardware. Green Computing is not a newfield of study, but the focus has been,
until recently, on hardware. While there has been advancements in Green Software techniques,
there is still not enough support for software developers so they can make their
code more energy-aware, with various studies arguing there is both a lack of knowledge
and lack of tools for energy-aware development.
This thesis intends to tackle these two problems and aims at further pushing
forward research on Green Software. This software energy consumption issue is faced
as a software engineering question. By using systematic, disciplined, and quantifiable
approaches to the development, operation, and maintenance of software we defined several
techniques, methodologies, and tools within this document. These focus on providing
software developers more knowledge and tools to help with energy-aware software
development, or Energyware Engineering.
Insights are provided on the energy influence of several stages performed during
a software’s development process. We look at the energy efficiency of various popular
programming languages, understanding which are the most appropriate if a developer’s
concern is energy consumption. A detailed study on the energy profiles of different
Java data structures is also presented, alongwith a technique and tool, further providing
more knowledge on what energy efficient alternatives a developer has to choose from. To
help developers with the lack of tools, we defined and implemented a technique to detect
energy inefficient fragments within the source code of a software system. This technique
and tool has been shown to help developers improve the energy efficiency of their programs,
and even outperforming a runtime profiler. Finally, answers are provided to common questions and misconceptions within
this field of research, such as the relationship between time and energy, and howone can
improve their software’s energy consumption.
This thesis provides a great effort to help support both research and education on
this topic, helps continue to grow green software out of its infancy, and contributes to
solving the lack of knowledge and tools which exist for Energyware Engineering.Hoje em dia o consumo energético é uma das maiores preocupações a nível global. Apesar
do hardware ser, de umaforma geral, o principal culpado para o consumo de energia
num computador, o software tem também um impacto significativo na energia consumida,
pois pode anular, em parte, a eficiência introduzida pelo hardware. Embora
Green Computing não seja uma área de investigação nova, o foco tem sido, até recentemente,
na componente de hardware. Embora as técnicas de Green Software tenham
vindo a evoluir, não há ainda suporte suficiente para que os programadores possam
produzir código com consciencialização energética. De facto existemvários estudos que
defendem que existe tanto uma falta de conhecimento como uma escassez de ferramentas
para o desenvolvimento energeticamente consciente.
Esta tese pretende abordar estes dois problemas e tem como foco promover avanços
em green software. O tópico do consumo de energia é abordado duma perspectiva
de engenharia de software. Através do uso de abordagens sistemáticas, disciplinadas
e quantificáveis no processo de desenvolvimento, operação e manutencão de software,
foi possível a definição de novas metodologias e ferramentas, apresentadas neste documento.
Estas ferramentas e metodologias têm como foco dotar de conhecimento e
ferramentas os programadores de software, de modo a suportar um desenvolvimento
energeticamente consciente, ou Energyware Engineering.
Deste trabalho resulta a compreensão sobre a influência energética a ser usada
durante as diferentes fases do processo de desenvolvimento de software. Observamos as
linguagens de programação mais populares sobre um ponto de vista de eficiência energética,
percebendo quais as mais apropriadas caso o programador tenha uma preocupação
com o consumo energético. Apresentamos também um estudo detalhado sobre perfis energéticos de diferentes
estruturas de dados em Java, acompanhado por técnicas e ferramentas, fornecendo
conhecimento relativo a quais as alternativas energeticamente eficientes que os programadores
dispõem. Por forma a ajudar os programadores, definimos e implementamos
uma técnica para detetar fragmentos energicamente ineficientes dentro do código fonte
de um sistema de software. Esta técnica e ferramenta têm demonstrado ajudar programadores
a melhorarem a eficiência energética dos seus programas e em algum casos
superando um runtime profiler.
Por fim, são dadas respostas a questões e conceções erradamente formuladas dentro
desta área de investigação, tais como o relacionamento entre tempo e energia e como
é possível melhorar o consumo de energia do software.
Foi empregue nesta tese um esforço árduo de suporte tanto na investigação como
na educação relativo a este tópico, ajudando à maturação e crescimento de green computing,
contribuindo para a resolução da lacuna de conhecimento e ferramentas para
suporte a Energyware Engineering.This work is partially funded by FCT – Foundation for Science and Technology, the
Portuguese Ministry of Science, Technology and Higher Education, through national funds,
and co-financed by the European Social Fund (ESF) through the Operacional Programme for
Human Capital (POCH), with scholarship reference SFRH/BD/112733/2015. Additionally,
funding was also provided the ERDF – European Regional Development Fund – through
the Operational Programmes for Competitiveness and Internationalisation COMPETE and
COMPETE 2020, and by the Portuguese Government through FCT project Green Software
Lab (ref. POCI-01-0145-FEDER-016718), by the project GreenSSCM - Green Software for
Space Missions Control, a project financed by the Innovation Agency, SA, Northern Regional
Operational Programme, Financial Incentive Grant Agreement under the Incentive Research
and Development System, Project No. 38973, and by the Luso-American Foundation in
collaboration with the National Science Foundation with grant FLAD/NSF ref. 300/2015 and
ref. 275/2016
Developing a requirements management toolset: Lessons learned
Requirements Engineering (RE) is a multi-faceted discipline involving various methods, techniques and tools. RE researchers and practitioners are emphasizing the importance of having an integrated RE process. The need for an integrated toolset to support the effective management of such an integrated RE process cannot be over-emphasized. Tools integration has been identified as an important next step toward the future of requirements management tools. This paper reports on some of the significant architectural and technical issues encountered and the lessons learned in the process of developing an integrated Requirements Management (RM) Toolset: PARsed Natural language Input Processor (PARSNIP) by integrating various independent tools. This paper provides insights on architectural and technological issues typical of these types of projects, the approaches and techniques used to address the architectural mismatches and the technological incompatibilities
- …