Creating a delta that depends on prior deltas requires knowledge about its predecessors, e.g., for modifying elements that have been introduced by a previous delta.

this may be supported by tools that automatically check the consistency of the newly added delta.


Our model checker works best when each small step of evaluation reads only a small part of the program state.

the above substitution reads the entire method body.


If the skewing is only moderate where faster nodes still .nish before slower nodes, CALB would work as described.

cAS s execution time ratios would have to be adjusted by the data skew factor (e.g., if CAS s mapComputeRatio ratio is 3:1 and faster nodes have twice as much data as slow nodes, then the new ratio would be 1.5:1).


Compilers, linkers, analysers and the like are all traditionally considered to be out of time processes.

when integrated into a dynamic, real-time, causal development process, such tools must be reactive, complying to task-domain time and concurrency constraints as well as being amenable to reactive updates from the environment.


In order to recover from situations where an Android application was terminated by the system, the Android platform already contains a mechanism for storing and recovering application state.

java objects representing application state and data are not persisted automatically.


Conclusions and Future Work Refactoring tools have become popular because they allow programmers to safely make changes that can affect all parts of a system.

such changes create problems for the current SCM tools that operate at the .le level: refactorings create more merge con.icts, the history of the refactored program elements is lost, and understanding of program evolution is harder.


Therefore, the contribution to the mean number of jobs in the system consisting of jobs in [][] NSQ the Exponential class is precisely EExp+ EN.The Expzero-sized jobs only contribute to the mean number in queue.

since the scheduling policy is size-independent, the waiting time distribution of a zero-sized job is the same as the waiting time distribution of a job belonging to the Expo C2-1 nential class, but the arrival rate of zero-sized jobs is 2 times the arrival rate of the Exponential class.


From a language standpoint, s-COMMA is as expressive as MiniZinc and Essence, in fact these approaches provide similar constructs and modeling features.

a main feature of s-COMMA that strongly differences it from aforementioned languages is the object-oriented framework provided and the possibility of modeling problems using a visual language.


These methods allow users to consume exactly the content in which they are interested.

innovations such as Personal Video Recorders (PVRs) and mobility features allow consumers to access content at their own convenience, both in terms of time and place.


In actual practice, the researcher served as the sole author and the rest of the team only left comments.

the reliance on live meetings and an online document substantially improved the overall efficiency and clarity of communications compared to former studies in which email and offline documents had been more heavily relied upon.


XQuery 1.0 [16] and XSLT 2.0 [7] share a lot in common: they share XPath 2.0 as a common sub-language and have the same expressiveness.

they are based on fairly different programming paradigms.


Separating Testing Concerns by Means of Models Dirk Wischermann Friedrich-Alexander University Erlangen-Nuremberg Systems Software Group Erlangen, Germany dw@cs.fau.de ABSTRACT The number of potential execution paths through software usually increases dramatically with the size of the program.

many coding errors only appear while executing few particular paths.


Example: threading state in parallel Perhaps the simplest example of a Par-monad transformer is the standard StateT monad transformer (provided by Haskell s Control.Monad.State package).

even if m is a Par monad, for StateT s m to also be a Par monad, the state s must be splittable; that is, it must be speci.ed what is to be done with the state at fork points in the control 8 By the original , we refer to 1.x releases of LVish, e.g., http:// hackage.haskell.org/package/lvish-1.1.2.


In fact, they propose some new refactorings from Java to AspectJ.

they only discuss the refactoring as a whole and the conditions to apply the refactoring.


In classical cryptography, two communicating parties, say Alice and Bob, try to con.dentially communicate the content through a non-trusted channel, while an enemy, say Eve, tries to obtain the content by listening to the channel and applying cryptanalysis to the acquired data.

in the case of content protection, Alice tries to send the content securely to Bob s trusted device (software or hardware), while both Eve and Bob are considered enemies.


Therefore, we ported the application to this hardware family.

in order to keep changes to the application small we simulated for this evaluation a .ctitious Mica2-like node that is like the Tmote Sky nodes equipped with more RAM.


5.3 Load Balance Consistent hashing is used to assign partitions to servers in order to automatically balance load among servers when server con.guration is changed.

this method may lead to imbalanced load as a result of imbalanced distribution of partitions among a small number of servers.


Backward References Finally, we enable the type system to check whether all classes, class re.nements, methods, method re.nements, and .elds contain only references to features that have been addedbefore, which we call backward references.

the type checker rejects programs containing forward references.


s systems allow storing open terms in global variables that can (potentially) outlive the scope of the variables theycontain, which cannot be done in Mint.

we are not aware of any use for this technique, apart from examples by Kim et al.


It is worth highlighting that reference architecture and MPL have similar goals regarding improvement in reuse and productivity.

the main motivation of this paper is that there is a lack of research that investigates how reference architectures can be applied in the development of MPL, specially to develop SoS.


By comparing the time spent to answer questions correctly with GenArch+ and pure::variants, we observed that the use of the framework-provided abstractions improved the comprehension of the con.guration knowledge speci.cation, by allowing the participants localizing the con.guration knowledge in a reduced time.

there is no signi.cant difference between GenArch+ and CIDE in terms of the time needed to localize and understand the con.guration knowledge speci.cation.


GreenHadoop is most closely related to our own Green-Slot [9], a green energy-aware scheduler for scienti.c com puting jobs.

greenSlot relies on extensive userprovided information about job behavior, assumes that persistent data is always available to jobs regardless of the servers power states, and does not manage the cost of peak brown power consumption.


Stephen Kou Jens Palsberg UCLA Computer Science Department University of California, Los Angeles Abstract Consumer electronics today such as cell phones often have one or more low-power FPGAs to assist with energyintensive operations in order to reduce overall energy consumption and increase battery life.

current techniques for programming FPGAs require people to be specially trained to do so.


Moreover, PL Components are generally contained in these layers and tiers implementing functionalities provided by these layers and tiers; thus, Architectural Styles seem not to be useful.

architectural patterns suggested in the reference architecture could be used to speci.cally design these components; thus, Architectural Styles and Patterns are partially used to design PL components.


Veri.cation techniques based, e.g., on model checking, may then be used to check properties over the speci.cation of the family as well as over the products that may be derived from the behavioural models.

specifying a PF directly in an operational model might not be easily realizable in case of a complex system.


Even though these requirements are widely propagated in compiler text books, many real-world languages have features that do not quite conform to them.

practice has shown that such problems can often be overcome by preprocessing.


Intuitively, Most code fragments are small and their executions should .nish quickly.

there are code fragments that can fall into in.nite loops if the randomly generated inputs do not satisfy certain requirements of the code.


In our capability model, owned represents a capability that every object has to access its own representation.

an object may need to structure its representation by putting some of its objects into a container that is also part of its representation.


Whenever we create a constructor in the heap, the code generator guarantees to only refer to it using a tagged pointer, so it is never the case that a pointer to a constructor on the heap can be untagged.

this leaves one way in which untagged pointers to constructors can arise: we don t guarantee to tag pointers to static constructors (see Section 6.1.1).


Stack traces and core dumps can be helpful when dealing with some errors, and statistical bug isolation can be used when a bug a.ects large numbers of users.

for bugs only manifest as a result of a speci.c input, these techniques are not useful.


Both of these systems also assume that the users are using an anonymity network to hide the source identity.

splitX provides users with di.erential privacy guarantees that are independent of the content of messages.


4.6 Escape hatches We have designed ESC/Java s annotation language and checking so that common programmer design decisions can easily be expressed.

situations arise where convincing the checker about the correctness of the design requires more powerful annotation features and checking than are provided.


Validation is done with clients and frequent testing.

model Driven Architecture (MDA) tools such as Magic Draw [9] from NoMagic and automatic code comprehension such as Structure 101 from Headway [10], are seldom used due to their perceived complexity and lack of understanding of their tangible value.


For AppleScript, the decision to forbid cyclic data structures solved that issue.

perl still has an incomplete GC solution as of today [1].


During the entire development period, students had to work and implement their prototypes autonomously.

a weekly meeting was setup to discuss issues with other participants or with a dedicated supervisor.


For some instrumentation tasks, applications, and bu.er sizes, the initial chunk of memory allocated for the bu.er will hold the entire application s data, and the user s callback only needs to be called on termination.

on most interesting cases, the user s instrumentation routines will generate many bu.ers of data.


For example, matching ((var x as a[String]) | (var y as a[String]))* against a sequence of n a elements will yield a set of 2n parse trees.

such a pattern seems to be rare and, indeed, our experimental results in Section 5 indicate no blow-up.


FFI designs aim for productivity, safety, portability, and ef.ciency.

unfortunately, thesegoals are often at odds.For instance, Sun s original FFI for Java, the Native Method Interface[52,53](NMI), directlyexposedJava objects asC structs and thus provided simple and fast access to object .elds.thisis unsafe, sinceCcode can violateJava types, notably by storing an object of incompatible type in a .eld.


Embedded software systems, such as mobile devices, have real-time constraints and therefore require performance profiling methods with low overheads.

performance analysis of such devices often involves causality relationships and precision requirements.


2.3 Graphical User-Interface Construction In the cases of code and XML generation a domain notation is readily available to improve the readability of application programs.

there are many other domains with APIs representing a language in the sense of a coherent set of concepts and composition facilities, but without a concrete notation.


We had to limit network size because of the length of our simulations.

most results shown in Section 7 should be a good qualitative representation of any network size, because PPay is scalable.


In general, we consider that .nding the right technique(s) and adapting them to our problem is an open issue.

we currently investigate the use of partitional clustering and speci.cally K-means [9].


Each constraint can be satis.ed independently by executing one of its methods.

to ensure consistency over the whole system, methods should be chosen and executed in an order such that once a variable has been read from or written to by one method, no other method will write to it.


Static backtracking is a backtracking optimization technique, because it accelerates the speed of backtracking.

backtracking elimination tries to reduce the number of backtracks in various ways.


Note that this type contains elements that do not correspond to well-formed terms.

one can de.ne a function abstr : D × term .


The rule says that if we have a sum of two expressions eand e1, and both expressions are of security type t, then we can infer that the type of the expression e+e1is also t. Note that if the types of eand e1do not match, either one or both of them can be coerced to higher security types, according to the subtyping rules, so that they do match.

the types of expressions cannot be coerced to lower types.


In a multi-extension AOP language, these extension-speci.c terms and expressions can be advised by foreign aspects.

it is unspeci.ed how these terms and expressions are observed by the foreign extensions.


At the other extreme are systems like Jade [17] and DPJ [5] that check non-interference statically, but must disallow aliasing to do so.

legion can verify non-interference of privileges at runtime, which is much simpler and more ef.cient than checking non-interference of dynamic memory traces.


On the one hand, exporting as much information as possible is bene.cial since one cannot always know apriori what information is useful to higher-level services.

exposing information from the OS greatly expands the API presented to applications and destroys encapsulation.


Both AspectJ and JBoss have only a limited language to select program elements on which annotations can be introduced.

the selector language of Compose* allows for specifying arbitrary complex queries to select program elements for introductions.


It is the dominant language in system programming, and it is also portable.

our .rst implementation (under development) does not target C. This is for two main reasons.


In their approach, besides static analysis, they leveraged symbolic execution to detect any violations to the consistency model.

the state space explosion makes this approach unfeasible for complex software projects.


Note that this relation creates an ordering of operations.

the existence of a in an operation log does not require that ß is present and vice versa.


Similarly to Activity 6 (Table 8) it also asks the students to summarize their role activities.

as opposed to the personal manner of Activity 6, in this case the students are requested to publish their responses in the electronic forum and to provide feedback to the summaries presented by the other teammates.


If Context modi.es the way to include strategies, a modi.cation of specialization aspect IncludeStrategy will be required.

existing specializations will not be affected, since they only refer a class of type Context.


First, while a cache miss will stall the processor that caused the cache miss, the other processors may still be served.

the offchip bandwidth can be a bottleneck.


WSNs have been widely used in monitoring natural hazards such as flood, earthquake, snow, fires, etc.

the use of WSNs in SDS detection is new.


To get these values, we modi.ed a probe to communicate with it during the execution process and simulated a node failure by forcing the event node failure by hand.

we regularly had a di.erence between the number of nodes asked to the scheduler and the number of nodes actually ready to receive the simulation binaries and input .les.


It extends all primitives, which potentially trigger scheduling, to interact with a centralized abstract RTOS model.

rOM differs in the implementation of three crucial elements: (a) integration of interrupts, (b) wait-for-time statements, and (c) dispatch implementation.


We have also shown that our runtime libEOMP can perform as well as the native OpenMP runtime library customized for a speci.c platform, libGOMP.

as our OpenMP runtime is built on top of MCA APIs, it is independent with any OS or architecture.


As described, Refcache is well suited to reference counts that track the true number of references to an object, since there is no danger of the count going back up once the object becomes unreachable.

operating systems often need untracked references to objects; for example, OS caches track objects that may be deleted at any time, and may even need to bring an object s reference count back up from zero.


Two conclusions come to mind: either this method was not used extensively to uncover faults or it has a very poor record in uncovering faults.

another review category, namely manual review, uncovered 92 faults.


Therefore, a (human or compiler) optimizer should be allowed to swap the execution order of the two receive operations according to the side effect sets.

this is not a safe transformation and would lead to incorrect code in the general case.


With this approach there is still the same event and timer problem as with second alternative.

also solution to that problem can be the same, and composing a practical implementation is not hard.


UnchangedRatio is a .ner-grained metric than our type-3 inconsistencies, and if a clone pair has type3 inconsistency, it must have some identi.er with a non-zero value for its UnchangedRatio, which means CP-Miner may generate more reports than ours and we may miss certain bugs.

our type-3 inconsistencies are more ef.cient to calculate and report fewer false positives.


In this case, the subexpression containing the nested array operation, vsum arr1, is independent of the argument of the mapping function, and can safely be hoisted out.

it is possible to write nested data-parallel functions that cannot be transformed by hoisting.


Similarly, in a scenario where subscribers can be divided into groups, group addresses and memberships are statically bound, it may be cost-e.ective to create multicast groups, as each static subset of subscribers is interested in the same noti.cations.

when the set of subscribers interested in an event noti.cation is big in size, changes frequently, and geographically disparate, the eligibility of group membership is evaluated dynamically and across multiple administrative domains, a content-based pub-sub overlay service infrastructure is a less costly scheme, especially in terms of coordination and membership management.


The basic structure of creative periods during a RESCUE creativity workshop Spaces precludes us from listing all of the lessons learned from these 5 workshops.

three lessons stood out and influenced the design and facilitation of future workshops including the one reported in this paper.


This changes the de.nition to LXt/rJ t X dataSent(t)= |vri| +(|si| + |smi| + |ni|) (2) i=1 i=1 Viewable areas can dominate equation 2 if they are large, as they may be sent frequently regardless of player interaction.

if the cryptographic hashing or signing process is space-intensive, signatures will dominate the equation.


We already know that for static analysis this is better.

dynamic analysis involves execution of the programs with some inputs, collecting information from these executions, and then making some assertions about the program behavior.


Therefore, this study proposes a dynamic audio-video sharing platform system, which allows users to share audio-video files through USB port, DVD reader, or commonly available interface.

since the control of audio-video equipment varies, the platform must have cross-platform and crossequipment functions, and the functions of the equipment must be shared on the Internet for sharing multimedia audio-video streaming.


[9] suggest an exhaustive ontology for defining how context information can be shared between applications in augmented areas.

based on our experience with a real pervasive environment in the transportation domain, we have found that a relatively small number of abstractions suffice to decompose a pervasive space domain model.


Enriching Student Experience with Student Driven Content while Teaching an Online Data Mining Class Suresh Kalathur Assistant Professor, Computer Science, Boston University Metropolitan College 808 Commonwealth Ave, Room 250 Boston, MA 02215, USA (1) 617-358-0006 kalathur@bu.edu ABSTRACT An online class provides a unique opportunity for the students to participate in the class at their own convenience.

the students have to be kept motivated by providing the tools to enable discussions related to the class topics.


INTRODUCTION Aggregating heterogeneous data from different sources is always difficult, especially when the data definitions use different terminology or formats.

often such an aggregation has the potential to be very useful in building descriptive or prescriptive models based on historical data.


3(a)), then merging the simulation points in the order in which they occur in the code will give adequate performance.

if l2 is a procedure placed after l3 (Fig.


Our initial idea was to locate this metadata on the processor that initiated the transaction.

we realized this would cause unnecessary network traf.c, make the implementation unduly complex, or both.


For instance, the assembler may know that a given rei.cation needs to be activated all the time.

a metaprogrammer may want to activate some rei.cation on runtime events.


As far as SQL injection is concerned, our work is similar to theirs.

their scanner is not as comprehensive as our tool because it lacks any detection mechanisms for XSS vulnerabilities where script code is injected into applications.


In order to increase clarity and facilitate this placing, the Project may have a drawing of the facility associated with it.

this drawing is solely laid out in the editing area s background.


If all failing runs are explained by strong predictors, HOLMES reinitializes the iterative process by deploying an uninstrumented version of the program, after which it needs to be bootstrapped again.

weak predictors, if any, are passed to the function selection phase (described next) which uses them to identify the set of functions to be pro.led in the next iteration.


The optimizations in Section 3 work better in the latter case.

figures 1, 2 and 3 seem to imply that functions tend to be called with the same parameters more often in the wild, then in benchmarks.


A speci.cation miner might treat frequent and infrequent paths differently, in the same way that previous miners have treated error paths and normal paths differently for greater accuracy[32].

for other analysis tasks it is important to be able to discriminately rank or sort paths based on predicted frequency.


Using this approach it is possible to reduce the code size for non-FT implementations and also to apply aspects for fault tolerance and other concerns at the operating system level, as logging, synchronization and middleware customization [1].

there is no modification in abstract and concrete FT aspects used at the application level.


Our results are thus useful in better describing the performance of those systems.

if a system designer were intentionally implementing node selection to minimize churn, the results of Section 2 show that Longest Uptime offers somewhat better performance.


A promising code generation strategy, implemented by systems like ATLAS, FFTW, and SPIRAL, uses empirical search to .nd the parameter values of the implementation, such as the tile size and instruction schedules, that deliver near-optimal performance for a particular machine.

this approach has only proven successful on scienti.c codes whose performance does not depend on the input data.


when a system utilizes static sensors along with the moving ones or when some cars remain static due to congestion or because they have parked) DENSE has a signi.cant performance improvement.

as the fraction of points that change over time increases the gap is decreased.


The particular Space Invaders implementation in Fudgets outlined by Hallgren and Carlsson is based on a static network of Fudgets, with a .xed number of aliens and missiles.

our implementation is centered around dpSwitch, Yampa s primitive for higher-order dynamic collections of signal functions, and aliens and missiles are added to and removed from our game at runtime in response to events.


It is because that the modeling can use the same technique such as modeling the individual variation, modeling the learning process and cooperation processes between learning and teaching.

we do not research the way to create a stakeholder model because we only attend the classi.cation of the business knowledge.


While execution speed is the most obvious motivation for storage strategies, memory usage can be as important for many users.

while execution speed has an obvious de.nition, memory usage is somewhat trickier.


A clear understanding of variability in architectures is missing.

software architecture acknowledges that variability is a concern of different stakeholders, and in turn affects other concerns.


In Algorithm 1, the s common part Q j will be rechecked redundantly.

algorithm 0 avoids the redundant checking problem by removing redundant states in the set of possible current states.


4.2 Implicit overloading The existence of the frontier in gradual typing supposes a performance penalty in the execution of the application.

a naive implementation of tacit type checks can cause additional performance penalties.


This bene.t is a favorable property that assures code portability.

an interpretation approach can harm system performance.


For the solution which had optimal speed, the GFLOPs are only slightly worse than those for the optimised single objective of execution speed shown in Table 1.

the cache misses are reduced over all cache levels.


This advertisement is referencedby a module speci.cation advertisement specifyingdifferent moduleversions,whichisitselfreferencedby a module implementation advertisement providing implementationspeci.c details such as the code location.

supportfordynamicloading of codeinJXTAisinsu.cient,because real implementations require further conventions [10].


we intended to address the issue of local concurrency control in network protocols, rather than distributed transactions; the design considerations were therefore different.


every call stack push or pop) is reported, which introduces very signi.cant overhead.

it is possible to .ag only certain .elds, and manipulating only those .elds would trigger .eld read/write events.


Therefore, cooperative threads seem to be the only viable threading mechanism to context-dependent interruptible executions.

cooperative threads su.er from the same limitation as coroutines.


Chimera is the .rst software system for multiprocessors that leverages a static data-race detector tool to provide a low overhead replay solution.

an ef.cient solution would not have been possible without the two critical optimizations that we employed to drastically reduce the overhead of recording all the data-races reported by a conservative, but sound static analysis tool.


INTRODUCTION Global software development centres and near-shoring have emerged as important research contexts of empirical studies on software business and on software systems delivery [1], but also in the field of requirements engineering (RE).

empirical research on distributed RE primarily focused on risk identification and risk management [2] and on the application of a broad range of coordination and communication theories to the study of collaboration [3].


The major contribution of all of these work is bene.ting from network layer information to optimize the route between overlay neighbors which may be physically very far.

there is another important aspect that from the best of our knowledge on which there is not enough research.


Comparing the NCG against the LLVM backend, further testing showed that the performance difference was the greatest for atom, hidden and wave4main.

in all three cases, no particular feature of the code generation seemed to be responsible.


Communication in distributed project is difficult.

it is not enough only to describe the problem of communication in a lecture.


This includes the aspect of scaling mashups and the opportunities of leveraging cloud computing techniques such as infrastructure services.

it is also vital to provide the necessary primitives to secure resulting data from mashups and also maintain privacy concerns of the original data and APIs.


On the one hand, this could reduce the complexity of the design by eliminating the scheduling server in a centralized alternative.

on the other hand, this could increase the complexity of the used protocols and the cost associated with them for exchanging states such as availability of resources, online and of.ine time, among others.


The approaches consider not only the control .ow of source codes, but also the data dependence relationship.

previous work [1, 5, 6, 8] requires that di.erent programs are applied with di.erent approaches according to their respective features.


Objects could be classi- fied as short-lived or long-lived depending on whether they have survived a single old generation collection.

that is unsatisfactory because old generation col- lection cycles are infrequent - even an object that dies before the end of its first old generation collection may have sur- vived for comparable young-generation-allocated objects to have been tenured.


[14] studied inter-context control-.ow and data-.ow adequacy criteria in nesC programs.

all previous work is intended for testing applications prior to deployment when the size of the test suite is not as critical.


For empirical or experimental data, there are standard statistical methods to test for certain distributions and to estimate their parameters.

there are often some factors that cannot or can only very costly be determined using those methods.


It is not necessary to copy any information about read-only transactions to the commit log.

the mechanism is more subtle for writing transactions.


design pattern template [9] used the Object Modeling Technique (OMT) to represent structural and behavioral diagrams.

we leverage the Uni.ed Modeling Language (UML) to present information about each design pattern.


The VPG concept helps to identify VPs with equivalent logic and facilitates code change impact assessments in product line maintenance.

comparing the logical equivalence of VPs with arbitrary #ifdef statements is theoretically undecidable.


That the fundamental MLS policy functions of MLS enforcement and mediation of relaxed MLS policy are performed in a trusted subject complicates this situation.

it is clear that the addition of kernel-enforced constraints to trusted subject behavior reduces the amount of blind faith (viz., trust) that the users must have in them, and commensurately increases the assurance in the system compared to one without such constraints.


Since we could not install LibSockCap on the Slurpee servers, packet-snif.ng was our only option for tracing Slurpee and had the advantage of non-invasiveness.

we found the logistics signi.cantly more daunting than we expected.


These characteristics are especially relevant to the large projects often studied by software engineering researchers.

proprietary teams operate di.erently, and may leave much less information of use to researchers.


Our approach shows potentials in both creation of S-boxes as well as in the evaluation.

we are aware of the di.culties that lookup table approach could pose.


None of these alternative physical interfaces have produced widely adopted general purpose programming environments.

they have had signi.cant success in limited domains.


One might think that it is inef.cient to save all of the term variables in G into the closure, rather than only those that appear free in .x : t1.e.

if WEAKEN is used eagerly in the original type derivation, these must in fact coincide, so no ef.ciency is lost.


Even for a dependence distance of 1, the .lland-drain overhead will be twice as much.

this  Figure 3: (a) 3-point stencil code with shadow region (b) Pipelined schedule with shadow regions (c) Schedule with shadow region synchronization eliminated overhead is signi.cantly less than the overhead of synchronization for shadow regions.


At each interval, it selects a job from a wait queue sorted according to the job s fairness.

occasionally, the goal of mitigating interference and maintaining data locality may con.ict with each other.


This table shows that using modern, more ef.cient branch predictors can improve the bene.ts gained from this technique.

the advantages of using comparison speci.cations still outweighed the disadvantages of the higher misprediction penalty even with the poorer performing bimodal branch predictor since the number of cycles was signi.cantly reduced.


If Ais assigned to2cores, resourcescannot be utilized suf.ciently.

the workload of each core may not be balanced well because we categorized all the tasks based on optimum resource requirements (Figure 4(f)).


Note that the object zkand the condition sets nkand Skhave the same subscripts because the condition sets are associated with an object instead of an instruction.


A stream of scalar values is useless for SIMD computation.

a stream of multi-values isn t quite right either, because of the dribble problem.


5.2 Detour: Mendler-style Adjoint Folds We have noted in Section 2 that many functions do not quite .t the pattern of simple folds: depths, for instance, uses an accumulating parameter.

to provide a precise semantics we can take a similar approach as in the previous section.


will be the computaional time to regenerate of the context s Case 2: state from a time-varying tree, which itself may be complex.

alternative algorithms can be designed in this di- Algorithm CSS Verification Input: A SOAP message with Context Sensitive Signature Output: Veri.cation Result 1: Select the message(subtree) M to be veri.ed 2: Cannonicalize M 3: Decrypt CSS with the public key of the user 4: if Decryption fails then 5: Signature is invalid , Stop 6: end if 7: Generate new digests of stored C and M 8: if the new digest of C is equal to the one available is CSS then 9: if M is derivable from C and the derivation path is from S to [M] then 10: if the new digest of M is equal to the digest in CSS then 11: Signature is valid 12: else Content of the message is tempered: Signature is invalid 13: end if 14: else Message is out of Context(Rewriting attack!)


On the other hand, LIBSYNC uses a graphbased representation to capture more thorough syntactic and semantic information for adapting API usages.

smPL [21, 27]isa domain-speci.c source transformation language that capturestextual patches witha more semantic descriptionof program changes.it does notexplicitly distinguish API changes from their usage changes.


by composing the required re.nements to a compound aspect.

ideas on generic aspects could be combined with our approach.


This avoidsthe ALL type collectives,like Allgather, which in the worst case consumes O(N2)for an outer communicator G of size N. An advantage of MPICH2 s context-id is thatit canbegenerated with a single MPI_Allreduce operation, andin the case of MPI_Comm_create nofurther communicationis needed.

in the case of MPI_Comm_split, 3MPICH2 uses k=11, allowing the context ID to .t into 16 bits.


redexes of a term correspond to non-overlapping rules and their descendants cannot be destroyed.

this notion is well-de.ned when we consider inductively sequential terms because all redexes of an inductively sequential term correspond to non-overlapping rules.


Then, if this event is detected, it returns the value Detected.

if the event is missed, the process returns the value Missed(j) where j = M(i) is the next detected event (see Section 3.2).


The OAR batch scheduler, used in the Grid5000 [3] architecture, is coupled to a node recon.guration system that can deploy a software environment, using disk images, on a node before a job starts running.

these disk images are used to reimage physical Table 1: Experiment running times, average waiting times, and average slowdowns for [10%/3H/medium], [20%/3H/medium], and [30%/3H/medium] Time to complete best-effort leases, relative to time without advance reservation leases .


They model changes in terms of the lines of a .le that have changed, instead of program entities that changed.

a semanticsbased SCM is tailored to a particular programming language and Copyright is held by the author/owner(s).


For example, the abstract list for the disk scheduling policy is simply the existing scheduling queue, separated for each device.

the abstract list for the .le allocation policy contains all of the cylinder groups, with the group that will be selected next for allocation at the head; this list must be constructed by combining knowledge of how cylinder groups are picked with the current state of each group.


In addition to querying or modifying variables within a running binary, developers can also invoke functions compiled into the binary.

advanced debugging techniques such as conditional breakpoints are not supported.


CEG approach is used widely for abstraction re.nement in the model checking community.

to the best of our knowledge, this is the .rst time CEG is used in determining which call to be unrolled.


(1) If the newly created version ec is not transitively concurrent to any other version, then a new group G is created and contains only ec.

(2) If ec is transitively concurrent to some versions and all belong to the same logical group G, then ec simply joins G. (3) if ec is transitively concurrent to versions belonging to more than one group G1...Gn, then a new group G is formed by merging all Gi(i :1..n) and ec joins G. In the three cases, some new edges are added into the t-GDG and some that were already built might have to be removed due to the restructuring of the logical groups.


As can be observed, in order to guarantee with probability 99%, that 30% of the points of a cluster with 500 points will be included in the sample, we need to sample 35.3% of the database.

in [22] they show that using biased sampling we can get a sample that has the same probability to include points from a given cluster with smaller sample size than uniform random sample.


In practice, the actual probability may not be 1 DEADLOCKFUZZER can miss a deadlock because the execution could simply take a different path due to nondeterminism and that path may not exhibit a deadlock.

in our experiments we have found that the probability of creating a deadlock is high on our benchmarks.


Modeling and programming languages possess similar concepts with similar semantics, such as class and inheritance, guaranteeing a continuity between implementation and design.

modeling languages aspire to provide higherlevel abstractions and thus include concepts absent from programming languages, in particular binary class relationships.


The Perfume model can also support this task by showing reachability in the inferred model from the terms of use page state.

perfume cannot easily support some other analyses supported by BEAR.


Considering such requisite, different testing tools can be identi.ed, such as J2MEUnit [12], GlassJar Toolkit [5] and JaBUTi [15], which support functional, control-.ow and data-.ow testing, respectively.

none of them supports the testing of mobile application directly on the target device, i.e., all of them allows the testing of mobile application only on the computer desktop through emulators.


If the angle measurement is noiseless, all orientation lines would ideally intersect at only one point.

perfect sensor accuracy is unlikely under real world conditions.


This means that compare does not depend on the solver state, so we do not need to update the index.

we will miss partner constraints when we use the index.


() :::::::::: axInt-[1a1][1a1]-Int [1a1]x[1a1]-[1a1][1a1]xInt-a(a-()x[1a1] -[1(1] -repliation -length -onatenation -indexing -dpappliation (b) andprimitivesofA.. edure.frstwewilldisuss,inthepresentsetion,afattenedrepresentationofparallelarrays;andthen, inSetion5thevetorisationtransformation,whihgeneratesforeahfuntionintheprogramavetorisedvariant operatingonawholearrayofoperands.


If applications insist on using opaque local identi.ers, these can be folded into URIs using the tag scheme [22].

this would re-create the problem of these URIs needing a proper context for interpretation that is typical for tightly coupled identi.cation.


In the past few years, pair programming has made inroads into industry and into programming courses.

it has not typically been used in courses that teach subjects other than programming or software engineering, nor has it been used in the analysis of experimental results.


The inclusion of design patterns in the ACM Curricula 2005 has also sparked wide interest in the education fields [6].

learning and applying design patterns remain a nontrivial task particularly to novices [3, 8, 20].


stable than the specific behaviour of the software system itself.

this and other similar approaches do not investigate if (and how) this problem can be solved at the architectural level, and postpone their solutions to later stages of the development (detailed design/implementation).


Whole character size and a whole font can be changed by the function of a browser.

the arbitrary parts which the user chose can be changed in WPM.


The basic idea in this paper is to observe the executions that occur in the datastore, create the corresponding GDG graph and test for cycles.

this is far of being a trivial approach as it is dif.cult to see from the outside what is happening within the system.


Speci.cally, we will consider the following three forms of the problem: (B1) The adversary is itself one of the mobile nodes included in the set of traces (i.e., it is one of the participants in the trace set); (B2) The adversary minimizes its e.orts by simply staying at one .xed location; (B3)The adversary pre-determines a movement strategy to presumably maximize the amount of useful side information it can obtain, subject to the same physical movement constraints and speed limits as the participant mobile nodes.

we will not consider the case in which the adversary may adapt its movement strategy to prior information it has learned about the potential victims.


To evaluate how useful our approach is in practice, we are planning its extensive application to other real systems.

our early experiments provide strong evidence in favor of this line of research.


XML-based languages are a popular tradeoff since they are easily processable using generic libraries while their notation is to some degree human-readable at the same time.

a BNF-based syntax for such a language can improve readability a lot.


Moreover, Prospector does not solve queries with multiple argument methods unless the user initiates multiple queries.

we generate full expressions using just a single query.


using arbitrary computation in the projection.

it seems that interesting ornaments can usually be expressed as valid projections.


For instance, Ahn and Shin [2] show how RBAC constraints can be expressed in UML using the Object Constraint Language (OCL) [31].

they do not provide a systematic modeling approach that can be used by developers to create applications with RBAC features.


Discrete recombination is similar to uniform crossover; every position in the chromosome is a potential crossover point.

unlike uniform crossover, a gene can be copied into one or both children with an even probability.


Python) classes do not describe object attributes, each object maintains a dictionary mapping attribute names to values, .eld access is expensive as it takes place via names, and space usage is suboptimal due to the redundancy across attribute dictionaries.

unlike static OMs, dynamic OMs support dynamic attribute addition/removal as well as per-object attributes.


The challenge is the fact that many network devices do not support large MTU size.

on ESX hypervisor, jumbo frame can be set easily using the virtual private network.


We note that the bandwidth increases with data size, and it is relatively stable for di.erent runs, for both directions.

for data transfers larger than 32 MB, the Phi to host bandwidth shows a large variation, with the median bandwidth value decreasing sharply (up to 6 times!).


The operations currently supported are insert, delete, and lookup.

extending the implementations to support the full ETS interface is quite easy.


In order to mine larger or more complete patterns, we need to consider single-cohesive changes that spread over a sequence of change-sets.

the changes-sets corresponding to such changes are rarely explicit (at least not directly recorded in the repositories or documented).


Two of the new reducers are implemented as Csmith add-ons and can only reduce Csmith-generated programs.

the most effective reducer (in terms of size of output) that we developed is generic: it can reduce any C program, whether generated by Csmith or not.


Given the tracking framework s design, rotating the associated annotations along with the tracked object is trivial to implement.

we have chosen against it, due to performance considerations, since that would require calculating the smallest bounding rectangle of every tracked object in every frame, which can be an expensive proposition when using complex object shapes, such as people s silhouettes, and on cluttered scenes.


This is understandable since the .elds with frequent values are usually shaped by the characteristics of the application, rather than the particular input set used.

the .eld values themselves depend strongly on the input set used in a particular execution.


One of the notable points of the study is modeling of scope overlaps, which allows for examination of con.icts in physical interactions, such as sound con.icts.

the provided modeling abstracts away details of the following.


The cleaning overhead could significantly decrease the performance of file system.

traditional cleaning policies do not consider the storage location where the valid data in the cleaned segments should be placed and rewritten to.


If the other phases of the algorithm do a good job with respect to color assignment, a post-processing phase, such as refinement, will have minimal opportunity to improve the quality of the solution.

unless compile-time is of primary concern, there is practically no harm in running refinement following an initial color assignment.


Towards a Moldable Debugger Andrei Chi ¸s Oscar Nierstrasz Tudor Gîrba Software Composition Group Software Composition Group CompuGroup Medical University of Bern, Switzerland University of Bern, Switzerland Schweiz AG http://scg.unibe.ch//staff/ http://scg.unibe.ch/oscar http://www.tudorgirba.com/ andreichis  ABSTRACT The debugger is an essential tool in any programming environment, as it helps developers understand the dynamic behaviour of software systems.

traditional debuggers fail in answering domain-speci.c questions, as the semantics of what they show and do are .xed.


Unfortunately, this information (if it can be retrieved at all) usually is quite incomplete.

there is also unintentional collaboration.


Therefore, the idle power pidle consumed by the CPU when idle is strictly less than the power consumption when running a task at the minimum operating frequency.

it is important to notice that the idle Table 2: XScale speed settings and power consump power is not equal to zero.


A.7 Per-Heap Clock Domains In our design all heaps (and the application) run at the same clock frequency.

we could place each heap into its own clock domain, and introduce FIFOs for clock-domain crossing where they are inter-connected.


Adequate support is a key to achieving the full potential of the Web services technology.

the current implementation of widely-accepted BPEL standard has demonstrated deficiencies in non-functional aspects.


In other studies as the ones by Bell and Lapadula [11] and Goguen and Meseguer [13] models, insecure .ows were considered for generic information systems.

applications to (active) databases were up to our knowledge not considered.


INTRODUCTION Low power design has permeated each and every level of a system design, including the hardware circuits, software applications, operating systems, compilers, and architecture designs.

often we observe that the low power infrastructure is not used optimally in a system design because there is little integration between the di.erent low power schemes embedded in each system component or level.


An identical situation can also occur with respect to the return types, as demonstrated by the following advice: Integer around(): call(Number *()) { Integer i = proceed(); // ... } Because this advice provides an Integer result, it can assume that its join points do so as well in AspectJ.

the advice can also be applied to join points where the returned value of type Number is not an Integer, in which case a ClassCastException will occur when returning from the proceed-method to the advice body.


For instance, must-alias pointer analysis could not identify likely dependences, such as load *p and store *q, hence would not synchronize them.

may-alias pointer analysis would indicate that load *p may depend on any of the .ve store instructions, hence they should all be synchronized.


The characterization of part as plagiarizing comes somewhat as a surprise, because part clearly does allocate each cons cell in its result and thus should be manageable and is so with our new method.

it is easy to see that all functions ful.lling Wadler s syntactic test for creativity also allow the type-correct abstraction from list constructors [], (:) and (++), and can thus also be transformed by our technique.


An object is allowed to escape via a method or constructor call, provided the signature of the method or constructor explicitly permits its receiver or arguments to be raw (and consequently does not rely on their non-null guarantees).

the system does not permit a raw reference to be assigned to a .eld of any object, even of the referenced object itself.


In other words, MobiDesk virtualization is protected from such changes in the same way legacy applications are protected.

new system calls could be added from time to time.


Note that the use of bridge predicates Pre and Post has the same .avor as pre and post-conditions used for functions in program veri.cation.

unlike traditional pre and postconditions, the proposed Pre and Post predicates relate pairs of states from two different executions.


If the resource demands of an application are known in advance, resource accounting and quota enforcement can be done by the resource allocator or grid scheduler.

an a priori estimation of resource consumption is very complicated for typical grid applications.


In Section 2, we discuss a number of DCAS-based results which represent signi.cant progress in the design of nonblocking data structures.

we also show that, despite these positive results, many of the DCAS-based algorithms we discuss su.er from important limitations, and are often complicated and di.cult to verify.


To represent an eventuality, all the participants mimed the behaviour described by the lexeme in question.

it has been shown that to refer to an eventuality in a natural discourse, speakers use various representational formats by adopting di.erent viewpoints.


(DSTM.rs(t, v) .¬SS.pending(t)) .¬DSTM.aborted(t) is an invariant of M(2, 1), it is not an invariant of M(3, 2), and hence not a uniform invariant.

consider the invariants .t.SS.pending(t) .


5.3 File and Directory Placement I/O-intensive applications, such as database systems and web servers, bene.t from controlling the layout of their data on disk [46].

because many .le systems do not provide this type of control to applications, the placement of .les has been used to demonstrate the power of extensible systems [21] and gray-box systems [31]; further, the ability to group related objects will become available in nextgeneration storage systems [15].


When a program is correct, the rely and guarantee speci.cations of each thread weave together to form a global proof of correctness.

the Rely-Guarantee approach suffers because system speci.cations must be written in a global manner.


In this case, four 32bit registers (DMA control, source/destination address and length registers) have to be set before each transaction [14].

each single PLB write transaction needs 4 cycles, thus we need at least 16 cycles to initiate the DMA transfer and at least 34 cycles to copy the data from the BRAM to the DRAM or vice versa.


Graph theory is a powerful tool for social network analysis and MapReduce is a well-known paradigm for distributed parallel computing.

our own experiences show that designing/writing Java programs to implement MapReduce graph-theoretic algorithms requires a signi.cant amount of efforts, even for some fundamental graph-theoretic algorithms.


As opposed to the last three schemes above which do not explicitly introduces the concept of the exception handling context (scope), the CAMA framework [6] (introduced in Section 2.1) supports the concept of (nested) scopes, which confine the errors and to which exception handlers are attached.

cAMA and the other mechanisms mentioned above do not support a fully context-aware exception handling, as supported by our approach (Section 4).


the presence of such self-loops does not alter standard analysis techniques (e.g.


[0, 255] because bitwise loop conditions are not handled properly.

using bitwise intervals only infers that mode .


Because we could not easily instrument or debug the code of the browser-based mobile version of the Lively Kernel, precise performance comparisons were not possible.

based on informal benchmarks event handling performance is generally 2-3 times faster in the ScriptBrowser than in the web browser.


DAPAalgorithmisto choosetheoptimum partitionfromaseriesof partitions, so the result is a local optimum rather than a global optimum.

this series of partition is seriously picked.Further more, since theavatarsin theDVE systems joinin oneby one, the connection betweendifferentavatarsisbuiltupgradually withthe changes of their states.


The best solution from our test in both regular and light weight type is "i5" Factory Method pattern that comprises of ConcreteProduct class, ConcreteCreator struct with static FactoryMethod inside.

in some situation, if it is essential, we may have other alternatives like i7 or i6.


These mechanisms are simple and convenient when users understand their application workload and when the relationship between the scaling indicator and the performance goal is easy to determine.

not all applications have time-based workload patterns, and it is not straightforward for users to correctly determine all the related scaling indicators or the thresholds based on the performance goals.


STATE OF THE ART IN SEQUENTIAL AND PARALLEL DEBUGGING Debugging is one of the fundamental steps in the software development cycle.

current techniques, particularly for parallel applications, have reached their limits due to rising application and architectural complexity.


These regular stack frames are the easy (and well-understood) part.

between each regular stack frame are zero or more Arg continuations, or pending arguments (shown grey).


To this end, it automatically connects to various police databases throughout the country, using some ACL.

a police of.cer is not allowed to see personal characteristics of suspects, unless he or she is assigned to that speci.c case.


CONCLUSION We have a complete experimental design to evaluate the IDE with the visualization interfaces against the regular IDE.

we decided to further characterize the use of the interfaces.


Eliciting Design Requirements for Maintenance-Oriented IDEs: A Detailed Study of Corrective and Perfective Maintenance Tasks Andrew J. Ko, Htet Htet Aung, and Brad A. Myers Human-Computer Interaction Institute Carnegie Mellon University 5000 Forbes Ave., Pittsburgh PA, 15213 ajko@cmu.edu, hha@zizawah.com, bam+@cs.cmu.edu ABSTRACT Recently, several innovative tools have found their way into mainstream use in modern development environments.

most of these tools have focused on creating and modifying code, despite evidence that most of programmers time is spent understanding code as part of maintenance tasks.


Different VMs can share objects via a separate heap.

programming languages fundamentally differ in their paradigms (e.g.


Scientific and technical approaches prefer to simplify problems, to distill them down to an equation or model.

sTS seems to revel in the complexity of problems.


As such, there is no need to .lter generated sequences for validity.

not all harmonically valid chord sequences are musically interesting.


Furthermore, throughput increases in network indicate that over-the-network memory replication might be feasible.

sustaining datacenter power outages requires at least one disk copy for the system to be fault-tolerant.


As in NextEJ, the type of role depends on the enclosing context instance.

powerJava lacks the feature of role groups that is a powerful mechanism of getting role instances associated with the context instance re.ectively.


For example, an instance of a TrafficLightGroup (Logical package) represents a group of traffic lights that are bound to always have the same colour, and that are therefore represented as a single object.

each of those traffic lights is modelled as one entity in the Management package because, for instance, traffic light bulbs burn independently of one another.


Also, mental behavior differs over so many metrics like age, ethnicity, education, marital status, family history and habits etc.

human brain chemistry changes over different mental disorders but still causes and effects are not fully explored.


Bj¨ orn was right: .attening makes this term huge.

(the size of the term with shared subterms is quite small.)


at the nearest available location to the current disk head position, reducing the seeking delay to the original location of the data.

these copy-on-write file systems do not perform well in PCM storage as PCM has no seek movement but has relatively long write latency and endurance limitation.


It introduces the ghost cell, which allows a vertex to access values through the put/get interfaces to the property map.

the ghost cell in parallel BGL is write accessible and an application-speci.c resolver is required to arbitrate and combine messages, which may cause consistency issues and incur burdens to programmers.


This technique disallows other portions of the page from snooping on sensitive email content.

since messages act as the same principal, it may be possible for malicious JavaScript code from one email message to affect the contents of another message.


Therefore, these approaches either restrict the user to using prede.ned operators only or require additional expertise to implement the extraction function.

a memory snapshot can only be taken if the respective pages are write-locked, which incurs signi.cant additional detection delay during failure-free execution.


This, on one hand, simpli.es the design of GDM.

it puts the system memory space occupied by stag- Figure 3: Device memory region and ob ject.


Further approaches consider link establishment between requirements and test cases, for example, [14, 30].

for design traceability the traceability between design artifacts and from and to other artifacts there are fewer and no comprehensive concepts.


The high complexity of MiniMax limits its use in the online selection of active servers.

due to it providing a good approximation, it is used for comparison in the evaluation section.


4.3 Distributed Hierarchical Scheduler A distributed scheduler would control processor resources on a number of connected machines.

implementing such a scheduler is complicated by communication delays.


As a result of this, our interview data could be biased and unrepresentative of the RTC team at large.

we are con.dent that this threat is minor, due to the mix of developers we interviewed, including novices, senior developers, and team members that had been part of the group since its beginning.


We also use OTC to categorize the overly strong precondition failures based on the template of the warning message.

we cannot use this approach for classifying failures related to behavioral changes since there is no information from our oracle (SAFEREFACTOR) that could be used to split the failures.


The bound 4¯r can be somewhat decreased by further analysis based on the way 0( pkplpm)and 0( pkplpn) overlap in case (ii).

the practical value of the additional analysis is questionable.


Hence, the measurement of cloning also occurs at the implementation level.

industrial software contains thousands of files, making it almost impossible to reason about software clone distribution.


For example social networking functionality, which was initially planned to be incorporated into the artifact, was neglected, as this functionality (against our first assumptions) added no direct benefit to the main use cases of the artifact.

the specific annotation functionality was detailed with additional features (e.g.


In this category, the con.icting vehicle with higher priority can ignore the intersection safety messages from other lower-priority vehicles and cross the intersection without slowing down or stopping.

any lower-priority vehicle is super-cautious and when it loses a competition, it comes to a complete stop before entering the intersection boundaries, and waits till it receives a CLEAR message, from the higher-priority vehicle.


Typical implementations of SMC represent states with Binary Decision Diagrams (BDDs) [5] that support ef.cient operations on boolean functions.

heap operations prevent the direct use of BDDs for object-oriented programs.


three calls to push can be followed by at most three calls to pop)are not captured by our technique.

these speci.cations lie outside the scope of general temporal properties; they are infact not modeled by any regular language.


2 In theory, d can be as large as k. In this case, our bound (as required) is worse than 1/nk .

we consider a depth k bug a practical impossibility, especially for modern software that is built from a large number of loosely-coupled components.


Consider the code in Figure 3, where r2 may be a subregion of r1 if condition Q evaluates true.

the region lifetime in Figure 3 is not consistent because r2 = r1 does not always hold; r2 can be a subregion of r0 when P evaluates true and Q evaluates false.


A brute-force approach to dis-covering incoming references into complets in Core A could be implemented by requesting all remote Cores in the sys- tem to traverse their local complets, search for those who reference complets in Core A, and then apply on them DA actions.

this is an expensive solution that might lead to long pre-disconnection periods, and thus not ap-pealing.


Manual construction: One of the main purposes of HAT is to systematically guide engineers through a set of analysis steps leading to critical decision points  points in the analysis that require judgements about the absence or presence of hazards, risk mitigation strategies, and the degree of residual risk.

many of the steps leading up to these decision points are highly repetitive and intermediate results are calculated in a straightforward manner from other development artifacts (e.g., identifying enclosing components or subsystems in a Failure Modes and E.ects Analysis (FMEA)).


By limiting the set of candidate functions to those with identical signatures, we ensure that type errors cannot occur when more speci.c functions are found.

by allowing functions that are more speci.c than the seed to enter the candidate set even if they are declared after the calling function we free ourselves from ordering dependencies and allow the most ef.cient operations to be selected in the vast majority of important cases.


Despite this, and the incidents cited above, I do not think there is cause for alarm about the e.ectiveness of DO-178B and its related guidelines.

i do believe it is important to try to understand why DO-178B works, and what is the contribution of its various objectives and its organizational context.


This is acceptable as descriptors constitute on average less than 1% of allocated memory.

if desired, space for descriptors can be reused arbitrarily or returned to the OS, by organizing descriptors in a similar manner to regular blocks and maintaining special descriptors for superblocks of descriptor, with virtually no e.ect on average performance whether contention-free or under high contention.


Intuitively, a data point far from the Sd (such as point A) shows unusual correlation, and thus represents an anomaly.

point B, although far from most other points, resides close to the Sd, and is thus normal.


One reason for this is that open source development takes place closer to the using organization.

it can also be suggested that FOS-ERP development have a risk of becoming a one organization task, creating a development vacuum.


[6] perform strong updates when an abstract location definitely represents a single location during every method execution.

both of the two approaches can only Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page.


As a result, the number of ucache misses is further reduced to 14812 and TLUS to 22921.

loads #3 and #4 have no scheduling slack and thus cannot be selected as SQ loads.


The images had been created and digitally altered so that each individual was shown in the different contexts.

each participant saw four images with women shown in occupation contexts and four images with women in family contexts together with children, but not the same model twice.


Thus, DVS scheme can reduce much energy compared to the maximum-speed static scheme.

there are tradeo.s in dynamic scaling of processor speed in on-line real-time cloud computing.


Depending on the domain, it will not always be possible to fully populate the subject-matter vs. concept matrix.

industr y demand for an interdisciplinar y course can be considered a strong indicator for being able to substantially .ll the matrix.


This is usually ineffective for objects with large APIs, as this sorting ignores the level in the hierarchy at which the member is declared or overridden at.

an important advantage of the alphabetical order is its familiarity and good predictability (in the sense that every time Code Completion is invoked for the same type, the list of completion proposals remains in the same order).


For JHotDraw, ANOVA did not indicate any signi.cant di.erence among patterns for both rc (p-value=0.39) and  95% CI for the Mean 2.0 1.5 1.0 r 0.5 0.0 -0.5 -1.0  d nsite aorator o mp c m meooDC ter-Cp a d A (c) rl rl (p-value=0.93).

e er ctory p ervasPrototy Fb O Pattern (ArgoUML) Figure 4: Client / Target Ratios (rc and rl) it was found that Adapter- Command had a signi.cantly higher rl than other patterns we have studied (p-value=0.02) and a mean rl = 2 while others had rl < 1.


4.2 A Weak Key Schedule In our weak key schedule, expanded-keys are still produced from a secure stream cipher controlled by a masterkey.

we let Cook s elastic block cipher be implemented in a way that special part of the expanded-keys serves special part of the elastic block cipher.


The mapping of most nodes was narrowed to one or two candidate layers.

.ve leaf nodes were completely unconstrained, associated potentially with every layer, and two nodes were over-constrained (associated with no layers).


In a .rst step, our algorithm simply computes the parallel composition of all roles or, more technically speaking, of all statecharts.

the user may specify restrictions on sequences of states executions paths which should not occur in the synthesized component behavior, i.e.


As it appears, CBR is the most efficient technique and PBR is the most effective one.

more empirical studies are needed to assess the differences between the techniques in the context of stereotyped UML designs on a bigger sample.


HAVi relies on IEEE1394 as the underlying communication media and supports respective protocols only.

uPnP, DPWS and Web Services are mainly IP-based solutions.


LMSA can work well on small scale instances of NRP.

it may take too much time for solving large scale instances, due to the large search space [1][2].


In the worst case, a designer would have to provide task code for each device under consideration.

improvements in high-level synthesis tools (e.g.


If mi is called by several other methods, sj is not a singleton allocation site according to the de.nition presented earlier.

if for examplewehave statements x.k(); y = x; y.n() after sj inside mi,in Red we would like to show that the receiver ob ject at these two calls is the same as the one created by sj .


This result seemed to suggest that our mechanism to change the master replica worked very slowly.

after analyzing the experiments, we discovered that a large number of transactions with incorrect results were rolled back by the benchmark code and not due to the detection of Byzantine behavior by our algorithms.


Their technique is similar to ours: Identify well-typed intermediate programs, perform one step of reduction, and prove that the resulting program is also well-typed.

the most important difference is that Roberson et al.


[18].Oursupportisin some ways simpler than that of HTM, since we throw an exception upondetecting a con.ict rather thanperforming rollback and re-execution.On the otherhand, our con.ictdetection mustbe precise since afalse con.ictwould resultin afalseMM exception, while a false con.ict in an HTM system is acceptable as it simply causes an unnecessary re-execution.

4.2.1 BasicHardwareDesign HTM systems commonly detect con.icts by maintaining read and write accessbitsper cacheline.this approach canlead to false con.ictsiftwodifferentmemory words accessed concurrently indifferentthreadshappentobe assignedtothe same cacheline.To addressthisproblem, wetrack read and writeaccesses of aregion using a circularqueuebufferthatwe calla regionbuffer and employ lazy con.ictdetection.


Certainly, customer availability throughout the development process as required by most agile process models is a promising means to reduce developers' risks of projects in which errors and misguided developments will be detected far too late.

this reduction of development risks will only be achieved by shifting a large portion of project responsibility on to the customer who is then being faced with new and partially unexpected demanding challenges.


DART uses these constraints to produce new concrete inputs that would drive the program along a different path on the next run.

dART does not instrument the environment and hence cannot use information from it when generating new concreteinputs, thus missingfeasiblepaths asindicatedby SC-UE.


Narrowing order-sorted dependency pairs The technique of OS-DPs is a powerful way to prove termination of OS-TRSs.

as in the standard case (5), there can be examples where the automation of the method fails due to the overestimation of the arcs that connect two OS-DPs in the estimated OS-DG.


Also, the implementation of crosscutting concerns is usually tangled with that of other (crosscutting) concerns, which is typically not the case for subfunctions.

both the subfunctions and the crosscutting functions access and operate on data elements held by the objects of the classes they are associated with; therefore, I believe that the following thought experiment of applying AOP to the modularization resulting from data encapsulation via classes (which AOP applied to OOP is invariably about) is legitimate.


We have also investigated the impact of reference semantics on the laws, in the rCOS re.nement theory [18], and identi.ed a number of what we call laws of classes which remain sound in reference semantics, even obviously sound because they are .ne grained changes of static program structure.

rCOS does not yet provide data re.nement laws with reference semantics.


For instance, the identity function can be used as a preference function for a quality such as average throughput, since higher throughput is typically preferred to lower throughput.

for a quality such as memory consumption, lower consumption is preferred to higher consumption, and so the preference could be computed as the reciprocal of the value of memory consumption.


COMP: Compiler Optimizations for Manycore Processors Linhai Song * , Min Feng , Nishkam Ravi , Yi Yang and Srimat Chakradhar * Computer Sciences Department University of Wisconsin-Madison Madison, WI, USA songlh@cs.wisc.edu Computer Systems Architecture Department NEC Laboratories America Princeton, NJ, USA {mfeng,yyang,chak}@nec-labs.com Cloudera Inc. Palo Alto, CA, USA nravi@cloudera.com Abstract Applications executing on multicore processors can now easily of.oad computations to manycore processors, such as Intel Xeon Phi coprocessors.

it requires high levels of expertise and effort to tune such of.oaded applications to realize high-performance execution.


Of course, the bene.t would decrease, if a concurrencybug detector runs much faster than the detectors used in this paper (e.g., more than 10 times faster).

techniques used to speed up concurrency-bug detection [63, 71] can po tentially also help speed up CFP measurement, in which case the bene.t of CFP-guided bug detection will remain.


For non-interactive applications such as movie playing, decompression, and encryption, fast processors reduce device idle times, which in turn reduce the opportunities for power savings through hibernation strategies.

dVS techniques are still bene.cial in such cases, i.e., DVS reduces power even when these devices are active.


For all the trace selection strategies, proactive linking produces smaller code caches than lazy linking because proactive linking needs smaller exit stubs leading to lower auxiliary code size.

the total memory demand of lazy linking is less than that of proactive linking because the decrease in data structures due to lazy linking outweighs the increase in code cache size.


The Ladebug project [4] aims at providing scalable parallel debugging and presented a prototype debugger on top of a hierarchical communication network similar to MRNet used in STAT.

ladebug has not been evaluated at the scales targeted in this work.


As the mobile web browsers are quickly catching up with their desktop counterparts, it is likely that Maygh will work without modi.cation once WebRTC support is provided to these browsers.

a potential drawback is that the user session times are likely to be much shorter, as smartphones typically only allow users to have one active web page at a time.


However, these approaches implement substantial parts or all of the garbage collector in hardware.

our approach aims at a small and simple hardware implementation, while leaving most of the garbage colleciton logic in software.


The book describe the whole process of failure data collection, including the steps that should be performed to setup the data collection process, and the mathematical background.

the primary focus is on the overview of black-box reliability growth models and related testing and analytical procedures.


In this respect, they are much more general than us.

on the other hand, they abstract much less: there are still computations, coin tossing and probabilistic transitions in their model.


We believe that these challenges would be typical of the refactoring effort required to convert any complex, modern operating system into a library OS for desktop applications, and that our solutions would apply elsewhere.

we also rec-ognize that our task was made significantly easier because most Windows applications seldom use child processes and the Win-dows API has no fork primitive.


Ccur and an LIO action m, toLabeled lm executes m without raising Lcur.

instead of returning the result directly, the function returns the result of m encapsulated in a Labeled withlabel l.Topreserve con.dentiality(seeSection4forfurtherdetails), action m must not read any values with a label above l. We can implement toLabeled asfollows: toLabeled l m = do ' (L ' , C ) .


The NI class is the class of test cases that are not impacted by the aspect.

the I class is the class of the test cases that are impacted according to the previous de.nition.


Thus, the main concern was to systematically identify and analyze which factors affect positively and negatively the production of stable output models, when the algorithms are applied.

conflicts have been identified as detrimental to stability of the models; therefore, provide a negative impact on the composition effort i.e.


Also, many techniques [16,28] have been proposed for eliminating similar code to help reduce software maintenance cost.

various studies [19,20,28] indicate that similarity in software is inherent, and clone uni.cation and removal may not always be desired.


These correspond to the times when synchronization stalled and the master had to perform a fault recovery.

owing to the non-blocking nature of guesstimate even during these times the user could continue performing operations.


So, it would seem that we gain in clarity by having such probe states.

using probe states in a program may incur a cost.


Phalanx uses digital signatures, i.e., self-verifying data, to port ABD to the Byzantine model, maintaining the latency of ABD, as well as its data writebacks.

since digital signatures introduce considerable overhead [33, 38], protocols that feature lightweight authentication, or no data authentication at all (unauthenticated model) have been designed.


Another im portant complete hybrid strategy is the counterpart of normal order in the lambda-value calculus [17] (Section 7).

applica tive order is uniform and is not complete: it reduces potentially divergent subterms.


It is worth noting that if the only rule that must hold is the general rule (i) and overwrite of prewrites already entered in LPW is allowed, the original TS2PC4RS algorithm works.

if there are more business rules like the general rules (ii) and (iii), the TS2PC4RS algorithm needs some extensions, in addition to the permission to accept overwrite of prewrites already accepted.


The remedy mechanism is very simple: suppose the remedy stage includes k windows, and the missed blocks number within the subscribed layers in the newly entered window is n, thus the n blocks should be requested from neighbors during k windows time, and on averagejust n/k blocks are requested in each window.

how to choose k s value is interesting: if it s too small, it s likely that there isn t enough time to request the missed blocks, especially when the blocks encounter bandwidth burst-anddrop in the decision stage; on the other hand, if it s too large, the initial waiting time will be very long, because after the blocks with earliest playback time leave the decision stage, they must stay in the remedy stage for k windows timebeforebeingplayed.


It could be argued that an alternative approach would be to specify all behaviours for all possible conditions in a single, monolithic component, together with the logic for selecting which behaviour to use at each time.

using separate redundant components for di.erent running conditions provides radically improved modularity and .exibility over the aforementioned approach.


To accelerate the memory access, the use of e.cient access mode is greatly encouraged to promote the access bandwidth [2].

speed requirement is not principal for all target application markets, instead, how to get an e.cient area becomes the main task.


Hence, a lot of expensive EM simulations are necessary to generate the training data.

only a small part of the design space is used in the optimization.


Middleware is scoped much more broadly and deals with the provision of all types of enabling services for effective distributed computing.

a predominant number of middleware platforms support at least some form of dynamism (e.g., dynamic discovery, insertion, and/or invocation of components in CORBA).


As a drawback we currently cannot de.nitely evaluate expressions containing CPP macros.

only 2 of the 27,569 conditional expressions used for feature-based con.guration in Linux3 call a macro function (e.g., #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,2,0) to query the kernel version).


Strategies (a) and (b) imply static tailoring at the beginning of a project.

during development some adjustment may be necessary to attain optimal performance [2].


Before calling a function that a.ects the property state, she must check the current state of the property FSM to ensure that the function call will not result in an error.

the programming language provides no mechanism to express or check the property state.


This approach is closest to ours as it looks for abstraction of problems involving crosscutting functionality.

we believe that the refactoring of design patterns is typically complex and involves a number of crosscutting concerns, as earlier discussed for the Observer case.


PipeCloud is able to support a much higher write workload and still provide responses to read requests within a reasonable time as re.ected by a lower average response time for PipeCloud under load.

pipeCloud s network buffering impacts those read requests which happen to coincide with write requests, resulting in a higher standard deviation in the response time as shown in Figure 12(b).


customer/enduser requirements project status organisational requirements  project  4.2 Added Value When comparing the methodology with project management methodologies, development methodologies, standards and models, some overlap can be observed: defining the project objectives and controlling the project s progress during its execution.

the methodology offers added value by explicitly recognizing that: D Release Definition: There needs to be a clear rationale for a project throughout its existence (economics).


Pedestrian Navigation Systems: a Showcase for Deep Personalization Theory Xiangkui Yao Department of Computer and Information Science, University of Oregon Eugene, OR 97403-1202, USA xiangkui@cs.uoregon.edu ABSTRACT There has been a rapid growth in navigation aids recently.

no meaningful personalization exists in these devices.


An around advice intercepts the outermost invocation in order to set up a ForkJoinPool, using the annotation attribute threads=2, and creates a RecursiveTask: Object around(AsynchronousRecursively ann) : outerMostCall(ann) { // necessary to pass ann into compute(): final AsynchronousRecursively a = ann; ForkJoinPool fjPool  = new ForkJoinPool(ann.threads()); MyRecursiveTask f = new MyRecursiveTask() { public Object compute() { Object obj = proceed(a); Result res = (Result)obj; return res.fetch();  } }; Object o = fjPool.invoke(f); return new Result(o); } This is basically the part performed in the main() method in Lea s example.

we have to use a class MyRecursiveTask extends RecursiveTask that makes compute() public (instead of protected as in RecursiveTask).


The .rst two methods are generally available for any mobile (Java) application.

viral distribution is speci.c for Gedda Headz .


Round-robin algorithms have O(1) time complexity and thus are highly ef.cient.

they have weak fairness with O(N) lag bounds in general.


In case (c) a static decision cannot be made.

using USRs we can formulate e.cient run time tests that will guarantee the legality of the constant propagation transformation at run time.


Therefore, we could usually treat types equal modulo .

we prefer not to do so and treat explicitly when needed.


The algorithm for the distributed caching of missed operations most likely will alleviate this problem, if the number of members of a shared object increases.

its performance also depends on the work patterns of the members of a shared object.


Contextual values [31] support variables similar to our modes of variables that hold di.erent values depending on the context.

they do not support modes of procedures and there is no notion of interruptible and resumable executions.


Its impact on the network is dependent on the duration of overload.

using cooperative swap does not match the performance of local memory over the long term.


5msperiod,respetively.Then 1 andN havethesameperiodof20ms.Supposethereis aGiottomodeswiths from1 toN witha5msperiod whihonformstotheGiottorequirements.Then1 hasa unitof5mswhereasN hasaunitof2.

5ms.Figure6depits atimingdiagramoftheGiottomodeswiths enabledat thel0mstimeinstantinthemiddleofaroundof1 .Sine bothmodes1 andN ontaintheGiottotaskP witha 20msperiod,P isnotterminatedbutanfnishitsomputationasifnothinghappened.Q 'sinvoationsare replaedbyexatlytwotimesasmanyinvoationsofthe GiottotaskR .SineN 'sroundhasalreadybeenompleted half-wayatthel0mstimeinstant,therewillbefourinvoationsofR beforetheendoftheroundatthe20mstime instant.WhenaGiottomodeswithourswithinaround, frsttheurrentGiottomodeisterminatedinstantaneously.


false paths are a well known problem in control .ow analysis; one solution is to employ k-CFA with larger values of k. it could be disastrous to recompute the entire control .ow graph with a higher value of k, as this quickly causes the graph to explode in size for interrupt-driven software.


From the .rst experiment, it seems that using batch queue predictions to decide where best to run work.ow tasks helps reduce the observed makespans.

we understand that in a real environment there are potential hidden factors not directly related to batch queue wait times which could impact our relatively small makespans.


Various DAG scheduling algorithms have been proposed for grid environments for optimizing various parameters [26, 42, 50].

they have neither attempted to orchestrate multiple work.ows as required in our application nor balance performance and reliability.


Dynamic deployment means that the language features an explicit deploy operator that, when run at level n, dynamically installs an instantiated aspect at level n +1.

aspectJ does not support dynamic deployment of aspects.


The randomly generated expressions can be quite complicated.

assignment operators occur only at statement level and within the initialization and increment parts of for-loops.


Moreover, we integrate variability modeling and staged con.guration.

we do currently not support cardinality-based feature modeling.


Selector logic can also be quite complicated in the case of .-join.

selector is a optimization mechanism that can help avoid excessive remote reads.


use x as if it has been declared as end "x":int = (current iter.elem.)

this has non-trivial implications for the concept of visibility rules, which must also be worked out in detail.


3.1.4 Require statement The require statement supports conditional atomic actions:8 RequireStatement: require Expression ; The Expression must be boolean-valued.

the effect of evaluating require exp ; is similar to evaluating if (!exp) retry ; an implementation may be able to use knowledge of the required condition to avoid retrying if the condition s value cannot have changed.9 3.1.5 Exceptions If an exception is thrown and not caught within an atomic action (i.e., the atomic action would complete abruptly), the atomic action fails, and is undone in a special way, as follows.


Sample code to implement a blocking operation on success or failure the color is changed to green or red respectively.

this design differentiated successful operations of the current user from the successful operations done by other users, and our users did not like this distinction.


Moreover, the user requires a smooth and transparent interaction with each of his devices and a high quality multimedia experience.

the digital home is more than ever an heterogeneous and complex environment, devices di.er in terms of resources and networking protocols turning the user requirements into an almost impossible task.


Only the methods that contain still optimized selfinvocations are concerned, and a method can be recompiled at most twice, since the recompilation must be done only the .rst time the group is moved.

the approach does not distinguish between self-invocations of methods/attributes introduced by the current class (which have actually been moved) and self-invocations of methods/attributes introduced in superclasses (which may have not been moved).


If it is notpossibleto usethese macrosin existing code(e.g.in external libraries), this optimisation can either be turned off, or the size information canbe strippedupon entrytolibrary code, and replaced upon return.This optimisation was usedbySMAin all our reported experimental results in Section 5.

in experiments we performedwith this optimisation turned off, wefound that roughly half ofSMA sreductioninmemory wastage compared withDoug Lea s algorithm is due to this optimisation, and the associated coalesce tag optimisation2(Section3.2.3).


The definition of the categories intensional/extensional and local/non-local for statements is also given in [13].

they do not deal explicitly with statements of the design and architecture that deal with specific systems and their categorization in these dimensions.


Inside a proof, using a callby-name semantics we could prove (x:Nat.Z) loop = Z, while at run-time using call-by-value the program would diverge.

if the argument t to an application is known to be terminating, because a proof p:t !


One of the possible work-arounds is the adoption of design patterns [5], which document and standardize solutions to common design problems.

implementing design patterns requires code changes and additions in multiple locations, with the concept and identity of the adopted design pattern being lost [14, 8].


In addition, in Java, to consume values of new types we must define new Listener classes.

franTk listeners can be parameterised over any type.


Most simpli.ers for the lambda calculus actually take advantage of this notion in spirit, as is manifest in their use of environments and closures.

it is often believed that an intrinsic use of explicit substitutions in particular, a re.ection of substitution encodings into term structure and the creation of such terms during reduction can be costly in terms of space usage.


(A ; B) A N.C) = (N.A A N.B) V ((X.A V (N.A A X.B)) A N.C) containing two occurrences of the subformula N.A.

by naming shared subformulae as de- scribed in Section 6, we can still represent the VC --1(W.S) as a formula whose size is linear in the size of S. Experimental Results We have implemented, as part of ESC/Java, both VC generation algorithms described in this paper.


For instance, if we decide to partition a sub-region using a 70-30 split, the partitioning will keep 70% of herds in left subregion and 30% in the right one.

the execution time is closely but not perfectly aligned with herd density.


3.2 Step 2: Selection of Design Strategy In most cases, RA s are not developed from scratch, but based on previous project experience [15] and existing architectures.

sometimes, the RA is built without any previous system.


It is clear that there are two distinct .ows of data throughout the function, which only merge at the end.

the aggregation of the two calculations (through return result ) causes the entire function body to be grouped as a single component.


If the fault policy is entirely consistent within a .le system, this could be done quite simply; we could run any workload, fail one of the blocks that is accessed, and conclude that the reaction to this block failure fully demonstrates the failure policy of the system.

.le systems are in practice more complex: they employ different techniques depending upon the operation performed and the type of the faulty block.


Towards Middleware-aware Integration of Event-based Communication into the Palladio Component Model*  Christoph RathfelderFZI Research Center for Benjamin KlattFZI Research Center for Samuel Kounev Karlsruhe Institute of Information Technology Information Technology Technology (KIT) Karlsruhe, Germany rathfelder@fzi.de Karlsruhe, Germany klatt@fzi.de Karlsruhe, Germany kounev@kit.edu David Evans University of Cambridge Cambridge, UK david.evans@cl.cam.ac.uk ABSTRACT The event-based communication paradigm is becoming increasingly ubiquitous as an enabling technology for building loosely-coupled distributed systems.

the loose coupling of components in such systems makes it hard for developers to predict their performance under load.


This abstraction allows singlethreaded operations to be made safe for multi-threaded use.

although software implementations of atomic blocks can scale well, they have high baseline performance costs around a factor-of-two overhead in uniprocessor cases is typical.


Economic Components as a Function of Information Perfection [9].

as increasing the information will also incur the detection and removal of residual defects, post-release cash outflows are likely to decrease.


Thus, the loss of type infor- mation that occurred in AspectJ does not happen in Hyper/J.

if an equate relationship is chosen, it is not possible to combine the singleton class with multiple different target classes because of the forwarding mechanism.


Some programs like jess and jack are highly instruction cache sensitive , meaning that from a processor-levelpoint of view the instruction cacheperformance has a large impact on the execution time of the program [18].

db and especially compress are highly data cache biased.


A nice explanation from the viewpoint of partial evaluation can be found in [18].

some features of AspectJ require the insertion of dynamic checks in the base programs, resulting in performance loss.


The points on a given line represent di.erent combinations of service price and response time that deliver the same satisfaction level, i.e., the customer is equally satis.ed at all points on a given line.

the customer prefers lines with higher satisfaction levels to those with lower satisfaction levels.


Both of these problems could be addressed by clever uses of C++ lambdas, templates, operator overloading, and destructors on stack allocated variables.

this would then preclude the use of Poli-C for pure C applications unless we also carried out substantial by-hand modi.cations of existing application code.


add(NewLinkedList().state, o).state and forallo: Object add(NewLinkedList().state, o).state .

addFirst(NewLinkedList().state, o).state the axiom foralll:LinkedListforall o: Object add(l,o).retval==true gives rise to only foralll:LinkedListforall o: Object add(l,o).retval .


This form of adaptation (conceptually) happens in a single step [3].

our approach adapts code not to its execution environment but to the data it operates on.


They mainly studied transactional properties for activities, which is not in our scope.


The Stargate is a much more capable platform, with a faster radio and processor, yielding very fast forwarding times.

the high power costs of keeping the platform awake, even with aggressive power-management, gives a very high average power.


It seems that this may allow many typical uses of frames/iframes.

at the time of writing we have notperformed any empirical investigations to determine the true impact of disabling contentWindow.


All I/O devices used by a job must be powered-up before a task starts execution due to the real-time nature of the tasks.

there are no restrictions on the time instants at which device states can be switched.


We expected these events to result in a short interval between events, explaining its overhead.

as Figure 10(d) shows, AGet s inter-event interval was moderately longer than most other cases.


The GME approach is heavyweight because metalevel speci.cations can be described fully.


This enabled developers to learn from the code and to contribute.

the viral e.ect of the GPL kept commercial companies from using SnipSnap software components.


The presence of write barriers involves some degree of cooperation by the compiler, or by the virtual machine.

adding the required logic to an existing compiler or VM is relatively straightforward.


These rules are called the Java Memory Model (JMM).

the JMM is more complex than an interleaved execution of the threads, where each thread executes in program order.


To achieve high retargetability of the testing framework, the test-case generation has to be done at source-code level.

it is challenging to guarantee that the test-cases obtained from the source code are also valid at the object-code level, since even in safety-critical domains programs are optimized during compilation, i.e., the compiler may also introduce new control-.ow decisions to the program.


As a solution for these problems, the provided secure communication overlay relies on 128-bit long identifiers, which are generated by hashing Elliptic Curve Cryptography (ECC) [13, 14] public keys with a Message-Digest algorithm 5 (MD5) [15].

these identifiers are not used through IPv6 BSD-style socket API, because our system is meant to be used also by devices without IP support.


When the deduced type of the body of a generic function does not match the type annotation for the function, the error message points to the type annotation.

the more important piece of information is which expression within the function body caused the mismatch.


We do not think that AOP is required to integrate replication into existing middleware systems, as it only changes the message sending and receiving semantics and does not in.uence the rest of the middleware implementation.

the architecture we present is not restricted to non-AOP approaches.