Scripting Language

NAMD is a parallel molecular dynamics code designed for high-performance simulation of large biomolecular systems. NAMD scales to hundreds of processors on high-end parallel platforms, as well as tens of processors on low-cost commodity clusters, and also runs on individual desktop and laptop computers. NAMD works with AMBER and CHARMM potential functions, parameters, and file formats. This article, directed to novices as well as experts, first introduces concepts and methods used in the NAMD program, describing the classical molecular dynamics force field, equations of motion, and integration methods along with the efficient electrostatics evaluation algorithms employed and temperature and pressure controls used. Features for steering the simulation across barriers and for calculating both alchemical and conformational free energy differences are presented. The motivations for and a roadmap to the internal design of NAMD, implemented in Cϩϩ and based on Charmϩϩ parallel objects, are outlined. The factors affecting the serial and parallel performance of a simulation are discussed. Finally, typical NAMD use is illustrated with representative applications to a small, a medium, and a large biomolecular system, highlighting particular features of NAMD, for example, the Tcl scripting language. The article also provides a list of the key features of NAMD and discusses the benefits of combining NAMD with the molecular graphics/sequence analysis software VMD and the grid computing/collaboratory software BioCoRE. NAMD is distributed free of charge with source code at www.ks.uiuc.edu.

PsyScope is an integrated environment for designing and running psychology experiments on Macintosh computers. The primary goal of PsyScope is to give psychology students and trained researchers, alike, a tool that allows them to design experiments without the need for programming. PsyScope relies on the interactive, graphic enviornment provided by Macintosh computers to accomplish this goal. The standard components of a psychology experiment -groups, blocks, trials and factorsare all represented graphically, and experiments are constructed by working with these elements in interactive windows and dialogs. In this paper, we describe the overall organization of the program, provide an example of how a simple experiment can be constructed within its graphic environment, and discuss some of its technical features (such as its underlying scripting language, timing characteristics, etc.). PsyScope is available for non-comercial purposes free of charge and unsupported to the general research community.

1Human Genome Center, Institute of Medical Science, University of Tokyo, 4-6-1 Shirokanedai, Minato-ku, Tokyo, 108-8639 Japan and 2University of California, Santa Cruz Extension in Silicon Valley, 10420 Bubb Road, Cupertino, CA 95014, USA ... Received on June 17, ...

We announce the availability of the Xplor-NIH software package for NMR biomolecular structure determination. This package consists of the pre-existing XPLOR program, along with many NMR-specific extensions developed at the NIH. In addition to many features which have been developed over the last 20 years, the Xplor-NIH package contains an interface with a new programmatic framework written in C++. This interface currently supports the general purpose scripting languages Python and TCL, enabling rapid development of new tools, such as new potential energy terms and new optimization methods. Support for these scripting languages also facilitates interaction with existing external programs for structure analysis, structure manipulation, visualization, and spectral analysis.

A computer program for fast and accurate numerical simulation of solid-state NMR experiments is described. The program is designed to emulate a NMR spectrometer by letting the user specify high-level NMR concepts such as spin systems, nuclear spin interactions, rf irradiation, free precession, phase cycling, coherence-order filtering, and implicit/explicit acquisition. These elements are implemented using the Tcl scripting language to ensure a minimum of programming overhead and direct interpretation without the need for compilation, while maintaining the flexibility of a fullfeatured programming language. Basicly, there are no intrinsic limitations to the number of spins, types of interactions, sample conditions (static or spinning, powders, uniaxially oriented molecules, single crystals, or solutions), and the complexity or number of spectral dimensions for the pulse sequence. The applicability ranges from simple 1D experiments to advanced multiple-pulse and multiple-dimensional experiments, series of simulations, parameter scans, complex data manipulation/visualization, and iterative fitting of simulated to experimental spectra. A major effort has been devoted to optimize the computation speed using state-of-the-art algorithms for the timeconsuming parts of the calculations implemented in the core of the program using the C programming language. Modification and maintenance of the program are facilitated by releasing the program as open source software (General Public License) currently at http://nmr.imsb.au.dk. The general features of the program are demonstrated

We have used the method of x-ray diffraction microscopy to image the complex-valued exit wave of an intact and unstained yeast cell. The images of the freeze-dried cell, obtained by using 750-eV x-rays from different angular orientations, portray several of the cell's major internal components to 30-nm resolution. The good agreement among the independently recovered structures demonstrates the accuracy of the imaging technique. To obtain the best possible reconstructions, we have implemented procedures for handling noisy and incomplete diffraction data, and we propose a method for determining the reconstructed resolution. This work represents a previously uncharacterized application of x-ray diffraction microscopy to a specimen of this complexity and provides confidence in the feasibility of the ultimate goal of imaging biological specimens at 10-nm resolution in three dimensions. coherent x-ray diffraction imaging ͉ x-ray microscopy X -ray diffraction microscopy is a recently developed method in which only the coherent diffraction pattern of the sample is measured. It provides a path to high resolution without the limitations imposed by an x-ray optical system. The idea to image a noncrystalline object by phasing and inverting its diffraction pattern goes back to a suggestion by Sayre (1, 2) and was first demonstrated with x-rays by Miao et al. (3). In this article, we report the imaging of the complex-valued exit wavefront (both phase and magnitude) of a whole freeze-dried and unstained yeast cell. The images, at 30-nm resolution from multiple angular orientations of the cell, required an exposure of approximately one minute each using 750-eV x-rays (1 eV ϭ 1.602 ϫ 10 Ϫ19 J). This demonstration paves the way for the application of 3D x-ray diffraction microscopy (XDM) (4, 5) to frozen-hydrated samples in the future.

High-performance computing has recently seen a surge of interest in heterogeneous systems, with an emphasis on modern Graphics Processing Units (GPUs). These devices offer tremendous potential for performance and efficiency in important large-scale applications of computational science. However, exploiting this potential can be challenging, as one must adapt to the specialized and rapidly evolving computing environment currently exhibited by GPUs. One way of addressing this challenge is to embrace better techniques and develop tools tailored to their needs. This article presents one simple technique, GPU run-time code generation (RTCG), along with PyCUDA and PyOpenCL, two open-source toolkits that support this technique.

Static and dynamic type systems have well-known strengths and weaknesses. In previous work we developed a gradual type system for a functional calculus named $\lambda^?_\to$ . Gradual typing provides the benefits of both static and dynamic checking in a single language by allowing the programmer to control whether a portion of the program is type checked at compile-time or run-time by adding or removing type annotations on variables. Several object-oriented scripting languages are preparing to add static checking. To support that work this paper develops $\mathbf{Ob}^{?}_{<:}$ , a gradual type system for object-based languages, extending the Ob < : calculus of Abadi and Cardelli. Our primary contribution is to show that gradual typing and subtyping are orthogonal and can be combined in a principled fashion. We also develop a small-step semantics, provide a machine-checked proof of type safety, and improve the space efficiency of higher-order casts.

We present a static analysis algorithm for detecting security vulnerabilities in PHP, a popular server-side scripting language for building web applications. Our analysis employs a novel three-tier architecture to capture information at decreasing levels of granularity at the intrablock, intraprocedural, and interprocedural level. This architecture enables us to handle dynamic features of scripting languages that have not been adequately addressed by previous techniques.

AutoTutor is a computer tutor that simulates the discourse patterns and pedagogical strategies of a typical human tutor. AutoTutor is designed to assist college students in learning the fundamentals of hardware, operating systems, and the Internet in an introductory computer literacy course. Most tutors in school systems are not highly trained in tutoring techniques and have only a modest expertise on the tutoring topic, but they are surprisingly effective in producing learning gains in students. We have dissected the discourse and pedagogical strategies these unskilled tutors exhibit by analyzing approximately 100 hours of naturalistic tutoring sessions. These mechanisms are implemented in AutoTutor. AutoTutor presents questions and problems from a curriculum script, attempts to comprehend learner contributions that are entered by keyboard, formulates dialog moves that are sensitive to the learner's contributions (such as short feedback, pumps, prompts, elaborations, corrections, and hints), and delivers the dialog moves with a talking head. AutoTutor has seven modules: a curriculum script, language extraction, speech act classification, latent semantic analysis, topic selection, dialog move generation, and a talking head. (A.C. Graesser) like AutoTutor, particularly in an academic environ-1389-0417 / 99 / $ -see front matter

GALAXY is a client-server architecture for accessing on-line information using spoken dialogue that we introduced at ICSLP-94. It has served as the testbed for developing human language technologies for our group for several years. Recently, we have initiated a significant redesign of the GALAXY architecture to make it easier for many researchers to develop their own applications, using either exclusively their own servers or intermixing them with servers developed by others. This redesign was done in part due to the fact that GALAXY has been designated as the first reference architecture for the new DARPA Communicator Program. The purpose of this paper is to document the changes to GALAXY that led to this first reference architecture, which makes use of a scripting language for flow control to provide flexible interaction among the servers, and a set of libraries to support rapid prototyping of new servers. We describe the new reference architecture in some detail, and report on the current status of its development.

JavaScript is the main scripting language for Web browsers, and it is essential to modern Web applications. Programmers have started using it for writing complex applications, but there is still little tool support available during development. We present a static program analysis infrastructure that can infer detailed and sound type information for JavaScript programs using abstract interpretation. The analysis is designed to support the full language as defined in the ECMAScript standard, including its peculiar object model and all built-in functions. The analysis results can be used to detect common programming errors -or rather, prove their absence, and for producing type information for program comprehension. Preliminary experiments conducted on real-life JavaScript code indicate that the approach is promising regarding analysis precision on small and medium size programs, which constitute the majority of JavaScript applications. With potential for further improvement, we propose the analysis as a foundation for building tools that can aid JavaScript programmers.

Macromolecular modeling and design are increasingly useful in basic research, biotechnology, and teaching. However, the absence of a user-friendly modeling framework that provides access to a wide range of modeling capabilities is hampering the wider adoption of computational methods by non-experts. RosettaScripts is an XML-like language for specifying modeling tasks in the Rosetta framework. RosettaScripts provides access to protocol-level functionalities, such as rigid-body docking and sequence redesign, and allows fast testing and deployment of complex protocols without need for modifying or recompiling the underlying C++ code. We illustrate these capabilities with RosettaScripts protocols for the stabilization of proteins, the generation of computationally constrained libraries for experimental selection of higher-affinity binding proteins, loop remodeling, small-molecule ligand docking, design of ligand-binding proteins, and specificity redesign in DNA-binding proteins.

his article describes an abstract framework for itinerant agents that can be used to implement secure, remote applications in large, public networks such as the Internet or the IBM Global Network. Itinerant agents are programs, dispatched from a source computer, that roam among a set of networked servers until they accomplish their task. This is an extension to the client/server model in which the client sends a portion of itself to the server for execution. An additional feature of itinerant agents is their ability to migrate from server to server, perhaps seeking one that can help with the user's task or perhaps collecting information from all of them. A major focus of this article is the Agent Meeting Point, an abstraction that supports the interaction of agents with each other and server based resources. Why is this extended form of client/server computing desirable or valuable? There are many detailed motivations for using itinerant agents [6]. They fall broadly into two categories: 1) support for mobile computers or lightweight devices and 2) the emerging need in rapidly evolving networks for an asynchronous method of searching for information or transaction services. For example: • The reduction of overall communication traffic over the low bandwidth, high latency, high cost access networks typically employed by mobile computers. • The ability of the agent to engage in high bandwidth communication (with a server, for example) to search through large, free text data bases. • The ability of lightweight mobile computers to interact with heavyweight applications without prior detailed knowledge of the remote server's capabilities. • The ability of the agent to integrate knowledge from the client and server and perform inferencing at the server. • The ability of the user to create "personalized services" by customizing agents that take up residence at a server. These claimed advantages are, at present, hypothetical, and we are performing experiments to determine if they can be realized. We believe they merit initial exploration. Public networks already contain an enormous number of computers capable of providing specific services. This number will continue to grow. These servers employ a wide variety of processors, operating systems, data bases, application frameworks, and applications. An itinerant agent framework enables these numerous, heterogeneous servers to offer many advantages. These include a host-independent execution environment for itinerant agent programs, standard communica

In this article we present the design choices and the evaluation of a batch scheduler for large clusters, named OAR. This batch scheduler is based upon an original design that emphasizes on low software complexity by using high level tools. The global architecture is built upon the scripting language Perl and the relational database engine Mysql. The goal of the project OAR is to prove that it is possible today to build a complex system for ressource management using such tools without sacrificing efficiency and scalability. Currently, our system offers most of the important features implemented by other batch schedulers such as priority scheduling (by queues), reservations, backfilling and some global computing support. Despite the use of high level tools, our experiments show that our system has performances close to other systems. Furthermore, OAR is currently exploited for the management of 700 nodes (a metropolitan GRID) and has shown good efficiency and robustness. * Supported by the ACI-GRID CIGRID and CGP2P, the project RNTL CLIC and BULL S.A. / Project LIPS

As illustrated by the approaches presented during the 5 th FSPM workshop (Prusinkiewicz 16 and Hanan 2007, and this issue), the development of functional-structural plant models 17 requires an increasing amount of computer modeling. All these models are developed by 18 different teams in various contexts and with different goals. Efficient and flexible 19 computational frameworks are required to augment the interaction between these models, 20 their reusability, and the possibility to compare them on identical datasets. 21

ARTS is a modular program that simulates atmospheric radiative transfer. The paper describes ARTS version 1.0, which is applicable in the absence of scattering. An overview over all major parts of the model is given: calculation of absorption coefficients, the radiative transfer itself, and the calculation of Jacobians. ARTS can be freely used under a GNU general public license.

Object-oriented scripting languages like Javascript and Python are popular partly because of their dynamic features. These include the runtime modification of objects and classes through addition of fields or updating of methods. These features make static typing difficult and so usually dynamic typing is used. Consequently, errors such as access to non-existent members are not detected until runtime. We first develop a formalism for an object based language, JS0 with features from Javascript, including dynamic addition of fields and updating of methods. We give an operational semantics and static type system for JS0using structural types. Our types allow objects to evolve in a controlled manner by classifying members as definite or potential. We define a type inference algorithm for JS0 that is sound with respect to the type system. If the type inference algorithm succeeds, then the program is typeable. Therefore, programmers can benefit from the safety offered by the type system, without the need to write explicitly types in their programs.

This paper describes Gamebots, a multi-agent system infrastructure derived from an Internet-based multi-player video game called Unreal Tournament. The game allows characters to be controlled over client-server network connections by feeding sensory information to client players (humans and agents). Unlike other standard test-beds, the Gamebots domain allows both human players and agents, or bots, to play simultaneously; thus providing the opportunity to study human team behavior and to construct agents that play collaboratively with humans. The Gamebots system provides a built-in scripting language giving interested researchers the ability to create their own multi-agent tasks and environments for the simulation.

Recent years have seen a dramatic increase in research and development of scientific workflow systems. These systems promise to make scientists more productive by automating data-driven and computeintensive analyses. Despite many early achievements, the long-term success of scientific workflow technology critically depends on making these systems useable by ''mere mortals'', i.e., scientists who have a very good idea of the analysis methods they wish to assemble, but who are neither software developers nor scripting-language experts. With these users in mind, we identify a set of desiderata for scientific workflow systems crucial for enabling scientists to model and design the workflows they wish to automate themselves. As a first step towards meeting these requirements, we also show how the collection-oriented modeling and design (comad) approach for scientific workflows, implemented within the Kepler system, can help provide these critical, design-oriented capabilities to scientists. (B. Ludäscher). by them. As such, these systems must provide scientists with explicit and effective support for workflow modeling and design. Regardless of how a workflow is ultimately deployed -within a local desktop computer, web server, or distributed computing environment -scientists must have models and tools for designing scientific workflows that correctly and efficiently capture their desired analyses. In this paper we identify important requirements for scientific workflow systems and present comad, a workflow modeling and design framework that aims to address these needs.

This paper introduces the development of multiple number of Unmanned Arial Vehicle (UAV) system as a part of BErkeley AeRobot (BEAR) project, highlighting the recent achievements in the design and implementation of rotorcraft-based UAV (RUAV) control system. Based on the experimental flight data, linear system model valid near hover condition is found by applying time-domain numerical methods to experimental flight data. The acquired linear model is used to design feedback controller consisting of inner-loop attitude feedback control, mid-loop velocity feedback control and the outer-loop position control. The proposed vehiclelevel controller is implemented and tested in Berkeley UAV, Ursa Magna 2, and shows superior hovering performance. The vehicle level controller is integrated with higher-level control using a script language framework to command UAV.

This is a preprint a paper published in Behavior Research Methods, Instruments and Computer, 1997, 29((3)), 322-327. Consult the latest paper for up-to-date information about Expe 5.1 EXPE is a DOS program for the design and running of experiments that involve the presentation of audio or visual stimuli and the collection of on-line or off-line behavioral responses. Its flexibility makes it also a very useful tool for the rapid design of protocols for testing neuropsychological patients. EXPE provides a powerful scripting language which allows the user to specify all the components of an experiment in a human readable file. Subjects' responses are saved in a user-specified format, also in readable ASCII files. A remarkable feature of EXPE is that the user can easily add new commands to the language: all the instructions are calls to functions written in independent Borland Pascal units. Thus, users can link their own pascal procedures to EXPE to meet any special need. This makes it possible, for example, to adapt EXPE to new hardware, such as new sound or video boards.

Space-Time Analysis of Regional Systems (STARS) is an open-source package designed for the dynamic exploratory analysis of data measured for areal units at multiple points in time. STARS consists of four core analytical modules: Anselin (1995) exploratory spatial data analysis; Anselin (2003) inequality measures; Carlino and Mills (1993) mobility metrics; and Christakos, Bogaert, and Serre (2001) spatial Markov. Developed using the Python object-oriented scripting language, STARS lends itself to three main modes of use. Within the context of a command line interface (CLI), STARS can be treated as a package which can be called from within customized scripts for batch-oriented analyses and simulation. Alternatively, a graphical user interface (GUI) integrates most of the analytical modules with a series of dynamic graphical views containing brushing and linking functionality to support the interactive exploration of the spatial, temporal, and distributional dimensions of socioeconomic and physical processes. Finally, the GUI and CLI modes can be combined for use from the Python shell to facilitate interactive programming and access to the many libraries contained within Python. This article provides an overview of the design of STARS, its implementation, functionality, and future plans. A selection of its analytical capabilities are also illustrated that highlight the power and flexibility of the package.

Recent developments in Web technology such as the inclusion of scripting languages, frames, and the growth of dynamic content, have made the process of retrieving Web content more complicated, and sometimes tedious. For example, Web browsers do not provide a method for a user to bookmark a frame-based Web site once the user navigates within the initial frameset. Also, some sites, such as travel sites and online classifieds, require users to go through a sequence of steps and fill out a sequence of forms in order to access their data. Using the bookmark facilities implemented in all popular browsers, often it is not possible to create a shortcut to access such data, and these steps must be manually repeated every time the data is needed. However, hard-to-reach pages are often the best candidates for a shortcut, because significantly more effort is required to reach them than to reach a standard page with a well-defined URL.

JavaScript is the most popular client-side scripting language for Web applications. Exploitable JavaScript code exposes end users to integrity and confidentiality violations. Client-side vulnerabilities can cost an enterprise money and reputation, and cause serious damage to innocent users of the Web application. In spite of all this, recent research in the area of information-flow security has focused more on other languages that are more suitable for server-side programming, such as Java.

Background: The main research tool for identifying microRNAs involved in specific cellular processes is gene expression profiling using microarray technology. Agilent is one of the major producers of microRNA arrays, and microarray data are commonly analyzed by using R and the functions and packages collected in the Bioconductor project. However, an analytical package that integrates the specific characteristics of microRNA Agilent arrays has been lacking. Results: This report presents the new bioinformatic tool AgiMicroRNA for the pre-processing and differential expression analysis of Agilent microRNA array data. The software is implemented in the open-source statistical scripting language R and is integrated in the Bioconductor project (http://www.bioconductor.org) under the GPL license. For the pre-processing of the microRNA signal, AgiMicroRNA incorporates the robust multiarray average algorithm, a method that produces a summary measure of the microRNA expression using a linear model that takes into account the probe affinity effect. To obtain a normalized microRNA signal useful for the statistical analysis, AgiMicroRna offers the possibility of employing either the processed signal estimated by the robust multiarray average algorithm or the processed signal produced by the Agilent image analysis software. The AgiMicroRNA package also incorporates different graphical utilities to assess the quality of the data. AgiMicroRna uses the linear model features implemented in the limma package to assess the differential expression between different experimental conditions and provides links to the miRBase for those microRNAs that have been declared as significant in the statistical analysis. Conclusions: AgiMicroRna is a rational collection of Bioconductor functions that have been wrapped into specific functions in order to ease and systematize the pre-processing and statistical analysis of Agilent microRNA data. The development of this package contributes to the Bioconductor project filling the gap in microRNA array data analysis.

Abstract. The design of collaboration scripts is a new focus of research within the CSCL community. In order to support the design, communication, analysis, simulation and even execution of collaboration scripts, a general specification language to describe collaboration scripts ...

Web software applications are increasingly being deployed in sensitive situations. Web applications are used to transmit, accept and store data that is personal, company confidential and sensitive. Input validation testing (IVT) checks user inputs to ensure that they conform to the program's requirements, which is particularly important for software that relies on user inputs, including Web applications. A common technique in Web applications is to perform input validation on the client with scripting languages such as JavaScript. An insidious problem with client-side input validation is that end users can bypass this validation. Bypassing validation can reveal faults in the software, and can also break the security on Web applications, leading to unauthorized access to data, system failures, invalid purchases and entry of bogus data. We are developing a strategy called bypass testing to create IVT tests. This paper describes the strategy, defines specific rules and adequacy criteria for tests, describes a proof-of-concept automated tool, and presents initial empirical results from applying bypass testing.

] conducted a comprehensive workload characterization study of Internet Web servers. By analyzing access logs from 6 Web sites (3 academic, 2 research, and 1 industrial) in 1994 and 1995, the authors identified 10 invariants: workload characteristics common to all the sites that are likely to persist over time. In this present work, we revisit the 1996 work by Arlitt and Williamson, repeating many of the same analyses on new data sets collected in 2004. In particular, we study access logs from the same 3 academic sites used in the 1996 paper. Despite a 30-fold increase in overall traffic volume from 1994 to 2004, our main conclusion is that there are no dramatic changes in Web server workload characteristics in the last 10 years. Although there have been many changes in Web technologies (e.g., new protocols, scripting languages, caching infrastructures), most of the 1996 invariants still hold true today. We postulate that these invariants will continue to hold in the future, because they represent fundamental characteristics of how humans organize, store, and access information on the Web.

Abstract| This paper describes an approach to building a distributed software component system for scienti c and engineering applications that is based on representing GRID services as application-level software components. These GRID services provide tools such as registry and directory services, event services, and remote component creation. While a servicesbased architecture for Grids and other distributed systems is not new, this framework provides several unique features. First, the public interfaces to each software component are described as XML documents. This allows many adaptors and user interfaces to be generated from the speci cation dynamically. Second, this system is designed to exploit the resources of existing Grid infrastructures like Globus 7], 15], Legion 17], 7], and commercial Internet frameworks like e-speak 11]. Third, and most important, the component-based design extends throughout the system. Hence tools such as application builders which allow users to select components, start them on remote resources, and connect and execute them, are also interchangeable software components. Consequently, it is possible to build distributed applications using a graphical \drag-and-drop " interface, a webbased interface, a scripting language like Python, or an existing tool such as Matlab.

A system for automatically identifying the script used in a handwritten document image is described. The system was developed using a 496-document dataset representing six scripts, eight languages, and 281 writers. Documents were characterized by the mean, standard deviation, and skew of five connected component features. A linear discriminant analysis was used to classify new documents, and tested using writer-sensitive cross-validation. Classification accuracy averaged 88% across the six scripts. The same method, applied within the Roman subcorpus, discriminated English and German documents with 85% accuracy.

Many large software systems originate from untyped scripting language code. While good for initial development, the lack of static type annotations can impact code-quality and performance in the long run. We present an approach for integrating untyped code and typed code in the same system to allow an initial prototype to smoothly evolve into an efficient and robust program. We introduce like types, a novel intermediate point between dynamic and static typing. Occurrences of like types variables are checked statically within their scope but, as they may be bound to dynamic values, their usage is checked dynamically. Thus like types provide some of the benefits of static typing without decreasing the expressiveness of the language. We provide a formal account of like types in a core object calculus and evaluate their applicability in the context of a new scripting language.

Providing online access to sensitive data makes web servers lucrative targets for attackers. A compromise of any of the web server's scripts, applications, or operating system can leak the sensitive data of millions of customers. Unfortunately, many systems for stopping data leaks require considerable effort from application developers, hindering their adoption. In this work, we investigate how such leaks can be prevented with minimal developer effort. We propose CLAMP, an architecture for preventing data leaks even in the presence of web server compromises or SQL injection attacks. CLAMP protects sensitive data by enforcing strong access control on user data and by isolating code running on behalf of different users. By focusing on minimizing developer effort, we arrive at an architecture that allows developers to use familiar operating systems, servers, and scripting languages, while making relatively few changes to application code-less than 50 lines in our applications.

Galaxy-ii is the designated initial common architecture for the DARPA Communicator project in the US Its key feature is the ability to control system integration via a run-time executable scripting language. This paper describes our experience in developing complex systems based on ...

In this paper we present XVR, an integrated development environment for the rapid development of Virtual Reality applications. Using a modular architecture and a VR-oriented scripting language, XVR contents can be embedded on a variety of container applications. This makes it suitable to write contents ranging from web-oriented presentations to more complex VR installations involving advanced devices, such as real-time trackers, haptic interfaces, sensorized gloves and stereoscopic devices, including HMDs. Some case studies are also presented to illustrate the development processes related to XVR and its features.

PySpline is a modern computer program for processing raw averaged XAS and EXAFS data using an intuitive approach which allows the user to see the immediate effect of various processing parameters on the resulting k-and Rspace data. The Python scripting language and Qt and Qwt widget libraries were chosen to meet the design requirement that it be cross-platform (i.e. versions for Windows, Mac OS X, and Linux). PySpline supports polynomial pre-and post-edge background subtraction, splining of the EXAFS region with a multi-segment polynomial spline, and Fast Fourier Transform (FFT) of the resulting k 3 -weighted EXAFS data.

Component-based systems must support dynamic reconfigurations to adapt to their execution context, but not at the cost of reliability. Fractal provides intrinsic support for dynamic reconfiguration, but its definition in terms of low-level APIs makes it complex to write reconfigurations and to ensure their reliability. This article presents a language-based approach to solve these issues: direct and focused language support for architecture navigation and reconfiguration make it easier both to write the reconfigurations and to ensure their reliability. Concretely, this article presents two languages: (1) FPath, a domain-specific language that provides a concise yet powerful notation to navigate inside and query Fractal architectures, and (2) FScript, a scripting language that embeds FPath and supports the definition of complex reconfigurations. FScript ensures the reliability of these reconfigurations thanks to sophisticated run-time control, which provides transactional semantics (ACID properties) to the reconfigurations. This research is supported by the French RNTL project Selfware (http://sardes.inrialpes.fr/selfware) and the IST project Selfman (http://www.ist-selfman.org).

In this paper, we introduce a toolkit called SceneMaker for authoring scenes for adaptive, interactive performances. These performances are based on automatically generated and prescripted scenes which can be authored with the SceneMaker in a two-step approach: In step one, the scene flow is defined using cascaded finite state machines. In a second step, the content of each scene must be provided. This can be done either manually by using a simple scripting language, or by integrating scenes which are automatically generated at runtime based on a domain and dialogue model. Both scene types can be interweaved in our planbased, distributed platform. The system provides a context memory with access functions that can be used by the author to make scenes user-adaptive. Using CrossTalk as the target application, we describe our models and languages, and illustrate the authoring process. CrossTalk is an interactive installation with animated presentation agents which "live" beyond the actual presentation and systematically step out of character within the presentation, both to enhance the illusion of life. The context memory enables the system to adapt to user feedback and generates data for later evaluation of user/system behavior. The SceneMaker toolkit should enable the non-expert to compose adaptive, interactive performances in a rapid prototyping approach.

Recent research has found that operators frequently misconfigure Internet services, causing various availability and performance problems. In this paper, we propose a software infrastructure that eliminates several types of misconfiguration by automating the generation of configuration files in Internet services, even as the services evolve. The infrastructure comprises a custom scripting language, configuration file templates, communicating runtime monitors, and heuristic algorithms to detect dependencies between configuration parameters and select ideal configurations. To demonstrate our infrastructure experimentally, we apply it to a realistic online auction service. Our results show that the infrastructure can simplify operation significantly while eliminating 58% of the misconfigurations found in a previous study of the same service. Furthermore, our results show that the infrastructure can efficiently determine the configuration parameters that lead to high performance as the service evolves through a hardware upgrade and the scheduled maintenance of a few nodes.

We argue that the transition from laptops to handheld computers will happen only if we rethink the design of web browsers. Web browsers are an indispensable part of the end-user software stack but they are too inefficient for handhelds. While the laptop reused the software stack ...

Understanding the structure of large information spaces can be enhanced using reverse engineering technologies. The understanding process is dependent on an individual's cognitive abilities and preferences, on one's familiarity with the application domain, and on the set of support facilities provided by the reverse engineering toolset. Unfortunately, most reverse engineering environments provide a xed palette of knowledge organization, data gathering, and information navigation, analysis, and presentation techniques.

This paper presents a flexible 3D simulator able to reproduce the appearance and the dynamics of generic legged robots and objects in the environment at full frame rate (30 frames per second). Such a simulator extends and improves USARSim (Urban Search and Rescue Simulator), a robot simulator in turn based on the game platform Unreal Engine. This latter provides facilities for good quality rendering, physics simulation, networking, highly versatile scripting language and a powerful visual editor. Our simulator extends USARSim features by allowing for the simulation and control of legged robots and it introduces a multi-view functionality for multi-robot support. We successfully tested the simulator capabilities by mimicking a virtual environment with up to five network-controlled legged robots, like AIBO ERS-7 and QRIO.

We present a procedural approach to authoring layered, solid models. Using a simple scripting language, we define the internal structure of a volume from one or more input meshes. Sculpting and simulation operators are applied within the context of the language to shape and modify the model. Our framework treats simulation as a modeling operator rather than simply as a tool for animation, thereby suggesting a new paradigm for modeling as well as a new level of abstraction for interacting with simulation environments.

This paper shows a new approach to model and control interactive objects for simulations with virtual human agents when real time interactivity is essential. A general conceptualization is made to model objects with behaviors that can provide: information about their functionality, changes in appearance from parameterized deformations, and a complete plan for each possible interaction with a virtual human. Such behaviors are described with simple primitive commands, following the actual trend of many standard scene graph file formats that connects language with movements and events to create interactive animations. In our case, special attention is given to correctly interpret object behaviors in parallel: situation that arrives when many human agents interact at the same time with one same object.