Moreover, 8 participants made mistake in theassociation step (Figure 9(c)) e.g., placing the artefact cardlater than the pro.le card onto the card reader or not placing the artefact card at all.

the deployment toolrejected these interactions and suggested the correct steps.This allowed the end users to accomplish the task withoutsecondary assistance.


It is important to remember that since change propagations can be performed in any direction among the products, the PGT may lose its tree characteristics.

these propagations also add valuable information regarding the genealogy of the products.


In these systems, arbitrary data.ow facts are associated with each program point.

our approach can be seen as associating a more restricted language of facts, i.e., the quali.ed type of each abstract location ., with each program point.


To this end, parameter sets could be introduced.

this would signi.cantly increase the complexity of modeling project parameters in the eABQM and thus should be carefully investigated within industry.


The AlciX layer computed arrangements of algebraic curves by analyzing curves and curve pairs, as reported in [12].

both layers lacked a public and well-designed interface for a general and simple usage.


Although strncat and strncpy require the user to specify the allocated length of the result string, there is no check to make sure the result fits in the length specified.

this does at least require the programmer to think about the length.


Traditional GUI editors recover design models by analyzing code.

a dynamic model is a hierarchy instance which can only be observed at runtime (i.e.


On the 22 cache-miss-address traces, TCgen is outperformed by VPC3 on one trace (by 13%), by SEQUITUR on five traces (by up to 452%), by MACHE on three traces (by up to 46%), by SBC on nine traces (by up to 195%), by PDATS II on one trace (by 11%), and by BZIP2 on four traces (by up to 60%).

on average and for the majority of the traces TCgen yields the highest compression rates.


They include workflow application modeling, workflow scheduling, resource discovery, information services, data management, and others.

from the user s perspective, the most important barrier that needs to be overcome is the scheduling on heterogeneous and distributed resources to meet user QoS (Quality of Service) demands.


These approaches have certain computation and communication requirements, as will be discussed later.

to our knowledge, DDM services have yet to be examined from the standpoint of power consumption requirements.


First, although packetizing the replicated data ensures that the chunks have a smaller size than the original message, in order to ensure that all possible opportunities to disperse data are used, these chunks must be fairly small, equivalently, s must be large.


For instance given the goals G1 and G2 it possible to derive the trigger-conditions for startSignal and preconditions for stopSignal by applying the immediate achieve pattern to the goals[16].

because our approach relies on analyses of behaviour traces rather than temporal formulae, the processes such as goal re.nement, obstacle analysis and operationalisation [8] can be bypassed provided the engineer gives the appropriate scenarios.


With our Atmega2560 setup, we veri.ed that a standard PC sound card suf.ced for the system to run at the granularity level of function calls, producing traces in the order of 200 to 300 samples in length.

to address either .ner granularity, or higher clock speeds for the target device, we may need to investigate the relationship between these: for a given granularity, what is the maximum ratio between the device s clock speed and the sampling rate at which we capture the power trace?


Systems that uses Coq as-is can easily be incorporated into our system.

those that modify the core system of Coq cannot be easily incorporated into our system because we use pCIC.


By negating some conditions, they proposed an approach to generate mutants [10].

they did not formally prove the conditions were correct.


In some way, marshalled c works as a coloured bracket with the difference that marshalled c(e:T) is a value and no reduction can happen in such a context.

after unmarshalling, the colour annotation on marshalled turns into real colour brackets to allow the sent expression to be well-typed.


In general, the components with the highest utility should be selected,but as described in Section 4.2, making this decision with only local in formation may lead to a con.guration that is globally sub-optimal.

having de.nedthe utilityofasingle component,itisnow possibleto.ndtheaggregateutilityofa con.gurationinorderto choose between candidates by taking the average utility of all the components in the con.guration: P U(c) c.arch Uagg(arch)= |arch|  this method for calculating the utility of a con.guration masks a signi.cant assumption, namely, that the component annotations are correct regardless of whether the component works in isolation or in a large con.guration; in other words, that nonfunctional properties are compositional.


Therefore, the live entry in node A ' and the new entry  are merged with the live entries in the sibling node B.

there are totally 6 live entries after merging, and a strong version over.ow occurs, leading to a key split [1].


Context-bounded veri.cation [34, 35] explores only those ex ecutions of a concurrent program in which the number of context switches is bounded globally by a user-supplied value.

the idea of context-bounding does not make intuitive sense for programs with large or unbounded number of tasks.


To reduce manual effort or human errors, tools can be developed for automatic migration of projects from one language to another.

these tools require the knowledge of how Application Programming Interfaces (APIs) of one language are mapped to APIs of the other language, referred to as API mapping relations.


The method defines composite models for multi-business transactions with different coordination protocols.

the required middleware is so complex that it results in poor availability.


To avoid lockholder preemption, Volkman s system delays the preemption of a VCPU running in kernel space.

the solution is only suitable for workloads that do not possess crossprocessor scheduling requirements.


with the evolution of AOP language, this burden is becoming shorter.


Another purpose-built application is SearchTogether [8], which allows multiple users to perform collaborative web search both synchronously and asynchronously using a PC, and provides novel solutions for addressing issues of awareness, persistence and division of labour (splitting a larger search task into smaller subtasks that are assigned to the different group members).

the system lacks a means of performing concurrent interaction on a single page -users can only see what others are doing and looking at and make suggestions, much as in the backseat driver scenario.


Scheduling for chaining SP is often the key to create enough slack, because the spawning inside the speculative threads enables long-range prefetching without incurring the spawning overhead on the main thread.

basic SP uses only one speculative thread.


This could be one reason why we observe this latency penalty for the hardware-based approach.

even in [28] that exploits a fully adaptive routing algorithm Opt-Y, the hardware approach incurs an average network latency penalty of 3.5% under the same link reactivation delay.


Finally, in this paper we have not discussed any possible scalability issues of our approach.

when applied to large systems, the use of a Rete network can result in a large memory footprint.


We have found that the performance of such cache optimized red-black smoothers is equal to the performance of the temporally blocked Gauss-Seidel smoother.

there is a drawback with the cache optimized red-black ordering: it is not easily parallelized since it re-introduces dependencies between the data points, see Section 4.


Nevertheless, previous systems have emphasized the support of task switching after workspace construction.

our system was designed to support the creation of workspaces through a simple intuitive user interface.


18 tells that the energy gain of all three algorithms improves with relaxed deadline constraints (from 0 to 100s).


The heap occupancy behavior of our benchmarks with this user-level optimization will be presented later in the paper and compared to our two schemes.

in this work, we mainly focus on exploiting the information about frequent .eld values within the virtual machine.


Figure 5(b) shows that vmmcESP delivers 41% less bandwidth as vmmcOri 9 for 1 Kbyte messages and 14 % for 64 Kbyte messages.

vmmcESP is only 25 % slower than vmmcOrigNoFastPaths for 1 Kbyte messages and 12 % for 64 Kbyte messages.


Admittedly, ILP is a very general tool for solving scheduling problems that allows to model certain architectural constraints in a .exible way, which enhances the scope of retargetability of the system.

we feel that integer linear programming should be rather considered as a fall-back method for the worst case where other algorithms are not available or not practical.


Clients that never send these new message types will simply be una.ected by them.

the addition of new message types does not, by itself, necessarily argue for the .exibility of more general structural subtyping.


In this sense, guard pages protect application data itself.

if the allocator is suf.ciently deterministic, an attacker may be able to ensure the placement of the source chunk well before any guard page, allowing an attack to overwrite many chunks.


Open innovation based on OSS can be considered a tool for uncertainty reduction and risk management: if the requirement is already in the open source project, it can t be used as a differentiator by a competitor.

oSS is also an unpredictable and only loosely controllable source of innovation.


To address the challenge of indoor localization, many systems have been proposed in recent years [1], [2].

smart phone based systems achieving both scalable and high accuracy are still missing.


Case studies [52, 32, 1] reported credible results even if some assumptions were violated.

application of SRGMs in [44] was unsuccessful due to their violation.


This initial version capped the speedup of any region at the number of cores available.

we found that including this constraint had a negative impact on plan quality.


Note that to grow .nances as quickly as possible, it is best to plant corn, as that generates 20 coins per minute.

the player must always be playing at .ve minute intervals to maximize return.


Maximal elimination will be achieved by .nding the smallest set of pointers pi covering a given interval, and then eliminating the barriers which they cover.

this is largely of theoretical interest, since in practice it will be dif.cult to apply the multiple covering condition statically, and there are unlikely to be multiple choices about which pointers to select to create a covering.


Uni cation graphs, as introduced earlier in this section, immediately yield the required origin traceability links: For a given merge problem, the set of nodes in each connected component of the uni cation graph constitutes the origin information for the corresponding merged element.

the current notion of uni cation graph cannot be used to nd the correspondence chain(s) involved in creating each merged element.


However, since the total numbers of incorrect.xestobu.erover.owsand memoryleaksin sample set2 isnot statisticallylargeenough(7 and8 respectively), wedonotclaimthoseexamples arefrequently observedincorrect .x patterns.

we assume these examples could be common for the incorrect .xes to bu.er over.ows and memoryleaks(showninSection4.2.4)if wecanfurther enlarge our sample set.


Inlining preserves the call-by-value semantics of MATLAB by making copies of the actual parameters.

read-only formal parameters are not copied.


Therefore, it makes sense to factor the handling code out into a separate module.

traditional programming languages, such as C++ and Java, do not support such separation.


It can also issue prefetches for these addresses on behalf of the main processor.

it can neither read from nor write to these addresses.


The method with predicates does not have to override another method that has no predicates.

for example, a method m may have only the implementations with predicates; in certain runtime contexts, all the implementations for m might be ineffective and thus a message not understood error would occur because all their predicates arefalse.we can modify our model to .t AspectJ s semantics.


For instance, there is no reason why the following expression should be ill-typed: poly :: Maybe ([Bool], [Int]) --ill-typed poly = do nil .

return [] return (True : nil, 1: nil) poly is not a well-typed Haskell expression, since nil is required to be monomorphic.


For example, NiMH batteries last for about 500 cycles when subjected to repeated 100% discharge.

battery endurance increases exponentially as the depth of discharge (DoD) decreases.


The LSI expert builds its judgment based on the source code textual similarities, while SPR expert grounds its judgment on the probabilistic ranking of dynamic events observed in execution traces.

both experts reply to the same question: What are the locations of a feature of interest?


The development managers, when asked how long it takes for the developers to become productive in their projects, would claim that it takes only a few months.

they would not even consider assigning some development tasks to developers that have been less than a few years with the project.


We tested the IRE method on the SPECint benchmark suite and found that the IRE method speeds up the execution of SPECint benchmarks in the range of 1.7% to 10%.

on microprocessors with less efficient data transfer paths, the speedup is limited.


All sequences are compressed by the standard encoder (referred to as STD) to produce the class of clean videos.

for Yang s method and PMP, all sequences are subjected to compression with random messages embedded to create the class of stego videos, and the achieved embedding strength vary from 80 to 200 bits per inter-frame.


Given a test database, query generation tools such as RAGS and QGEN generate many queries in order to cover a variety of test cases.

rAGS and QGEN were not designed for testing an individual DBMS component.


Three di.erent VCVs were introduced based on di.erent metaphors: the pin-ball metaphor, where the VCV is a ball that moves from the source to the destination node, striking the destination and making it oscillate; the prod metaphor, where the VCV is a rod that extends from the source to prod the destination; and .nally a wave metaphor, where the VCV accordingly is an animated wave that moves towards the destination node.

while these constructs are certainly an improvement over a simple DAG representation of causal relations, they do nothing to battle the complexity of large systems with many nodes and relations.


To give the client side the ability to process XML documents several XML based browsers are available [12][13][14][15].

they are not designed to support the processing of general XML data, nor do they have a flexible open architecture for incorporation into XML applications.


For model transformation for instance, trust can be enforced by construction through the use of transformation specific formalisms that can reduce the risk of errors.

redundancy aims to keep track of requirements in relation with the implementation in order to prove and test the transformation.


In the absence of such a natural weighting, we have generally chosen to maintain the entire distribution.

in the interest of a single normalized metric for comparing reuse functions, we formulate a metric similar to that of spatial locality where the cumulative fraction of memory operations at each reuse distance is scaled by some increasing function of that reuse distance and summed.


Interestingly, this part of the XSL specification has enjoyed far less success than the XSL transformation part and is not widely supported.

there is a fairly advanced implementation called FOP (Formatting Objects Processor) within Apache's XML Graphics Project.


For example, cheapF is a call to determine whether a given .ight is cheap and, unless the speci.cation of what cheap means changes, returns the same answer for a given .ight.

bf books an available .ight, and each successive call to this service can produce di.erent results.


Loop overhead is also expected to shrink as loops on larger vectors should require fewer iterations.

the reduction in dynamic instructions is not always ideal.


In that case, the real-time application would meet all deadlines if the processor on the physical computer is (at least) two times as fast as the processor for which the original real-time application was designed for.

the overhead for switching from one VM to another cannot be ignored and the time slot lengths for this kind of switching can obviously not be infinitely small.


This has been applied recently to component and service based architectures [21].

in our context, we have an important constraint: the implementation source code is un-available since it is made up of distributed black-box peers.


For example, in [9] it is shown that C++ results in 1737% larger Code Size in Bytes than C, for certain benchmarks.

but in our study, both sets of components measured in series 2 and 3 are implemented in C. as pointed out in [26] also object-oriented design implemented in C can cause a Code Size penalty.


This leads to suboptimal performance, especially for FFTs of larger sizes (e.g., 1D FFTs) that require several passes over data located in GPU memory.

we exploit the shared memory to perform auto-tuning on a much larger space.


A possible algorithm to solve a triangular system is to compute the inverse of A and then multiply it by b.


Collectively, the fundamental limitation of these exhaustive approaches is that they are not inherently scalable for larger concurrent programs and often require manual intervention (to specify abstractions or a model of the program).

our focus is squarely on handling large concurrent C implementations, which in turn dictates our dynamic synthesis approach.


Therefore, the maximum number of LXCs in an experiment we can keep in real-time is: N/TDF, where N is the number of dedicated CPUs on the machine, and we are assuming no overhead.

our system does have overhead, so our experiment will determine just how close we can get to this upper bound.


We all know that verification is hard, yet there are techniques that work pretty well in practice, such as those based on model checking.

common verification techniques do not exploit the hierarchical structure or modularity that such models very often have.


Application Services can be defined as reusable components or pieces of reusable business logic that can be used and, more importantly, only make sense within the given application.

business Services can be defined as reusable components or reusable pieces of business functionality that have initial affinity with the application, but largely can be used and make sense within the wider enterprise.


HashTable in X10 (without place type annotations) just as an instance of S, namely p, is used to bind a property in BoxT, in the same manner S itself might contain a property which wouldbe boundby some other .nalvalue.

distributed Arrays In general, the place of the object that an array element a[i] refers to can be different from the place at which the slot itself lives (which is determined by the distribution of a).the type inference system can takeadvantage of the knowledge if the content of the slot is at the same place as the slot itself, as in the example below: T@!


We can certainly take advantage of the fact that we are dealing with advice as .rst-class functions, and de.ne a shift-down higher-order function that takes a function f and returns a new function that applies f one level below: (define (shift-down f) (.

args (down (apply f args)))) simply deploying an aspect with shift-down as follows: (deploy pc (shift-down adv)) would be incorrect.


A key innovation is its compositional pipe-and-.lter design.

unlike Unix pipes, processing along the pipeline is still done synchronously.


As a consequence, they are becoming more and more complex.

these transformations are still developed manually.


A great deal of our e.ort has been absorbed by the need for clever ranking.

the analysis has proven relatively straightforward.


Table 1: Log Interval Values Expressed by the Gene Log Interval Range [1 -8] (8 -12] (12 -15] (15 -40] Represented Values all each 2 each 3 each 5 that keep into account exclusively direct e.ects (e.g., the expected overhead for taking each single log).

executing the reproductive cycle of even a simple EA on long individuals and/or large populations requires high computational resources.


5.2 Projection to User Code The slice created by MatchMaker contains all the statements that were necessary to create the critical chain in a particular heap.

a lot of the code in the slice belongs to the framework, and is therefore of no interest to the user.


As DIMM-to-DIMM power variability is mostly .xed post-manufacturing [17], there is little need for realtime monitoring of memory power use for each module.

if power variation changes (e.g., due to aging and wear-out), we assume these changes can be detected through power sensors in each module (left as future work).


Furthermore, an idea for the additional implementation of other metrics and opportunities for extending the tree to other programming languages was described.

their final goal was programming language independence.


In almost all cases this assumption is correct and simulation proceeds normally.

if an interrupt is found to be pending, the simulation needs to revert to a previous state and restart the simulation using an interpreter that faithfully models interrupt handling.


Hence, in the given simulation scenario,the NetLossCap method is very e.ective in limiting risk while maintaining good performance.

we note that the NetLossCap method is not necessarily scalable.


It is then challenging for the library s client to .x the problem, since they may not know the precise cause nor even if it is in fact their fault, rather than a bug in the library.

if library authors make use of gradual typing to annotate the parameter types of their functions, then the error can be localized and caught before the call to moment, resulting in easier debugging.


The icc compiler performs many advanced CPU-level optimizations.

using icc alone attains the worst performance among all approaches due to the lack of better cache-level optimizations.


1 APFEL is German for apple and short for A Preprocessing Framework for Eclipse (and CVS)  Comparing abstract syntax trees is one approach to compute finegrained changes, however it is complicated and time-consuming [19, 20].

aPFEL represents the syntactic content of elements (e.g., methods) with tokensets, thus neglecting the order within an element.


Polylingual systems are relatively easy to build when the number of APIs needed to achieve language interoperability is small.

when the number of distinct APIs become large, maintaining and evolving polylingual systems becomes a notoriously difficult task.


Objective 3 results in a reordering of a FIFO queue through the event mechanism.

this does not interact with the scheduling.


If this condition does not hold, there can be no integer solution to the linear equation, and hence, no dependence exists.

if the condition does apply then dependence does not necessarily exist.


For our purposes, this does not pose any problems, since the debugging and analyses presented in Section 4 and Section 5 only use sequential access to this data.

when needing random access to the trace (e.g.


Core Operational Semantics of Proto Mirko Viroli Jacob Beal Matteo Casadei Alma Mater Studiorum BBN Technologies Alma Mater Studiorum Università di Bologna 10 Moulton Street, Cambridge, Università di Bologna Via Venezia 52, 47521 Cesena (FC), Italy mirko.viroli@unibo.it MA 02138, USAjakebeal@bbn.com Via Venezia 52, 47521 Cesena (FC), Italy m.casadei@unibo.it ABSTRACT The Proto spatial computing language [6] simpli.es the creation of scalable, robust, distributed programs by abstracting a network of locally communicating devices as a continuous geometric manifold.

proto s successful application in a number of domains is becoming a challenge to its coherence across di.erent platforms and distributions.


A key assumption of that work [12] is the following: Matching documents of the query in web index are evenly distributed and thus load balancing among threads is not of great concern.

this is not always the case because matching documents of a query may not be evenly distributed along the index space.


The use of .sheye views for the visualization of graphical models has two advantages: Showing only an abstract view of the model parts which are not in the user s current focus of interest reduces the amount and complexity of the information displayed while still showing all the details in the current focus of interest.

the integration of a .sheye visualization in a modeling tool avoids the frequent context switches that occur with an explosive zoom, because the surrounding context is always shown.


The 64-bit x86 architecture permits entry into the kernel via interrupts, system call instructions (syscall and sysenter), and certain far call and jmp instructions [2] (see [21] for a more concise explanation than [2]).

the Linux kernel only enables entry via system calls and interrupts.


For Qrate, our results indicate that linear growth in the team was not associated with reduced product quality.

for Qacceleration, we conclude that accelerated team expansion is associated with reduced product quality.


With cloning, each packet is processed by one core, hence these read operations are performed once.

with pipelining, these We conclude that pipelining introduces signi.cant synchronization overhead, hence we expect cloning to perform better in scenarios where compulsory cache misses are the dominant costfactor(in termsofcycles spentperpacket).


On one hand, tight resource constraints will limit the search space by rendering certain states inaccessible, and thus reduce the runtime.

loose resource constraints will make even the high utility states accessible, giving the full bene.t of the optimization directed search.


The result was a large overlap in the basic engineering tool features of this particular industrial sector such as several dialog types as well as device communication related features.

each product supported unique feature domains.


On Raw, off-chip DRAM offers higher throughput than a core s local memory, so we decided to store the buffers there.

we envision that on-chip storage would be the better choice for most commodity multicores.


Thus, our algorithm starts o. by doing a direct transfer.

at time t1 =10s, we limit the inbound bandwidth of the site to 1/10 of its value.


Finally,innovationsinhypervisorshave alittleperformanceimplication.Usinga safelanguage mayincur additionalperformance overheadduetothe added callindirections and changed codelayout.

as theproportion execution timein ahypervisoris muchless than an operating systemfor a well-formed(e.g., nonblocking) hypervisor, the possibly added execution time should contributelittletotheoverallperformanceofapplications.Further, usingascalabledesignandlanguagecanlikelyimprovetheperformance for medium-or large-scale processors due to the possibly improvedcachelocality and scalability.


If handlers are used, the monitored service will have to become unavailable during the deployment of a handler, because it would be necessary to change the con.guration or even to recompile the Web service, depending on the underlying technology, in order the required handlers to operate properly.

the use of a wrapper or a proxy does not require the monitored service to become unavailable, because the wrapper is similar to any other consumer accessing the monitored service, and the proxy is transparent for the monitored service.


HARD REAL-TIME GC The usage of the term real-time for garbage collectors dates back to the late 1970s [4].

this term has been used in very different ways since then.


For example, SISR .rst generates a relative location map of the network and then transforms it to absolute positions when suf.cient landmarks are available.

dV-hop simply relies on counting hops to the landmarks to calculate the node locations.


On the other hand, the user-level threadapproachis moreportablethanthekernel-levelthread approach.

supportingNativeThreads: Currently, ourprototype only works withJava.integratingtheproposed clustering and planning mechanism to languages such as C and C++ should be quite straightforward.


having said this, our experience shows that the test leader is a primary source of important knowledge that is based on intuition and personal experience.


Indeed, the knowledge of the relative locations of sensor nodes is assumed or computed in most prior work on multi-robot spatial coverage [7, 9, 11, 14, 22, 24].

these existing techniques are unsuitable for MAV swarms due to the following challenges:  Lack of Infrastructure Many multi-robot systems rely on existing infrastructure for inferring the relative location of nodes such as GPS, Wi-Fi access points, motion-tracking camera systems etc.


Our initial results suggest that using multiple starting points (>15) in the knowledge base, and considering impacted artifacts several trace links away (>5), increases the prediction accuracy.

considering a high number of impact candidates requires a good ranking function.


The lower run-time cost of SIPs makes their use feasible at a finer granularity than conventional processes.

hardware isolation remains valuable as a defense-in-depth against potential failures in software isolation mechanisms.


Applications pass abstract syntax trees to Atlantis for execution.

we could have chosen for applications to pass low-level bytecodes ala applets.


Moreover, in a non-shared partition of the computing system, it always holds .ptq Optq 0, indicating that there are neither sharing bene.t nor sharing loss.

in a shared pay-asyou-use computing system, either of them could be nonzero.


SingI ( Succ n) where sing = SSucc sing The SingRep class The SingI and SingE classes are kept separate because while it is possible to de.ne instances for SingE on a datatype-by-datatype basis, the instances for SingI must be de.ned per constructor.

it is often convenient to combine these two classes.


This is done in the hope that the smaller number of synaptic weights will ease the training process.

training spiking neural networks requires innovative techniques.


Memory management Dynamic memory allocation is considered central to most object-oriented languages, and automatic memory management in the form of garbage collection is common to most modern object-oriented languages.

on a low-end embedded system, the amount of memory may be so limited that dynamic memory allocation becomes infeasible.


As we discussed in section 3.4, the complexity of code maintenance is on the order of t2 e. As the number of states increases, the taskof code maintenance becomes extremely di.cult.

the code translation algorithm automatically threads the control-.ow states together.


or functional constraints (such as legacy components) may drive the process of selection among the resulting alternatives.

working on the performance side to remove problems may inhibit analyzers to consider some solutions that, instead, would be visible in the software side due to the richness of the architectural notations and the experience of software architects.


In this case, it is desirable to augment the test set with one or more tests whose profiles yield points in R when displayed.

it is possible there are no inputs to the software that will produce profiles in R, and in general it is undecidable whether there is any input to a program that will produce a profile with specified values.


This slows down the embedder, extractor, and attacker equally.

slow KDFs can be defeated by attackers with plenty of parallel computational resources, and the key dictionary can be derived o.ine unless the keys are also salted [16] (and with what?


Introduction Virtual machine monitor (VMM) technology has been put to many innovative uses, including mobile computing [16, 28, 40], system management [17, 39], intrusion detection [18], and grid comput ing [20].

the dif.culty of virtualizing graphical process ing units (GPUs) has so far limited the use of virtual machines (VMs) for running interactive applications.


INTRODUCTION Middleware technologies, such as J2EE, .Net and CCM have proved successful in constructing enterprise scale applications[1].

one remaining problem challenging developers is to design component based applications that can meet specified performance requirements.


This technique trades costly in-place updates for many cheap log writes.

it cannot eliminate small writes needed to update metadata in-place unless the metadata are deleted.


For permutation groups G, the Schreier Sims algorithm and its variants [17],[16] solve the constructive membership problem in G, by computing a strong generating set Y.

for large-base permutation groups (see Section 3), there are asymptotically more e.cient algorithms, which use reduction .rst.


Throughout the project much interest was expressed in PIPSI by project managers.

whilst very supportive of the ideas contained within PIPSI managers decided against investing in practitioner training.


because p was not split from them during the typing of e ' .

are we guaranteed that if we restore the pulled permission to these locations in .


They prune out all non-coalesced solutions so it is not clear what happen with codes that can never be coalesced.

we allow non-coalesced solutions, although they will never be selected if there are coalesced ones.


3.1 Static versus dynamic typechecking The StringBorg-generated API we have presented checks dynamically if guest sentences are composed correctly.

we have also implemented a Java back-end that performs these checks statically by using the Java type system.


3Note that it is safe to update the memory system if the store is equal to oldest(UL, Us, UB ).


A formal evaluation of AgentCubes [15], which essentially is the 3D cousin of AgentSheets featuring identical programming, confirmed high degrees of end-user programming accessibility and support for general problem solving.

at this point only semi-formal studies have been conducted to assess the specific contribution of conversational programming added to AgentSheets and AgentCubes.


To ensure the system s performance it has to constantly adapt the placement through migrations to new fog nodes.

each migration comes with a cost because operators are associated with local state, e.g., a cached portion of the event stream or a street map.


Forinstance,they canbe noti.ed when a collaboratorhas .nished editing the element.

noquantitative measureisprovidedfor concurrent operations orfor con.icts.


Without the hardware support, their reliance on collecting load values for the SMT solvers to search for shared memory dependencies will create a signi.cant space overhead and a considerable program slowdown.

we do not collect any values but only the paths taken by the threads, which has much lower recording overhead.


This is similar to our disambiguation method.

we rely on the template for a name, and add metadata only when required by a name collision.


recommended a cloud management plane for using in Infrastructure-as-a-Service model [10].

they did not show how we can practically implement those schemes.


It is not necessary to implement a complete VM, allowing the language designer to focus on the execution semantics of the language.

the bene.ts of the layering must not sacri.ce peak performance of the guest language.


Gazelle [49] is another microkernel browser; like Atlantis, Gazelle is agnostic about a web page s runtime environment.

atlantis di.ers from Gazelle in .ve important ways.


This work is similar to ours in its overall goal, namely, to assess the bene.ts of using aspects to modularize error recovery code.

there are some fundamental di.erences: (i) we use exception handling to deal with errors, instead of transactions; (ii) we substantiate our conclusions with measurements based on a metrics suite for AO software, instead of examples; (iii) we do not address concurrency; (iv) our study is more general and based on a varied set of applications with diverse error handling strategies.


CoreDet, a compiler and runtime sys tem, enforces deterministic execution for arbitrary multithreaded C/C++ programs [3].

it exhibits prohibitively high over head, running up to 8.4× slower than pthreads (see Section 6) and generates thread interleavings at arbitrary points in the code, complicating program debugging and testing.


Such services have met an enthusiastic success in implementing these large-scale federations thanks to their intrinsic decoupling properties that improve the o.ered scalability guarantees.

a very important requirement of such federations is the capability of the adopted publish/subscribe service to tolerate faults occurring in the network and/or computing nodes composing the federation, without negatively a.ecting the provided event noti.cation.


However, this was achieved at the expense of additional software development e.orts.

e.cient data transmission is a non-functional application requirement that can be considered as a cross-cutting concern, since it cannot be cleanly separated from the rest of the system.


Unfortunately it is not easily possible to automatically translate the existing JastAdd based refactoring implementation into Coq, since JastAdd allows attribute de.nitions to contain arbitrary Java code.

almost all of JastAddJ and the refactoring engine is written in a declarative style that is easily transcribed into a pure functional programming language by hand.


a We choose the task with activity vectorbj to be scheduled next, if: c a j= arg min(at-am) ·bi (6) i=1 Ifaunitis currently hotterthanitsaverage temperature, scheduling a task that uses this unit is discouraged: The corresponding component of the temperature difference (at- am) is positive; mul a tiplication with a nonzero utilization from vector bi yields a positive contribution to the scalar product.

if a unit is currently colder than its average temperature, scheduling a task that uses this unit is encouraged: The corresponding component ofthe temperature difference is negative; multiplication with a nonzero utilization from vector abi yields a negative contribution to the scalar product.


Note that the decisions of the compiler are based on declared type information, and not on global static analysis.

in this paper we assume that when static typing as per place typesfails, the programis rejected.asa matterof policy, theX10 compilermay choosetoreverttothe standardtype system, and insert runtime checks as before.


Debugging tools can provide status acquisition functions by using OS internal descriptions provided by OS vendors.

because of customization, the description becomes more complex as the internal structure becomes more complex.


This library was natively compiled for all platforms and used for encoding and decoding.

software decoding is only used as a fall-back case.


Existing tracing tools such as Poirot [21] include capabilities to expand acronyms and utilize lists of matching words in an attempt to bridge the semantic gap.

they fail to capture the rich set of relationships and inference rules that can be modeled in an expert system.


On the one hand, this additional dimension makes formal reasoning more challenging.

practical issues like the cost of thread migration further complicate things.


7.2 Adaptation The adapter design pattern [17] is a protocol for implementing adaptation.

this and other related patterns are tedious and error-prone to implement, rely on statically unsafe type casts, and do not preserve object identity or provide bidirectional adaptation, as sharing does.


These objects are, in general, opaque to the structure server, which simply stores them and allows them to be retrieved by domain-speci.c applications.

as part of Themis s support for behavior awareness, certain objects are now only partially opaque, allowing them to provide information to Themis in order to augment the operation of certain behaviors (see Section 2.2).


Static analysis alone cannot address this issue because, technically, the user interface presents all the consequences of the sharing action to the user.

the way that information is presented does not ensure that the user sees or registers the consequences of granting another user edit permissions.


On the one hand, the W associated with the prepend must be small enough to satisfy W = V in order to ensure a normalized stream be shifted by no more than V bytes.

the W associated with the prepend should be large enough so that the W .


On the surface, it looks like an ARM/Thumb mixed ISA is just a variable-length instruction set architecture.

the layout of an ARM/Thumb mixed ISA executable is quite different from a typical CISC executable.


7.2 Dynamic Adaptation of Core Performance Dynamic voltage and frequency scaling (DVFS) is a widely used technique for dynamic per-core performance adaptation [15, 10] and some AMD commercial processors support per-core DVFS [1].

off-chip regulator-based DVFS incurs intolerable scaling overheads (tens of microseconds) for our purpose.


To understand this thesis, we assume that each hyperlink is a recommendation; thus, a page which has many recommendations, which correspond to inlinks, must be an important page, and vice versa.

the weights of recommenders are not the same.


To the best of our knowledge, this is the .rst work that proposes application and ISP collaboration based on the observation that content is usually accessible at multiple locations due to the prevalence of distributed content delivery architectures.

there is a chance that the content delivery architecture may try to boycott the choice of the ISP by no longer exposing the multiple locations.


Apart from the work in [9] that we have considered in this paper, there are also other approaches that use UML class diagrams to represent the data dimension, such as [11].

[11] turns to proclets (a labeled Petri net with ports) to represent the internal lifecycle of the artifact and how it relates to other artifacts.


Table 2 outlines that the basic counter logic and the rou tines necessary to create and check message certi.cates are similar in complexity for both SSL variants and CASH.

the software-based isolation and execution substrate for SSL and VM-SSL are clearly larger albeit we use the conservative values presented by Steinberg and Kauer [26].


3.2 Fixed Priority Scheduling We have shown that the task promotion times cannot be used as the maximum procrastination interval under .xed priority scheduling.

task feasibility is guaranteed if the maximum procrastination interval of each task is bounded by the promotion times of all equal and lower priority tasks.


One notable example can be found in Ken Thompson s Turing Award lecture [19].

none of these efforts strove for the same development environment goals as Klein.


|ai | = 1, then we more easily see that a left-associated expression costs O(n 2) more steps than a right-associated expression: n-1n-1 n(n - 1)(n - i) = i = 2 i=1 i=1 Of course, these are the most extreme cases: most expressions will not be completely right-or left-associated.

any expression that is not completely right-associated will yield an overhead.


The CS-DVS technique executes at the critical speed and shuts down the system to minimize energy.

if the idle intervals are not suf.cient to shutdown, CS-DVS can consume more energy than the DVS technique as seen at utilization of 20% and 30%.


facilities, we have put together a vision of a current high end modeling environment.

modeling is mostly creative work, and sadly, current high end modeling tools do not support this very well.


This result serves as the ground truth against which the output of BIRD s disassembler is compared.

there could be instructions that BIRD s disassembler produces from the binary .le that are not present in Visual C++ compiler s assembly output.


Their real reason was probably that analysis of such a powerful construct seemed utterly hopeless, particularly when considering the language s lack of protection mechanisms, as it allows arbitrary behaviours to result from an unstructured data value.

a recent survey [18] showed that a majority of the most popular websites use eval and that they use it in many varied (and often misguided) ways.


5.3 Formal MaskParameters Sofar, we have applied masks, and views in general, on componentsina non-invasivefashion, fromthe outside.

views as formal parameters within components also have an important use in disambiguating di.erent instances of an e.ect.


This is also hold the CMS and MM architectures.

we cannot specify a composition in HW architecture based on request-service join points (Table 1) as the exceptional events need to be handled at the server side in the HW architecture.


These are extremely rare events with our large mapping units and as such they have negligible impact on overall performance.

if we used a .ner-grained module-level mapping, we would have to update all of the cached mapping information on every module change, including each call to mremap.


Players can move freely from one cell to another.

both of these approaches are not able to cope with an uneven and dynamically changing player distribution.


Their framework Makao [1] infers modularity in KBUILD by analyzing build traces.

the amount of variation points that we identify in KBUILD with this article indicates that the full re-engineering of build-system variability remains an unsolved problem.


Most recent studies to monitor location with smart phones make use of the embedded GPS radio and accelerometers [1].

the location information obtained through GPS is only reliable in certain outdoor environments with direct visibility to the satellites, while the accelerometer data are generally too noisy to obtain accurate location information.


the outliners on the population objects, which contain actual data for running the application SelfSync synchronizes the three views, which is partly facilitated because the objects in the three views are actually di.erent views on the same Self code.

view-dependent information is not visible in all the views.


For example, he .nds direct threading is faster than subroutine threading on a 6809 CPU, because the JSR and RET instruction require extra cycles to push and pop the return address stack.

curley found subroutine threading faster on the 68000 [4].


General Terms Algorithms, Experimentation, Measurement, Veri.cation  Keywords Peer-to-peer, Sampling 1 Introduction The popularity and wide-spread use of peer-to-peer systems has motivated numerous empirical studies aimed at providing a better understanding of the temporal and topological properties of deployed peer-to-peer systems.

due to the large scale and highly dynamic nature of many of these systems, directly measuring their global behavior is extremely challenging.


The results made clear that the physical and digital organization scheme of each collaborator was idiosyncratic.

the methodological bent of the researcher was glimpsed in the ways they organized their documents.


Because the common CS1/CS2 programming languages are not languages often thought of as web or mobile programming languages a desktop application is the natural choice for a userinterface programming project.

the recent development of web and mobile application development environments based on popular CS1/CS2 languages such as Java, C++, and Python means that human computer interaction classes can be made more relevant to today s students through the incorporation of mobile and web user-interface projects.


As shown in Figure 1, both the thread-parallel execution and the epoch-parallel execution start running the .rst epoch simultaneously.

the threadparallelexecution runs the epoch muchfaster becauseit uses more cores.


Since the theory of lists is not decidable as it uses universal quanti.ers, the theory of ordered relations is not decidable as well.

for practical purposes we have not found that to be limiting in our experiments.


As vehicle B is assigned a lower priority based on its arrival time, it allows vehicle A to safely cross the intersection .rst.

when the packet loss rate is too high, intersection safety messages among these vehicles can be lost, and vehicle B has no information about the higher-priority vehicle, A.


There is signi.cant reduction in the overall job execution times between 100 Mbps and 1 Gbps scenarios.

.gure 7(a) shows results for 100 Mbps (a) 100Mbps bandwidth and 30ms delay between clusters (b) 1Gbps bandwidth and 30ms delay between clusters  Figure 6: Execution times for 30ms inter-cloud delay and 60 ms inter cloud network parameters.


In MAT L A B all the variables holding a numerical value are by default of type Double, which means that by default, in the X10 code generated from MAT L A B, all variables are statically declared to be of Double.

in languages like X10, Java and C++, certain program operations require the variables used to be of an integer type.


Given the event-driven natureofEvent-B,thiswork will requireus todevelopbotha translation of events to JML speci.cations and a Java framework that models the .ring behavior of events.

event-B is in some ways a simpler language than B and so easier to translate.


Microtasking workflows clearly impose an overhead on a development process, and the total amount written per person-hour is likely lower with CrowdCode than with traditional approaches.

if microtasking is able to successfully reduce the barriers to contribution and thereby harness value from the long tail of participation the many willing to donate small amounts of time and effort the benefits of tapping into a much larger available resource may still outweigh the overhead costs of using that free resource less efficiently.


There are already several procedure placement algorithms in the literature, as enumerated below.

the best techniques for reducing cache con.icts increase the global code size, which make themselves unusable in the embedded context.


Consequently, we were unable to directly measure the impact of setting stepbase to an ar bitrary value.

the values that we have selected are very effective for all of the benchmarks we have considered.


However, such timeouts result in additional packets being sent to the controller, both in .ow removed messages and for subsequent .ow setups.

frenetic s run-time system reacts to changes in the forwarding policy and manages the set of installed rules automatically, obviating the need for timeouts.


Moreover, we are not restricted to total functions as in full dependently-typed languages such as Coq [Bertot and Cast´eran 2004] or Agda [Norell 2007].

since we can pattern match on index objects, we cannot naively erase them.


A bug in an individual con.guration may be found by analyzers based on standard program analysis techniques.

since the number of con.gurations is exponential in the number of features, it is not feasible to analyze each con.guration separately.


Lockfree versions of the queue are well known.

an important open question is whether practical wait-free queues exist.


We use this kind of application as an example because it lets us stress that many systems are complex and operate in a varied and complicated environment.

the above issues would arise, to different extents, for most applications (e.g., mail clients, word processors, web servers).


Once the admission test is passed, the components in a segment are initialized (line 15-17): a component is parameterized, activated and connected to its downstream neighbor.

during the initialization, the components have not yet begun to execute as a result the reserved resources are not utilized.


Templates also help concretize the initialization-time validation step by providing a singlecall that validates the template and returns a handle to the resultinggraph.


When two such ordered juice terms match, the corresponding code fragments will be equivalent, modulo renaming of variables and literal constants.

it is also possible that a different ordering of variables may lead some other pairs of terms to match, and thus correctly identify other sets of equivalent code fragments.


DFuse is intended for deployment in a heterogeneous ad hoc sensor network environment.

dFuse cannot be deployed in current sensor networks given the limited capabilities available in sensor node prototypes such as Berkeley motes [7].


The data race reports pointed to races in shared arrays that were used by the programmer to implement custom barriers.

all the custom barrier implementations were incorrect because they involved unsynchronized spin loops on shared array elements.


This data-set includes all hierarchies previously used in the literature in benchmarks of dispatching algorithms.

prior Table 2: Essential parameters of the pruned hierarchies in our data-set The .rst two data columns in the table give the values of n and mfor each of the hierarchies in the data-set.


This bound is fairly close to the trivial upper bound: every e.ciently computable function can be inverted with work 2n+O(log n).

we are able to show that a qualitatively similar assumption is necessary for obfuscating point functions.


This slowdown is due to conservative code size estimation: the compiler predicts that the fused version of 3gpp will not .t into the instruction cache, thereby preventing fusion.

due to optimizations by gcc, the .nal code size is smaller than expected and does .t within the cache.


The works of [19, 20] de.ne a framework to describe generational and conservative collectors.

it only deals with stop-the-world algorithms.


A number of overlay multicast protocols have been developed, many of them in the context of the applicationendpoint model [3, 4, 5, 7, 8, 9, 11, 12, 13, 15, 16, 18, 20].

a critical issue ampli.ed by the application-endpoint model that these protocols do not seriously consider are the connectivity restrictions imposed by Network Address Translators (NAT) and .rewalls, which hinder and even block communication between certain pairs of hosts.


Note that this model does not really match empirically derived models of UDP and other bursty tra.c patterns [10], [13], [19].

it is analytically tractable; furthermore, our purpose here is to compare the relative impact of RED on bursty (active mode) and less bursty tra.c (passive mode).


C++ namespaces and Java packages are modules, and nested or inner classes can also be used to emulate modules to some degree.

none of these mechanisms support late binding.


Thequeriestypicallyre.ecttheday s news and popular culture, so they are broadly relevant for evaluating SMSFind.

a majority of Google Trends queries are open-endedin a waythatSMSqueriespresumably would notbe.


There are, however, some layouts [7] that may extend an object representation to both sides, so that for instance a class may share its dynamic type data with two of its bases.

an ef.cient implementation of such layout would need to know the derived classes of a class in advance, which would impede separate compilation.


Model Transformation by Demonstration Yu Sun Department of Computer and Information Sciences University of Alabama at Birmingham Birmingham, AL 35294 yusun@cis.uab.edu Abstract A common approach toward model transformation is to write transformation rules in specialized languages.

their usage may present challenges to those who are unfamiliar with a specific model transformation language or a particular metamodel definition.


The pure computation part of the code, i.e, code with no side effects, including garbage collection, is executed by the normal Erlang run time system.

the side effect part is executed under the McErlang run time system which is a complete rewrite in Erlang of the basic process creating, scheduling, communication and faulthandling machinery of Erlang, comprising a signi.cant portion of the code of the model checker.


Quality assurance provides broad coverage but fails to handle many corner cases, which is why bugs arise in production in the .rst place.

mutable replay isolates actual bugs that occur in production.


In [4], Gupta and Sofia proposed hybrid slicing technique which uses limited amounts of control flow information.

it does not address the imprecision in data dependency computation in presence of pointers.


Thus, nodes forwarding the reply can determine the source position at any time.

the source might change its direction or speed at any time.


This difficulty is not an issue with Definition 1.

in Definition 1, if the PF-set is invoked many times, there is a concern that the resulting memory consumption will be excessive.


In comparison to pure enumerative (grammar-based) input generation, CESI generated several orders of magnitude fewer inputs, and achieved slightly better (6% better) coverage under the same testing budget.

if one discounts the test input generation time, the time to run the test suite was 5 minutes for CESI, against 2.5 hours for enumerated inputs.


To execute a read operation, a transaction has to obtain a shared read-lock on the target data item.

for write operations, exclusive write-locks are needed.


Thread-level speculation parallel data structures and algorithms is often required.

we demonstrate large parallel speedups on a diverse set of uniprocessor applications, while changing or adding very few lines of code.


Android mediates access to protected resources using a permission system.

its effectiveness hinges on app developers correctly implementing it.


proposed the use of appropriate assertions in the speci.cation of web applications.

while they allow designers to specify invariants prohibiting any dialog synchrony breaks between client and server, they leave open how implementations should actually guarantee this the suggestion to disable the browser s history feature would hardly be acceptable in practice, and does not solve the problem of multiple windows.


If p is swapped out before executing line 7, all other threads can continue to add requests to the end of the list, but no thread can go over the list to execute the requests.

several operating systems allow a thread to give a hint to the scheduler that it will soon execute a critical section[9]sothatthe scheduleravoidsswappingoutthis thread.For instance, Solaris provides schedctl start to announce that a thread will soon access the critical section, and schedctl stop for informing the scheduler that the thread has .nished executing the critical section.


In this section, we present our annotations as a type system for Java programs that provides global guarantees about aliasing.

adding alias annotations to a large legacy program may require significant effort.


Libraries such as Atlas [35], FFTW [19], and SPARSITY [24]; frameworks such as PERI [36], SPIRAL [28], and Green [7]; and languages such as PetaBricks [3], allow the programmer to set up an application to be autotuned for a given microarchitecture.

while o.ine autotuning provides great performance gains, it has two major problems.


We model tlam and tapp analogous to lam and app.Thefunctionthatisprocessedisafunction mappingtypestoterms,i.e., a polymorphic term.

the .rst parameter of tlam and tapp states thedomain(ontypes,i.e,itis akind,inthe example: *), while the secondparameter states the codomain.the codomain candepend onthe respectiveinhabitant of thedomain,i.e.,itis a family of types indexed by types.


Text messages (or persistent chats) could be attached directly to the piece of code to which they refer, like in Anchored Conversations [3].

for synchronous collaboration, especially when using the audio channel, support for gestures becomes important, which will likely also require some form of screen sharing, such as that offered in VNC.3  5.


Thus, in a first attempt we focused our study on Feature-based Analysis and Survey types of evaluation which are common for both works.

the evaluations based on the Survey type present some limitations.


The detection of hot .elds and the colocation in the garbage collector need no changes.

the actual inlining algorithm must take the di.erences between objects and arrays into account.


In the program in Figure 3, communication on b cannot occur simultaneously with that on c because T2 forces the two communications to be sequential and therefore b and c can share buffers.

there is no ordering between channels a and c; a and c can rendezvous at the same time and therefore a and c cannot share buffers.


Nor is it completely apparent that they should, since these semantics appear to have been largely accidental.

an understanding of these issues does seem to be essential to any revision of the current rules.


However, pollution proliferation is not dependent on any underlying network topology, since users typically select versions from a nearly complete list of available versions in the P2P system.

propagation of some worms (e.g, e-mail based) is in.uenced heavily by the social links of nodes involved [15].


Any extern values not de.ned inside the program are also conservatively treated as dead.

we do not give up on recording dead values so easily.


Such a proxy would function to preserve the application .ow semantics, like packet ordering for TCP whenever used for transport layer data transfer.

this might entail collaboration between multiple (W)ISPs that provision network access.


<% activate greeting textInputField empty %>  the notationmustbeusedbecausetheconstructedXHTMLfragmenthas(atleast)twonodes,atextnodeandaninput elementnode.The notationalsoprovidesadifferentnotationforempty: empty =   A.nalexampleforacodeblockinsteadofanattributevalueconsidersafunctiontoconstructanalign attribute: alignment :: String -> WithHTML x a alignment what = ]> Thereisaslightcaveatinusingthemarkupsyntax.Thetext constructorfortextnodesautomaticallytranslatesillegalcharacterslike<,&,etctotheirXHTMLentityreferences.Usingthemarkupnotation,theXMLconventionshavetobeobservedinthesourcebecausethetextispassedonverbatimwithoutfurtherprocessing.

theastutereadermaymisssyntaxcorrespondingtoanattributehole,asintheuseofat inthisexample: let at = attr "href" "http://www.w3c.org" in --THIS IS ILLEGAL: >The W3C thisfunctionalityisnotrequiredbecauseWASHdocumentsequencesalsocollecttheattributesfortheenclosing element.Thatis,theaboveelementshouldbeprogrammedas let at = attr "href" "http://www.w3c.org" in --THIS IS CORRECT: The W3C andthesameresultwouldbeachievedbyplacingtheescapeanywhereelseinsidethea element.


Ideally, nodes would be able to compute the value vi of an ADU locally, as the data is sampled.

since the value might depend onfactors other than the ADU s data, such as data computed at other nodes.


A major advantage of ADP is that the logic of the algorithm can be designed largely without being concerned about e.ciency.

once the tree grammar is designed, the current implementation requires to add e.ciency annotations to the grammar.


The satis.es relation between slices s,s 0 can be therefore interpreted as the logic constraint: s!

s 0 (4) consider the case when there are multiple slices s 0 i satisfying s, for i =0,1,...,n. For instance, each slice might contain a production of the form B !


This has two important effects by doubling the DRAM size, fewer DRAMs are needed per memory DIMM, and fewer DIMMs are needed for a given amount of system memory capacity - reducing the power per GB for memory.

newer technology DRAMs are initially pricey because of supply limitations so it may not be possible to take advantage of this right away, and in any case, a careful tradeoff needs to be done for the price vs. power tradeoff.


One approach where the con.guration of software and hardware featuresis considered within one product linewas suggested in [17].

only requirements are mapped and only one single feature model is used, which limits the differentiation between software and hardware features.


The flexibility of MAUI is rooted in the basic flexibility of the underlying Swing toolkit; since our goal was to add transparent groupware functionality to this existing layer, flexibility of the underlying tool is not reduced substantially.

we did determine a set of limitations to applications built with MAUI: MAUI uses a glass pane to implement menu transparency and telepointers, so an application developer cannot use their own glass pane in a MAUI application.


An instance for FunType is the following, with proofs omitted: instance Polynomial FunType where pcode = P I I pto = toFunType pfrom = fromFunType ptoFromInverse = ... pfromToInverse = ...  5.2 Universe embedding To write modular functions for polynomial functors we proceed in the same way as in Section 4 by showing that Polynomial is closed under coproducts and building the functionality of the SPF type class generically.

that would duplicate the generic functionality and would prevent us from using polynomial functors with containers.


As discussed further in Section3.2, the work product is the key element (direct evidence) to characterize whether an agile methodmeets or not the MR-MPS processes.

it is im ortant to clarify that there may be situationsin which a work product in the agile method meets only p artly an expected result, due to the nature ofagile methods that tend to produce only enough documentation for software.


Broadly speaking, access control in common programming languages is expressed using modifiers on their declarations.

when interfaces are defined in these languages, the modifiers can not be applied to the items in the interface2.


SCRIPTING IN THE GRID The bene.ts of using an interpreted language for coordinating applications while maintaining their core in a compiled language have long been discussed in distributed programming [18] .

in high performance computing, probably due to the focus on e.ciency, emphasis has been on ignoring multilingual programming.


Most of the students, some of them after using scratch paper, correctly decided that this variation would work.

many students who disagreed invoked StudcnCrConstructed Rule 3: Numbers or numeric constants are the only appropriate actual parameters corresponding to integer formal parameters.


As more censorship-enabling systems are deployed, we will see increased usage of censorship-resistance technologies tools designed to circumvent the technological filters.

the use of currently-deployed censorship resistance systems such as Tor bridges [14] and Freenet [10] is problematic if they are explic itly proscribed.


very high in order for the agent to score any points.

if holes never disappear, the agent would achieve a perfect score, even when ~ is very low.


They are computed on one attribute subject to a certain condition on the other.

this condition has to be speci.ed in advance and the goal is to compute the aggregate in the streaming setting, thus the problem is fundamentally di.erent from ours.


These can be useful for representation invariants, which refer only to internal private state.

theories are more effective than assertions for expressing and exploring general statements of externally-visible behavior: Theories can safely mutate the state of the objects under test, which is of course too dangerous in in-line assertions.


To enable a more vigorous approach to specify, apply and analyze pattern leitmotifs, previous researchers [38,12] attempted to suggest some more precise specification languages to pattern leitmotifs.

their suggestions erroneously impose excessive constraints to the leitmotif specifications.


Because the runtime cannot distinguish whether more than one variable point to the object, named remains 2 in the original object.

2.2 Performance of Type I Codes Type I R programs suffer from many performance problems that it has in common with of other interpreted dynamic scripting languages, including Dynamic type checking and dispatch  Generic data representation  Expensive name-based variable lookup  Generic calling convention (e.g., heap-allocated variablelength argument list)  R also introduces some unique performance issues that are speci.c to its semantics, such as Missing value NA number support.


An energy-e.cient algorithm for node discovery is also presented in [9].

the emphasis in that work is on detecting the temporal patterns of node arrivals and scheduling a wake-up based on expected hourly activity.


This can be accomplished by replacing listE by BagE, the bag-equivalence constructor: fsEq1 :: Equiv FilesystemElem fsEq1 = MapE fromFs (SumE eqString8 (PairE eqString8 (BagE fsEq1))) Using SetE instead of BagE we can even allow indadvertently duplicated .le names and subdirectories and still identify them as duplicates: fsEq2 :: Equiv FilesystemElem fsEq2 = MapE fromFs (SumE eqString8 (PairE eqString8 fsEq2)) Now we have the desired de.nition of dirEq: dirEq = SetE fsEq2  4.2.3 Skipping the cross-product In the previous two examples we have used the SQL idiom of using self-join before .ltering pairs for non-duplicates.

it turns out that for this particular pattern of queries, it is not the most ef.cient approach to follow the SQL idiom.


Results have been taken in a SGI Origin 2000 with 64 processors for availability reasons.

we consider that they are quite representative of most of the current CC-NUMA systems, and that the results obtained could be extrapolated to larger systems because the migration mechanism decisions are distributed, and from that, it should be easily scalable.


For most of the benchmarks, the result shows that runtime privatization incurs much higher time overhead than ours.

there also exist a few programs that issue just a small number of private memory accesses, for which the monitoring overhead is low for runtime privatization.


Comparing to the Phi-Algorithm, the runtime improvements are not that big (up to 7.98% with an average of 1.78%).

our algorithm leaves less than the half of the costs (and af.nities) behind.


In this case, a fault-tolerant design could be a single two-of-two system.

service requirements of the system are much higher.


hanspeter Mössenböck Institute for System Software  Johannes Kepler University Linz, Austria hanspeter.moessenboeck@jku.at  while object allocations produce a direct and easy to understand performance impact, the costs of garbage collections are easily overlooked.


Thus, browsing (inspection) by the user is necessary.

many properties are known in advance and relatively easily formalized; the systematicity and consistency of automation is a signi.cant advantage in that case.


Initially, partial marks were awarded for its support of the activity.

once discussed, it was agreed that support was too limited.


Thus no overhead is incurred during this process.

if the write event is a user input or a local computation, the MH first forwards a copy to the MSS to be logged and does not apply it locally until an acknowledgement is received from the MSS.


By incorporating many perspectives, their tools can provide an extremely rich picture of organizational software activity.

since they based their analysis on change records, they are not easily able to analyze the structure of the software system itself and to combine this view of the activity with the artifact (although change records do frequently indicate structural units).


The highest quality evidence comes from one or more welldesigned and well-executed randomized controlled trials (RCTs) yielding consistent and directly applicable results.

rCT evidence can be downgraded to moderate, low, or even very low quality evidence, depending on the seriousness of the limitations of the study.


That s why system call in PV guest is slow.

as the number of cores and the amount of DRAM in a computer increase, the requirements for virtualizing the CPU and dram are not necessary.


HTML), this could not be an important drawback, since the user is free to browse along the links in any order.


If tasks were designed with runtime architecture and schedulability in mind, a single task should be assigned only objects handling a single event stream [1][6].

in real systems, tasks often contain objects handling more than one stream of events.


As a result, for this class of applications software fault tolerance is an extremely attractive solution, since it allows the implementation of dependable systems without incurring the high costs coming from designing custom hardware or using hardware redundancy.

relying on software techniques for obtaining dependability often means accepting some overhead in terms of increased code size and reduced performance.


Previous studies [8-15] state that Unified Modelling Language (UML) design models provide a means to manage the increasing complexity of programs, which in turn assist developers in understanding and managing them.

nothing is said in the literature about the impact of making available UML design models that show different kinds of composition details, which allow us to express the nuances of its properties (e.g., composition scope).


Note also that it is more .exible than CUT as it can be used to limit the search to a window of K solutions.

in contrast with CUT, the order in which these .rst solutions are found is arbitrary.


It can also be used for brainstorming about the why, what, who, and how of the community.

for making the decisions about where the community should go, and especially for the coordination of tasks it may be less suited, at least when used in isolation.


However, we could handle only symmetric SMIs in our prior work.

that limitation is eliminated in the current work which can handle general SMIs, which enables us to handle monitoring applications such as Memcheck and Eraser.


Synthesising Graphics Card Programs from DSLs Luke Cartey Rune Lyngsoe Oege de Moor University of Oxford University of Oxford University of Oxford luke.cartey@cs.ox.ac.uk lyngsoe@stats.ox.ac.uk oege.de.moor@cs.ox.ac.uk  Abstract Over the last .ve years, graphics cards have become a tempting target for scienti.c computing, thanks to unrivaled peak performance, often producing a runtime speed-up of x10 to x25 over comparable CPU solutions.

this increase can be di.cult to achieve, and doing so often requires a fundamental rethink.


If the design model of the Observer pattern in List 2 is changed, List 3 might violate a new Archface re.ecting the new design.

in such a case, a programmer has to modify the code to conform to the new Archface.the design model should be changed when the code is changed.


Cooperative threads are expected to yield soon after their timeslice deadline, but if they fail to do so within the slack period, they are preempted and demoted.

second, based on our programming model, cooperative threads are normally expected to sleep by calling oop poll.if a thread blocks in the kernel for any other reason, then it will not have a release time and is demoted.


To calculate the equivalent size in C, we multiplied the software size in Erlang with 3.2, Java with 2.4, and IDL with 2.35, as the practice is in the organization.

we found that other studies use other numbers.


The median and 90th percentile of the distribution were 30 seconds and 2.2 minutes, respectively.

the distribution also has a long tail: the worst-case latency was 9.1 minutes.


Conservatism and Pinning The Immix conservative collector designs apply to any setting with ambiguous references, including fully conservative systems.

the major performance advantage comes from opportunistic copying of unpinned objects; opportunities which are nonexistent when all references are ambiguous.


Otherwise, when BM C (A', 0) becomes unsatis.able, A' is precise to frame 0.

given that the gates of A' that do not appear in the unsatis.able core of the formula (returned by the underlying SAT solver) are not needed to prove the absence of counter-examples of length 0, these gates can removed from A' resulting in a smaller abstraction, that is still precise to frame 0.


Invariant preservation for looser synchronization relation i.e., .1 .2, we can conclude that if .2(B)is deadlock-free, then .1(B)is deadlock-free.

we can still reuse the invariant of .1(B) as an over-approximation of the one of .2(B).


We can systematically implement thread safety mechanisms inside components.

it is generally costly, especially if the component, in its execution context, does not require it; 2.


If agreement is used, the fault-free overhead is O(allreduce) and in case of fault the overhead will be roughly O(allreduce × num retries + allreduce).

if agreement is not used, implementations may be able to optimize the algorithm to remove the trailing fault-tolerant collective in many low-fault cases.


(b) Asynchronous unidi-(c) Asynchronous unidi-(d) Asynchronous bidi-(e) Synchronous service rectional service at the rectional service at the rectional service sending node receiving node  Figure 3: Generic and customized service installation scenarios CLOSED (.nished) state before activating the new service, interrupting (freezing) the running service and conducting the replacement immediately will speed up the adaptation process.

to preserve a valid service, this implies transferring the internal state of the old TCP service to the new one, before activating the latter.


For example, it is not possible to override the behaviour of a polytypic function at some speci.c instance (without changing the de.nition of Rep).


Similarly to their work, our analysis is demand-driven as we analyze the program starting from the original call.

our data reachability analysis propagates information in terms of objects instead of classes which will result in more precise analysis results.


In general, the code quality produced by the generated compiler still cannot compete with the handwritten highly optimized compiler.

the major focus of this work is to push the automation of compiler generation to its edge.


We found out that the two techniques did not differ signi.cantly in terms of concurrency errors, number of LoC and time to develop the resulting programs.

for programs where developers made only non-concurrency-related mistakes, STM programmers .nished their assignments quicker.


In this case, the loop is unrolled to the max- imum degree, as discussed above, and the strip mining loop is avoided.

because the total number of registers is now less, unrolling to the maximum degree turns out to be a worse decision.


Following this premise there should not be restrictions on the introduction of aspect behavior.

this is not consensual [10] [33], and recent work [40] claims that the obliviousness is too broad and naïve, and proposes that it should be restricted to noninvasiveness.


Moose is well known by a relatively large community of academics who have built tools on top of it, its bus factor is thus relatively high.

all those satellite tools are much less sustain able: they are typically developed by one or two students for a thesis or to support a paper.


Note that many conditional rules become unconditional now, and that the conditional parts of the remaining conditional rules have been greatly compressed.

there is a much simpler variant of the transformation (RT , µ) .


Unfortunately, little reasoning can be done about shared references, except that they may not alias non-shared references.

shared references are essential for interoperating with existing run-time libraries, legacy code, and static fields, all of which may refer to aliases that are not confined to the scope of any object instance.


Resource management approaches, e.g., Real-time CORBA [5] and Condor [6], have offered facilities for configuring and reconfiguring of resources to ensure that activities running on a device have adequate resources.

none of these models addresses the issue of cross-domain resource distribution.


In fact, on 16 processors, all three programming paradigms have similar runtimes across all data sets.

on 64 processors, performance differences between the two basic programming schemes begin to emerge.


Of course, one can obtain a technically well-de.ned treatment of dynamic binding and delimited control by choosing one of the three inequivalent implementations of abort above.

such a choice is purely arbitrary: the trampoline optimisation is no more and no less at fault as the non-trampoline pessimisation for a.ecting how dynamic variables behave.


There are many static analysis tools available publicly and commercially to detect bugs in the program [10, 3].

a complete static analysis of the program through all the paths is not always possible, as for e.ciency reasons many static analysis tools limit the analysis to few paths or maintain less information during analysis [1].


One approach for solving this problem would be a restart of the whole system with serving input actions with recorded input and ignoring output actions.

this would be very inef.cient in combination with searching all possible schedules since the system has to be restarted for every possible schedule.


2.5 Challenges According to our preceding analysis, the expressive power of a propositional logic based language and the nature of a static anal-ysis based approach make fault detection precision impaired.

a migration from a propositional logic based language to a first-order logic based language is not straightforward.


Transactional memories with abstract locking could be used to simplify the task of parallelization [24].

both approaches often require the relaxation of the original semantics of the program.


Determining when the steady-state has been reached is impractical since the branching possibilities of a program are vast: there is always the possibility that a previously unvisited branch may later be involved in a hot loop.

by running a program for a large number of iterations, we increase the chances that we are at  or at least near the steady-state.


The propositions for the latter we are aware of (i.e.,[1,18,21]) do not allow high guards in loops,and extensions to more than two privacy levels seem not straightforward.

the extension of the model integrating the speci.cation of scheduling policies as in [5, 21] seems interesting3 .


Figure 5: Screenshot from Journey to the Moon The implementation of the game was successful, and our version corresponded correctly to the original implementation in Lua.

some interesting problems were encountered, which led to improvements in the original design of the VSE.


Thiswould allowdatatobebroadcast directly to tasks, rather than forcing the use of POs between the tasks.

the PO broadcast semantics useprotectedprocedurecalls, whereasthetasksonly offer entries.


The .gure illustrates that O(1) and BFS allocate a fair percentage of the CPU to every process: each of the eight processes obtains half of a CPU.

cFS does not always allocate a fair share to every process: in some runs of this workload, some of the processes receive less and some correspondingly more than their fair share.


During development, we can not know the amount of messages that are sent and received during runtime.

we must reserve enough buffer, to make sure that the node receiving the messages has enough time to process them.


interpretationId need not be speci.ed if there is only one interpretation for the model interface.

only one concrete element may be given an isA mark for a single element in any given interpretation.


Cactus (2) and GridWay (14) do not use performance models.

these frameworks are only suitable for sequential (Grid-Way) or single-site applications (Cactus).


During early exploration, and in unfamiliar domains, there might be no known guidance to give.

once a structure has emerged or is known up-front, as when analysts work within an analysis framework developed on previous projects, guidance can help the user work within it and conform to it.


In the current prototype systems, regions are primarily loops that have signi.cant samples within an interval of 1Inter-region optimizations are rarely performed due to the complexity of analysis in a runtime optimization system.

with the help of compiler annotations, future dynamic optimization systems may deploy inter-region optimizations, such as instruction cache prefetching for the next incoming phase.


In the quest for huge computational power, hardware engineers are building multi-core systems because multi-core processorsoffer signi.cantly greater parallelism, and performance relative to uniprocessor systems.

multicore architectures bring new challenges to the system software (compilers, OS).


[Samples] are useful when you become experienced, but wasn t a starting point.

would leave example programs that are there; they will be helpful if you want to do a complex program.


If this length is greater than the maximum size (as in the case of the EVIL OVERFLOW DOS variable), the computation uses the pam syslog function to log this event.

the computation does not exit the loop and, instead, keeps logging the same event in every subsequent iteration.


Such data locality is a key advantage in MapReduce and Dryad, as it signi.cantly reduces network traf.c.

such a scheduling strategy can lead a chain of vertices in the EPG to be scheduled on a single computer, as each downstream vertex is scheduled on the computer that generated its input.


Thisis mostlyduetothefactthatscienti.c applications are typically written in Fortran or C/C++ for performance and scalability reasons, while a large body of the AOP research is based on Java-based implementations.

itis encouragingthatthe overhead ofJava(e.g., garbage collection overhead) is becoming acceptable for computationally intensive tasks with the increasing hardwareparallelism[3], which canleadtobroader recognition of sophisticated software engineering methodologies such as AOP in the scienti.c and high-performance computing domains.


We consider events from different devices rather different, so we model each device and the events they generate in a separate way.

contact proposes a uniform event, and extensions if they are necessary.


Hence, the original MVC design pattern works like a closed loop wherein the view talks to the controller, which connects to the model, and this in turn talks to the view [11,16].

the eLC2 collaborate the reusable services in the model that is wrapped inside the reconfigurable controller which acts as an interface integrator and transforms the request/response parameters of the end user view to the model.


This is an easy work which most developers are familiar with.

the potential defects in the source C++ objects will be transferred into the generated domain model.


The current XML++ constructs for templates makes it di.cult to use traditional XML pages for the purpose of inheritance as we discuss here.

xML content can be used as part of the templates and classes as described in section 3.3.


The latter is realized through integration of original applications and data sources, particularly in terms of widgets, into the same graphical space (e.g., browser), in which participating applications and data sources can be perceived and identified by the end-users.

from a technical point of view, we categorize mashups with respect to the source and integration approach as depicted in Figure 1. services data sources tools Figure 1.


As shown in this figure, the performance of naïve-A* method is worst of all due to its wasteful iteration.

our method and post-Dijkstra method show good performance because they expand road segments one by one.


3.1 Requirements analysis based on KAOS KAOS provides an adequate requirements description capability even if the target application is MAS, when we extract the functionalities of the system, which is one of the main activities of the requirements analysis.

certain constraints should be used when connecting the requirements description with the MAS architectural model.


Nowadays, there are several concern identification techniques [24, 27], which can also be used to support the concern projection process.

concern projection is often performed manually for several reasons.


Code clone detection tools .nd only structurally similar code fragments.

our method retrieves similar fragments based on the correspondence of identi.ers; thus the retrieved results might not be structurally similar.


We modified the implementation so that GC can be independently triggered either for space or for locality optimization.

when GC is triggered, unless the policy says it is for space only, it will attempt to do both at the same time, with one exception: when it is triggered to collect only Generation 0 objects, locality optimization will not be applied.


The simplest software counter-measure is maybe to ban any lookup table from the implementation of the AES and use its plain mathematical expression instead.

this kind of implementation is highly ine.cient and is exposed to other kind of side-channel attacks (see [17] for example) that did not exist when relying on lookup tables.


Also as there are no inequality constraints for ttab elem,we have T0(ttab elem) =(m,32), and similarly for tb1 there are no zero blocks.

due to the bitmask, T0(tb1&130 02 ), and hence T0(tbase ) has two zero blocks, as the constraint tb1&130 02 =tbase is the only inequality constraint with tbase on the right hand side.


A path can also be divided into sub-paths or segments.

not any partition of the whole path into sub-paths is meaningful.


As we did not compare multiple customized products, the Crawler did not generate recommends relations.

the consultant identified one recommends dependency based on the textual requirements description.


In thisdialog size, subject(b) and(c) also obtain similarlayouts.

especially about(a),itis not seen the precise relation between the desirability and layouts because the constraint of widget sizes is stricter than the constraint of the desirabilityin sucha smalldialog size.


Katherine Isbister and Regina Bernhaupt edited two books, respectively, to discuss the current theories and methodologies within the field [3, 4].

since this community is new, there is not a cohesive understanding of the state of this research art and science.


We realize that modeling expertise is in itself an interesting topic of research [15], and hence we also experimented with a slightly di.erent measure of .le familiarity, in terms of the proportion of total code in the .le that has been updated by the developer, compared to the updates made to the .le by other developers throughout the evolution history of the .le.

when we computed both the measures and cross-checked with a team of developers who were part of the TA case study, we realized that equating .le expertise with proportional code updated, may result in grossly inaccurate familiarity levels since it ignores familiarity that a developer gains of code submitted by others in course of making his/her own updates.


Thus, reducing the collector s work and letting mutators get more CPU time should result in reduced cache miss rate.

there is an interesting additional factor: elimination of coherency cache misses.


Its after-returning advice assumes the join points are constructor calls; and the concrete aspect ConstructorTracing, Listing 5: ConstructorTracing.java (1) public aspect ConstructorTracing extends ReturnValueTracing {}  would trace newly constructed objects.

it is an error to put after-returning advice on a join point that does not return a value or returns a value of an incon'ect type.


The operating system SwarmOS [6] has a similar in tention to our project.

it follows a bottom-up programming approach.


In the case that a given node (source) holds a particular block which is required in other parts of the network (sinks), network coding will ensure that such block will propagate in a number of rounds equal to the distance between the source and the sinks.

if no coding is used (or even if only source coding is used), then, the nodes in the path may waste several rounds downloading blocks that the sinks already has.


If the ID of node A is 100 (and ID Cover 1**) in the example of Figure 4, the ID space cannot be made perfectly uniform under the constraint that the ID Cover of each node is a single vector.

the entire ID space is su.ciently extensive compared to the number of nodes 3 .


It is possible that only a subset of the roletypes generated by this combina- tion will be present in B/A, as some roleJ:ype rB/rA may be eliminated because of contradictory conditions or results specified in rB and rA.

if there is any contradic- tion in the combination of a process of A with the roletype of B chosen to be bound with it, then we cannot create B/A at all, since B/A needs all the processes of A and B.


For example, the attribute GL_REPLACE can be sent to the glStencilOp and glTexEnv subprograms.

the set of legal attributes for glStencilOp are GL_KEEP, GL_ZERO, GL_REPLACE, GL_INCR, GL_DECR, and GL_INVERT, while the legal attributes for glTextEnv are GL_MODULATE, GL_DECAL, GL_BLEND, and GL_REPLACE.


As a consequence, improvement in productivity and reuse could also be promoted.

each aspect of these research must be investigate in broader and deeper way; for instance, through conduction of qualitative and quantitative evaluations and experimental studies in the industry must be certainly conduced.


(max) able, since X can always interfere with the normal execution of S getting the overall system stuck, so that the .nal message mF is not delivered.

still keeping the intuition behind Formula 1, we can weaken the property to the conjunction of Formulas A1 and A2, where: A1 When there is not an intruder, the orchestrator always drives the services to correct termination.


Standards such as ZigBee1 [30], Zwave, X10, and Echelon may also support interoperability of low-power devices.

each of these standards is tied to a single physical layer standard and, these standards need application layergateways to connect to the restofthe Internet.Wefocusonan alternativeapproachthatisbuilt on widely-used open standards such as TCP/IP and web services.


HotWave runs on any standard JVM and restricts the AspectJ programming model; e.g., around() advice and explicit structural modi.cations of classes, i.e., socalled static cross-cutting, are not supported.

hotWave2 is based on a prior version of the DCE VM [44] that allows the necessary class transformations in support of around() advice and static cross-cutting.


Therefore, for a program with pointers, SSA conversion requires points-to information to enumerate the indirect writes to variables through pointers, so full SSA conversion cannot be done before the points-to analysis.

since top-level variables cannot be accessed through pointers, it is possible to convert the top-level variables into SSA form prior to points-to analysis.


Sensor nodes are considered to be heterogeneous in terms of the supported sensing functions, since a sensor node can be equipped with one or more sensing devices.

the sensing range of sensor nodes is considered as the same value.


This suggests that OSNs, similar to so many other innovative services and products, may also have a natural life cycle.

our knowledge of the details of their life cycles remains very limited.


We cannot yet report data on model maintainability.

it is obvious that support for keeping variability models and formulae consistent after changes is necessary.


2.1 Hardware heterogeneity Regarding hardware heterogeneity, J2ME is one of the software technologies available for developing applications that can be used on different resource-constrained devices like mobile phones or PDAs.

each hardware device has different capabilities and resources, so the same AmI application has to be able to be adapted to different execution environments.


Various specialized algorithms for collecting the garbage have been developed for the actor model [14].

the most relevant work is [15], which describes how to implement garbage collection for actors in terms of standard garbage collection algorithm by translating the actor reference graph to a passive object reference graph.


Furthermore, Hammond and Davis [8] demonstrated that domain speci.c languages lend themselves better to the problem of specifying gestures.

a paper by Hoste and Signer 1The same holds for other input modalities, such as speech or deviceorientation, which are not relevant to the speci.c gestures described in subsection 2.1, but in general might be jointly used in a single gesture speci.cation.


There are a few user programs that lie in that region, so it is a good thing that region has been tested.

many user programs lie in a region at the bottom of the display, where there are no test suite programs covering that combination of functions.


It may not be clear how one can show the absence of certain inclusions in a modular setting, since a program extension can always declare more inclusions.

inclusions are only declared with in and maps into clauses, which are part of particular attribute declarations.


All previously existing technologies such as a proprietary communication protocol, (D)COM, CORBA, Java, and a home-grown HTTP/XML solution could either not fulfill this vision or did not meet all requirements of a truly Service-Oriented Architecture (SOA).

web services can be characterized as self-contained, modular applications that can be described, published, located, and invoked over a common Web-based infrastructure which is defined by open standards.


Incorporating all of these in our model would be both extremely tedious and onerous.

we also do not want to oversimplify our model and run the risk of obtaining results that do not work in actual Prolog systems.


The EvalMult module combines these two extensions by composing EvalMod with MultMod.

the pure composition (EvalMod &*MultMod) has a gap in functionality because the Times class does not implement the eval method.


Our target security assertions are stated in terms of principals U, C, IP, and RP that are not compromised by the attacker.

the interface Ipub includes the X.509 certi.cates of IP and RP, and the user credential and card belonging to a bad user.