For some systems version of this system using 4 GB of memory (consuming 9 watts) per processor, the processor + memory power budget is Effects of increased memory on system power (90 Watt CPU, 9 Watt 4GB DIMM) dominated by the processor (90%).

for the same system 100% 90% using 32 GB of memory per processor, memory power grows to 80% 0% 44%, or almost half of the processor + memory power budget.


INTRODUCTION Concurrent and distributed systems are becoming increasingly important.

distributed applications can be difficult to design, build, and debug.


The ultimate responsibility for the format and content of the information in the tab lies with the applications and services in the CRUSE backend, as long as they comply with the CRUSE interface standards by utilizing the CRUSE interface API.

it is unreasonable to assume that these applications will format and present the content in a usable manner for different form factors; therefore in most cases CRUSE will retrieve the content from the backend and manage the formatting and presentation.


The synthesizer transforms the code into barrier-separated phases by taking into consideration each concurrent data-structure.

a naïve composition of these phases of multiple data-structures may result in non-optimal number of barriers.


Hence, the answer to RQ1 is that the functionalities most investigated are concerned with boosting performance, e.ectively managing memory, and adapting HLL VMs or their core components for resource-constrained environments.

the categories with less studies are security, MLT, RSVM, and testing.


For example, in the set of CFs developed in a previous paper [5], Pooling and Caching CFs can only be coupled to a Persistence CF and not directly to the application.

a Persistence CF can be coupled only directly to the application.


3.2 Protocol extensions and variations The protocol and diagnostic techniques discussed above provide good results for diagnosis, and indeed represent what we have implemented for evaluation.

especially for more speci.c cases, there could be many potential variations.


Due to the lack of structure for the USTM signal sets designed in [10], the noncoherent maximum a posteriori (MAP) detector given in [12] requires an exhaustive search among all the possible T ×Nt transmit signal matrices, and has a complexity which is exponentially proportional to the number of bits conveyed by the T × Nt signal matrix.

an orthogonally designed USTM was proposed in [13], in which the USTM signal is constructed using a known pilot matrix followed by an STBC signal matrix.


This technique, which applies to .nite state machine models as well as other kinds of models, is folklore, and we refer to [23] for a comprehensive text book overview.

using implementation coverage to enhance tests derived from models has, to the best of our knowledge, never been tried before.


The CERT researchers include in the description tools such as Fortify [11], Coverity [4], and FindBugs [28] that can automatically enforce the rule.

for some rules automatic detection is unavailable.


On average, this variant improves application performance by 3%.

because this modi.cation adds extra memory accesses, it also increases cache misses for most of the benchmarks except 255.vortex.


Systems based on virtual reality technologies are complex to design and implement.

this complexity becomes more evident when virtual reality systems are developed in the scope of astronomy for two reasons.


The touch and feel of the development environment including the intelli-sense autocompletion feature supports easy, rapid development of code.

we believe that it is too complicated for the novice programmer to use effectively.


In the example shown, speculating all loop-carried dependences to make DOALL applicable could cause excessive misspeculation since the linked-list traversal dependence manifests on every loop iteration.

a better option is to synchronize these dependences as in DOACROSS and speculate only the inputdependent self-dependence in statement C. the problem of inter-core communication latency on the critical path persists.


[10], address the .xed size VM problem of cloud infrastructure vendors, which they refer to as the t-shirt model.

in some private cloud scenarios, the capacity of each VM is permitted to change dynamically using a time-sharing mechanism.


In Section 3 we will show a direct application of the concepts developed in this section to the C/C++ programming languages.

2.2 MemoryModel andExecutionModes Ourapproachhinges upontwokeynotions:reactive memory locations and constraints.Reactive memory can be read and writtenjustlike ordinarymemory.differentlyfrom ordinary memory: 1.


When a conventional Java program that runs on a single computer is used, the running time is greater than 6 hours.

when a MapReduce program is used, the running time is less than 2 hours.


Subsequently, the paper [13] used BDD-compressed traces to visualize and extract potential parallelism from programs.

this paper does not discuss the time required to create a BDD representation of trace information.


The most promising SPL implementation technique is the aspect, which enables extensions beneath the function or type level by addressing particular extension points.

the data do not reveal whether an implementation technique is applicable and workarounds for refactorings using either feature modules or aspects may be necessary [17, 29].


In particular, the simulator achieves security in an information-theoretic sense without making any query to the point function oracle and simulates general adversaries using just black-box access (to the adversary) and no additional nonuniformity.

the construction only achieves computational functionality, that is, given a circuit produced by their construction, no e.cient algorithm can .nd an input on which this circuit di.ers from the desired functionality.


This feature can also be used in conjunction with our prototypical implementation of the design prompter.

there is space for further enhancements, such as the presentation of the design recommendations which is currently limited to individual classes.


Hence, selfadaptation would permit, in principle, the autonomous evolution of the software without the need for manual intervention.

in practice nearly no system is developed anew and it will not be possible and wanted to handle all aspects of the evolution autonomously without human supervision.


4.4 Alternative implementations The Twin Class Hierarchy approach is designed speci.cally to permit instrumentation of Java standard libraries [2], by constructing a parallel, independent hierarchy that contains modi.ed copies of each original class in the runtime.


Such representation is essentially reactive.

to provide this integrated and near-to-reality perception of the ubiquitous environment, the use of multiple and heterogeneous sources of context is needed.


In fact, they have been successfully applied to the entire Linux kernel [15].

object-based approaches cannot always enforce complete spatial safety because of sub-object over.ows.


There are well-defined visual formalisms outside of the UML that could be used to model security protocols: labeled transition systems, Harel's original stat- echarts, and Petri nets.

each of these three is also lacking according to at least one criterion.


In this context, there have been efforts for defining semantics for activity diagram in the works of Eshuis [10] [11].

these works not consider the hierarchical decomposition of activities in UML AD.


3.8 Measurement Comparison When measurements of the same dimension are compared, the system has to convert them to a common unit before comparing their amounts.

when comparing measurements 1 Quantity refers to what we call measurement not automatically convertible between each other, like 100 dollars < 100 euros , the same solution cannot be adopted.


The side effect of this behavior is having less CPUs devoted to computing the final answer.

this may not be a problem since there would be more processors available in a computational Grid in comparison to the amount of processors in a single local cluster LHRP is design for grids that are made up of cluster computers.


Truly dynamic changes to solutions build on components are extremely challenging in terms of correctness, robustness, and efficiency of the resulting systems.

even at tier three, most of the problems already surface.


Intuitively, this sounds true since software systems can generally be described (and built) in terms of a set of common architectural and design patterns and these patterns are much more stable than the software system itself.

eA 09, May 18, 2009, Vancouver, Canada this assertion is highly dependent on the language used to specify the conceptual model, especially on the mechanisms provided to select and bind the base code elements to the conceptual elements.


For example, when we want to .nd the shortest path from a vertex s,paths whose startpoints are not s are useless.

naive execution of Algorithm Aresults in enumeration of such useless paths.


For a language with open-sourced libraries, it would be possible to actually compile the library methods to X10.

many MAT L A B libraries are closed source and thus it is not possible to translate them to X10.


We believe our system sufficiently balances flexibility with the other updating criteria: the generality of our dynamic patches allows us to achieve most of the flexibility of the most general solutions, and programmer control of patch ap- plication gives good flexibility in timing updating.

there are some important flexibility limitations we would like to address, as informed by our experience with FlashEd.


´eal,Qu´October21 25,2007,Montr Jonathan Aldrich Carnegie Mellon University aldrich@cs.cmu.edu contexts where the structure of the data is of primary importance, such as in data persistence or distributed computing.

by-name subtyping also has its advantages.


In general, it has ful.lled its goal in forcing students to deliver solutions acceptable by software engineering standards.

the teaching assistants often found it hard to differentiate between / and - grades, because a - had a severe impact on the team s chances of passing the course.


One general solution to overcome the limitations of Zephyr would be to rewrite a whole new code generation algorithm that combines instruction selection and register allocation in one phase, as done in many other compilers for DSPs [13].

this would require too much retargeting e.ort of any compiler designers who want to retarget their compilers like Zephyr.


When the requested resource is not available, NASP tries to find an alternate resource.

before going into the standard procedure to find the alternate resource, NASP checks with cognitive agent for the history of transactions where alternate resources had been provided.


Therefore its SDI value reaches almost 1.

every file occupies at least one cluster group in GCA, which means that many cluster groups can be wasted to hold many small-sized files, resulting in the low SDI values.


In the following, we therefore assume that the garbage collector executes at lowest priority, as entailed by ratemonotonic priority assignment for the task with the longest period.

the proposed solutions do not necessarily require this assumption, and tasks with longer periods or non-real-time tasks may execute at lower priorities than the garbage collector.


Second, SL approaches generally either require heavyweight theorem proving and/or a relatively heavy programmer annotation burden [37] or are fully automated, and thereby limited by what the compiler can infer [25, 39].

we chose to start from the extensive prior work on regions and effects, which is more mature than SL for OO languages.


The authors of [17] develop a multi-state availability model based on semi-Markov to predict future resource availability.

the applications of FGCS in [17] are confined to be CPU-bound batch programs, which are sequential or comprise multiple tasks with little or no inter-task communication.


4.3.2 Experiences with Visitor Our original set of agreed statements identi.ed four positive and four negative issues.

in coding, we made little use of one of the positive issues and hence dropped this from the set, on the basis that the concepts concerned were adequately addressed by the other three.


A high NIM value indicates a large class that may be trying to do too much of the work itself instead of putting the responsibilities where they belong.

these metrics end up in the calculation of in/out degree, which as already explained, is not sufficient to distinguish between central and peripheral classes as in the example of Figure 4, although it fulfills the criterion b).


They are application software on the Host OS and enables unmodified OS to run as the Guest OS.

vMware and VirtualPC require the GUI environment and QEMU can not provide enough performance now.


The order of the message transmission has a great e.ect on the scheduling of messages, specially if the link serves the way to a number of message streams such as when providing connectivity between two switches.

it is hard to predict the order of transmission at each downlink of each switch because of the possible jitter in the activation of messages (at their nodes) and also the jitter in the switch delays.


In our extension, if receiving ACK is true, transmitting packet is considered as a success.

ifreceivingACKis false, thevalueof NRT is incremented by 1, as shown in step 7 of Figure 1 and the sender compares its NRT value with the value of aMaxFrameRetries.


A simple approach to reuse an SPL is to con.gure and derive a valid product, which can be used in other SPLs.

this approach is insu.cient when di.erent products of the same SPL are needed depending on the con.guration of the reusing SPL.


Note that the boxes for the MUL and FORLOOP bytecodes represent multiple basic blocks since the implementation of these bytecodes requires some control .ow for type checks and exception handling.

it is also suf.cient to trace one path through this control .ow as the behavior is the same for each loop iteration.


For Type-3 case (Table 7), MFd < MFn suggests that Type-3 clones are more stable than the corresponding non-cloned code.

according to this method, Type-1 and Type-2 clones of DNSJava are much less stable than non-cloned code (The di.erence of MF s for the Type-3 case is smaller compared to the differences for the other two cases).


One could argue that instead of adding this kind of side-effect behaviour, one could modify the commands generator.

doing so would lead to simple errors getting hidden and obscured.


4.3 TarantulawithOutputMapping The Tarantula algorithm presented in Section 4.1 localizes failuresbased onhow often statements are executedinfailing andpassing executions.

in theWeb-application domain, a significantnumber oflinesareexecutedin both cases, oronly infailing executions.


It may decide to wait for additional, nearby requests.

even if a new request from the last process arrives in this period, the scheduler then con-tinues to pick the same old request.


There do exist standards for representing the data stored in social networks, for authenticating users in a decentralized manner, and for delegating user access rights.

there is no comprehensive implementation of all of these standards that would lead to functionality comparable to today s Web 2.0 sites.


Clearly, this group is operating as a team to accomplish a common goal: improving the quality of the garbage collector.

the issue dealt with has parts scattered across the code base.


It is trivial to identify tfield for branches such as if(stack.size == 10), where tfield (such as size) is directly included in the branch.

in objectoriented code, branches often involve method calls such as if(!vertices.Contains(v1)) in Statement 7 (Figure 1) rather than .elds.


The VLIW architecture with a very wide instruction width and high branch miss penalty would require speci.c .ne-tuning of each code to perform well [7].

none of our test cases was tuned for a speci.c device.


The .ag is only true 4 when the input value of i is zero.

because of the 3 plateau, the search is not provided with any direction as to 2  3.2.2 The Chaining Approach The Chaining Approach was originally developed by Ferguson and Korel [7, 8, 11], utilizing a local search method.


Annotations are frequently used to reduce the dynamic compilation overhead in embedded Java environments where the memory budget and CPU speed are limited.

some annotations can cause the dynamic compiler to generate code that violates the security policy of the JVM.


if we change w.color = red to w.color = blue, the color of old w objects bound will remain red, only future w objects will be blue.

live visual languages execute changed code as if it was always in its post edit state.


2.2 Language uni.cation (L) Language extension and language restriction assume the existence of one dominant (typically general-purpose) language that can serve as the base of other languages.

sometimes it is more natural to compose languages on equal terms.


As a consequence, the cross-cutting concerns are not suitable for explicit visualization, since they typically relate elements from di.erent diagrams.

they are very important parts of the model and are necessary e.g.


inFigure3, the use of Interval Vector cannot help Pk in eliminating its false negative conclusion.


Reactive systems tend to be embedded, distributed, or real-time in nature.

as the size of non-reactive transformational systems get larger it is likely that some state based concerns will appear.


Web services are a promising and currently widely researched approach in particular for large scale open systems, as they offer globally accessible and platform independent applications via standardized protocols and service descriptions.

(Semantic) Web services do not provide support for persistent publication of data, nor time-decoupling of messages so that data can outlive the services publishing or consuming it.


As stated above, each test procedure requires the complete P Set, which is the set that contains all feasible P Runs.

it is usually not available in practice.


This might be a threat to the validity of the dataset.

in the presented data each system counts irrespectively of its size, so the bias introduced by these correlations is very low.


Generally, escape analysis wishes simply to determine whether allocation sites produce objects that ever escape after allocation.

we can eliminate a write barrier to an eventually-escaping object if the the write occurs before the object has escaped.


Appropriate domains and behavior are added to the context to describe how authentication takes place from the point of view of the user (in problem space).

one cannot necessarily stop at the addition of domains and phenomena.


We were much less compelled to add also requires, because we deemed its use a probable programmer error (some programmers design their programs as if it would be sound to strengthen preconditions in subclasses).

again due to the lack of abstraction features, we do allow also requires in one special case, as described in the user s manual [33].


Bob takes a taxi, and tries to pay the taxi driver using his cellphone when he reaches his hotel.

the unloading lobby is underground and neither Bob nor the taxi driver cangeta signal on their wireless equipment.


FUTURE TOPICS There are a number of issues and topics around cloudbased application logging that we haven t been able to discuss in this paper.

we are interested in addressing them at a future point in time are: security visualization[1], forensic timeline analysis, log review, log correlation, and policy monitoring.


Doing so enables more e.cient hardware utilization, easier management, and quicker failure recovery.

to realize these bene.ts, VMs may often need to be launched on machines that have not been pre-loaded with a copy of the corresponding VM image.


The more suitable approach would be to split the regions (boxes) across available reducers and have each reduce function independently read the input station records and assign records that belong to its region (box).

this can be viewed more as a parallelisation strategy for compute-intensive step rather than data-intensive computing using MapReduce.


Even though PAS generation was parallelized using multiple threads on the CPU, the cost of PAS gen overwhelms other parts of execution.

vAST still outperforms CPU execution on SpMV as shown in Figure 8.


Devices already have pre-established interactions and are normally used under a single administrative domain.

distributed key pair assignment is more .exible, yet more complex to implement and heavier on the network.


know whether the subclass invariant has been established prior to such calls.

in the statement of the invariant rule, we use the notion of codependency (from Section 4.1) as a way to conservatively detect which variables might be related by an invariant.


In FP the compiler checks that all the rules of a function have the same number of arguments, but this is not checked for the rules of member functions in different instances.

this property must be checked if the proposed translation is used.


The type of 'aso.promoProdut O'is unknown at compile time, since its owning class 'DVD'and the associated 'CrossPromotionType'(in this case 'DVD Player')are not known before their creation at runtime.

the result of 'aso.promoProdut O'can still be used in a typesafe manner: Assuming a further method of class 'DVD', 'playOn CrossPromotionTypeO', the following code is statically safe: 'aso.playOnaso.promoProdut OO'or alternatively, 'aso.playOn netaso.CrossPromotionTypeOO'.


Here the merchant ships goods to customers of legal age only.

she accepts payment by credit card to be proof of legal age.


They use a key caching based technique that relies on subscription popularity to reduce the number of encryptions and to increase message throughput.

their approach requires that the pub-sub network nodes (brokers) are completely trustworthy.


We found that this technique worked well for the smaller functions in the applications since it was often the case that the batch compiler produced code that was as good as the code generated by the best sequence found in the search.

the smaller functions tended to converge on the best sequence in the search in fewer generations anyway since the sequence lengths were typically shorter.


Sampling greatly reduces the overhead of the technique and allows it to be used on live applications, which is a signi.cant bene.t.

sampling also increases the number of false positives generated by the approach.


This allows di.erences to be scoped at the basic block or statement level.

it is not clear if the noise from errors is worth the extra precision.


Figure1 tells that at the systemlevel, using absolute values of RSS for distance estimation is not reasonable since identicalRSS valuesmay correspond todifferentdistances.

for eachindividualcurve(i.e.,from the viewpoint of a single node), RSS values mostly decreased monotonically withincreasingdistance, conveyinginformation about relative near-far relationshipsamong1-hop neighbors.


Their primary focus is on an API that supports anonymous data access in a distributed OSN.

they assume that the server is trusted with the data for access control.


For example, in the log block schemes [7, 8], when writing data to log block which is used as a buffer for random write operations, the write algorithm is based on the in-place writing first and then out-of place writing .

this scheme may violate the sequential write restriction.


4.2 Many-Task Version The previous implementation treats the supernova detection as a single monolithic application that is applied to a set of independent input .les.

as Figures 3 and 4  Figure 6: Task graph of the many-task version.


We also show that simple soft error detectors can provide low overhead mechanisms with few false positives.

these techniques probably do not provide an acceptable reduction in application soft error vulnerability.


Our previous work only considered purely functional data types, i.e., data types with immutable state.

the implementation of the same data type using an imperative style, where the state is mutable and the same entity can go through several different states, can differ quite a lot from a functional implementation.


If the language were extended with pointer equality, then a condition might turn out differently on H2 than on H1.

theorem 3.2 would still hold if a rule analogous to GET-CRASH3 were introduced that allowed us to derive a .O judgment in (2) instead of executing an inconsistent pointer equality.


It is an extension to the Common Lisp Object System (CLOS, [2]), which in turn is based on the notion of generic functions instead of the more widespread class-based object model.

the contextoriented features of ContextL are conceptually independent of the CLOS object model, and a mapping of ContextL features to a hypothetical Java-style language extension called ContextJ has been described in [5].1  Layers are the essential extension provided by ContextL on which all susequent features of ContextL are based.


Consider Figure 2(c) again: if T0 through T3 happen to access a very small number of banks, signi.cant memory stalls can be experienced.

if these tiles access different banks, we may have high levels of BLP.


This is a gigantic burden on Process0 and the performance in Figure 16 re.ects this (as expected).

with the use of the PSCT we can dramatically decrease the number of requests that need to be answered by any single process.


Many individual research groups undertake valuable empirical studies.

because the goal of such work is usually either individual publications and/or post-graduate theses, there is often little sense of overall purpose to such studies.


Thus, the tools calculate di.erent values for these metrics.

looking at the NOC metrics, we observe that all tools calculate the same values for the classes in this project.


could su.er a deadlock if scheduled by an adversary that is not in A, but we are only interested in schedules by the adversaries in A. as E for almost all processes.

we then evaluate the relative probability of the two colour schedules M and N. Since we only .ip some registers from green to red in order to obtain N from M, colour schedule N is signi.cantly less likely than colour schedule M. we also have to take into account the number of distinct colour schedules MI that get mapped to the same N in order to avoid that process b .nds some other process in step s. 6.1 Preliminaries We start with some observations regarding the rollforward rules.


fail to let authors create compositions with unspecified internal content or unspecified relationships.

extension languages have been defined to increase the facilities of those languages in line with design patterns principles, like SMIL Timesheets [5] aiming at allowing any language to incorporate the XML elements and attributes of the SMIL temporal control modules.


There has been research that supported modeling-level aspect-orientation based on a speci.c AOP language such as AspectJ: an aspect at the modeling-level is converted to an aspect in AspectJ[7].

there are problems in these approaches: a PSM is limited to a speci.c AOP language; most of current AOP languages are based on a few .xed set of JPMs; and we cannot separate concerns that cannot be separated by current AOP languages.


When they find the comments are constructive and valuable, they will revise their code sincerely and carefully.

there are a few author students who might perform in the following two ways: (i) do not pay attention to their written manuscript code, neither compile nor test the code, or rush to send the email to the reviewer and wait for their comments; (ii) after receiving the comments form, the author will briefly look through it and make only casual revisions.


INTRODUCTION  Many design companies and organizations have often viewed accessibility as an issue related to government agencies and the agencies' suppliers.

supporting accessibility is mandatory for many organizations.


These benchmarks do not contain generator loops that are performance critical, hence they cannot bene.t from generator peeling.

including these additional results demonstrate ZipPy s performance on a wider selection of programs.


Performance of Class A (14,000 Rows) with Slower Network  veloped for parallelizing irregular applications written in High Performance Fortran (HPF) extensions [1, 25, 15, 20, 26].

these techniques have not yet been fully implemented in a production level compiler.


This is due to the use of low-range NDP in addition to WiFi scanning and transmissions.

the power consumption ratio is much lower for the follower nodes, which only have to participate in the NDP.


INTRODUCTION One of the main research approaches in the field of computer science is to construct something novel [1].

some innovative technological solutions developed within the field of computer science are not relevant for the practitioners or users.


The PC browser is used for nonsecurity-critical tasks: browsing the product catalogue, making selections etc.

when the user starts to purchase the goods, the form requesting credit card details automatically appears on their cell phone.


It is an extract of an educational game which warns of domestic electrical accidents (DEA game) whose objective consists in causing an electric shock for the player [4].

at first, the game designer (author) anticipates that the player, from an initial position, will go to the kitchen, where the IS controller will start the strategy of causing the electric shock for her/him, via appliances there such as a fridge, a microwave oven, an electric cooker, besides the possibility of going to the kitchen, the player may have other choices, for instance, staying at the initial position to work or going to the bathroom.


As lock operations and application terms are annotated with their continuation e.ect, it is natural that e.ects .ow backwards through the type system: the input e.ect to an expression e represents the events that follow in the future of e, that is, after e is evaluated.

the output e.ect represents the combined sequence of events caused by e and its future.


In fact, agile practices focus on coding and try to keep documentation as minimal as possible.

this does not mean that agile processes do not include any documentation.


Our proposed extensions were driven by the needs that arose during the development of our speci.c case-study; and hence it is possible that, through the development of additional behavioral projects, BP may need to be extended with additional idioms.

due to the large variety of programming tasks entailed by the web-server project (e.g., handling timeouts, string manipulation, .le access, checksum calculations, etc), we believe that our proposed extensions are robust, and could prove suf.cient for a variety of programming tasks.


Results show that both schemes outperform previous approaches and, at the same time, they reduce compile time.

one surprising result was that a posterori and on-the-.y techniques turned out to achieve very similar results.


In such cases, programmers are specifying how the rest of the program should interact with a module, potentially improving readability and maintainability.

in declarations that are hidden from external modules, we expect programmers to opt for the simplicity and .exibility offered by untyped declarations more often.


To summarize, in case a race occurs, it is possible that several threads record the slot s in their local bu.ers.

all of them record the same correct value of s at the k - 1st pause.


Note that it may be possible to reduce the size of the partition identi.ed by the algorithm by performing additional analysis (e.g., by distinguishing di.erent kinds of use relationships among classes).

doing so would increase the cost of the partitioning and, as the studies in Section 3 show, our current approach is e.ective in practice.


Instead of using LOOCV, we may apply K-fold CV, as well.

its score would not be an unbiased estimator of the generalization error even though it would be more realistic than the score obtained by leaving out only one data point.


Many commodity operating systems also support an interposition mechanism for system calls intended for debugging purposes, such as ptrace in Unix-like systems, and it is also possible to interpose on OS library APIs [18].

the complexity of the relevant interfaces makes these solutions demanding to use, and tightly couples the implementation of an extension to a speci.c OS.


FRP offers the right abstractions to make event-driven programming convenient, safe and composable.

existing web frameworks and programming languages exploit the bene.ts of both approaches separately, for example by restricting the use of FRP to the client side.


The architectures presented in this work are far from the "perception-representation-action loops" (a.k.a., Design Animism) presented by Laurel [18].

we believe the exploration of this aesthetic conception is worth with regard to our architectural styles.


As a result of the loop fusion, the granularity of parallel loops is increased [18].

its optimization performance is not always very clear because of the dependencies on the programs.


Also, it is not necessary to identify sub-expressions, as all bytecode instructions stand on their own.


CONTEXT-SENSITIVE MERGING The context-free rules given in Subsection 5.2 may be applied to attributes as they stand.

when they are applied to links, they ignore context-sensitive con.icts.


Note that we could use a similar organization to compute a matrix-vector product Ax, where A is an N × N matrix and x an N × 1 vector.

using only one column of R ×1 computeprocessors requires M = R +1 memory processors.


In other words, we show how the bounds on the worst-case skews depend on all these parameters.

another aspect of clock synchronization, which so far has not received much attention, is that a practical clock synchronization algorithm must ensure that the rates of progress of all logical clock values are always within speci.c bounds, i.e., the clock values are not allowed to change substantially in a short time.3 bounding the clock rates inhibits the ability of an algorithm to react to clock skews, which have to be kept as small as possible.


This combination seems to violate the CAP theorem [2], which says a distributed system cannot have availability, consistency, and partition tolerance at the same time.

our system, in practice, provides all three of these properties within a storage stamp.


In polyphase and vpenta, hybrid is outperformed by KilI-4K and Drowsy-4K.

in the remaining five benchmarks, hybrid gener- ates the best results.


[17] scale up k-objectsensitivity, increasing k by one using types rather than allocation sites.

in all of this work, which parts of the abstraction should be more re.ned is largely left up to the user.


Semantic Web Data Visualization with Graph Style Sheets Emmanuel Pietriga* INRIA & Laboratoire de Recherche en Informatique (LRI) Universit ´e Paris Sud, 91405 Orsay, France Abstract Visual paradigms such as node-link diagrams are well suited to the representation of Semantic Web data encoded with the Resource Description Framework (RDF), whose data model can be seen as a directed labeled graph.

these representations are not fully satisfying: diagrams can quickly become big and over-cluttered, making them hard to understand.


Since the new table types also use the same ETS memory management code their performance is also effected by this component.

the new table types have less hot spots than the set and can thus perform better when several NUMA nodes are used.


If the machine is in a slope, the controller application should not decide to release hydraulic pressure.

on .at surface, the hydraulic pressure can be released.


almost in any case this investment is many times cheaper compared to mitigations designed and applied later in the system lifecycle.


The LRU order is 1To e.ciently track the MRC, changes to basic Mattson s algorithm are made so that the MRC is computed approximately.

the computed MRCs are accurate enough tobeuseful(SeetheresultsofSection4 and 5).


Other potential sources of ideas for construction rules include [2, 6, 17, 19, 21-24].

there still remains work to be undertaken to ensure that such approaches gain commercial acceptance.


AO4BPEL has an important disadvantage in the fact that advices have to be modeled using BPEL.

padus is based in advices de.ned using BPEL, and pointcuts described with a logic language.


Until recently, many peer-to-peer applications were built essentiallyfromscratch, usinggeneral-purposeprogramming languages.

the complexity involved in recent systems has grown to a point where low-level details, such as manipulating network sockets or dealing with timers, burden the development e.ort.


Jackson s problem frames is a technique that is suitable for straightforward IT systems descriptions.

when an organization deploys an IT system that must deliver upon its competitive business strategy, then an appropriate technique or method needs to be used to capture that business strategy in order to connect it to businesscritical IT requirements.


In [7] component interaction uses events to loosely couple widgets as in Sqwelch.

the definition of what constitutes a widget different: In Sqwelch they are web applications, whereas in [7] they are lower level components such as pie charts and query widgets.


Requiring a separate object emphasizes intentional interaction and is less susceptible to accidental use.

objects can be lost, which is why we chose an inexpensive, easy-to-replace colored ball.


This empiricism allows us to conclude that on typical C programs, an optimized implementation of Andersen s analysis scales much better than its worst-case bound of O(n 3) in the size of the program (Section 5.4) and that a linked list append function that runs in linear time in the length of the list is a performance bug in banshee s parser (Section 5.5), but the same idiom is not a bug in the context of elsa s data structures for resolving name lookup (Section 5.6).

6.1.2 When Workloads Oversimplify the user of trend-prof must choose workloads carefully or risk generating results that do not generalize.


4.2 Model migrators As said in the previous section, BYADL provides software architects with the means to create customized ADLs by extending existing ones.

in this scenario it is important that tools supporting original ADLs can still be used to manipulate and analyze models which have been created by means of the new composed ADLs.


When the object is a literal the original triple is deleted from the graph and a sanitized version is added to the graph in replacement.

when the object value is an IRI then the sensitive triples are computed, which are those that contain the IRI.


The memory overhead for the .ne-grain analysis is substantial (columns 3 and 4), since every .eld and array element requires a its own VarState object.

fASTTRACK s memory requirements are substantially better than DJIT+ s because many 5 Some of the JavaGrande benchmark programs were run on smaller data sets than we used, which could also impact relative performance.


Many informal catalogues exist [16, 31, 4, 6] explaining how they are used and implemented.

for all the informal descriptions of design patterns, there is still no standardised way of formally de.ning what a design pattern consists of, or how it can be automatically processed with veri.cation or developer tools.


Existing test-case generation approaches can be added to our testing framework for AutoResolver, e.g., plain random input generation, or evolutionary test case generation [28], which targets large input domains and has been used successfully in industrial applications [7].

as already explained, it is impossible for any such tools to directly tackle the AutoResolver input space.


We attribute the higher hit rate of our approach to its ability to drive the execution through a previously observed synchronization schedule more reliably.

observe that the Replayer drives the execution Figure 9.


On one hand, existing techniques work at the individual program entity level and assess the fault suspiciousness of program entities separately.

the transfer of fault suspiciousness of one program entity to another will change the fault suspiciousness of the latter.


In functional languages, pickler combinators [10, 17] can reduce the effort of manually writing pickling and unpickling functions to a large extent.

existing approaches do not support object-oriented concepts such as subtyping polymorphism.


Given MyMorph : Morph, this binding is then replicated for MyMorph s world and parent.world facets.

this replication can be expressed as: B(p, A.e.G, A.f.G) = fb D(p, B.e, A.f) = fd B(p, B.e.G, B.f.G) = fb + fd where B represents binding relationships that are initially seeded by bindings encoded in the program: B(p = trait A ... f = g, A.f, A.g) = 0 B(p = trait A ... f = g, A.g, A.f) = 0 B relationships then generate D relationships that affect extension graph shortest path computations: B(p, e, f) = f D(p, e, f) = f binding edges are fundamentally weaker than typical extension edges in one very important way: binding relationships cannot be derived across other binding relationships.


The modeling entities are similar as those provided by, for example, UML2 component diagrams: component types, component parts (also called component prototypes), ports and connectors.

in EPM components are called functions,to highlight the fact that they are intended to be used not only on implementation level, i.e.


http://www.someservice.com/< tenant> / easier to manage and evolve the schema itself, to use less computational resources, and to run analytics on the whole system data.

its use requires initial changes to the original schema and indexes, it may happen that data from one Tenant leaks to another, and changes are required in the SQL statements used in the application.


In that case, we can combine these aggregates into one index structure by replacing the list of aggregates in Figure 8 with a list of aggregate tuples.

two very important aggregates maximum and minimum are not divisible.


The OSEK/VDX system generator uses this knowledge to generate an OS variant that is speci.cally tuned for the given application.

if the application violates the properties assured by the de.nitions in the system con.guration to the system generator, the runtime behavior is unde.ned according to the OSEK/VDX speci.cation [19].


To see this, consider the following simple example in which the invocation of m("def") in the main method of class B on an instance of a class A is meant to bind to A.m(String), but really binds to m(Object): class A { private void m(String s) { } void m(Object o) { m("abc"); } } public class B extends A { void m(String s) {  } public static void main(String args[]) { A a = new A(); a.m("def"); A b = new B(); b.m(true); } } To change binding, accessibility of A.m(String) must be increased [6, §6.6.2.1].

this also changes the dynamic binding of the invocation of m("abc") on an instance of B in A.m(Object), which now binds to B.m(String) rather than A.m(String) as before.


logically attached to the EJP name) and the scope to which those semantics apply, providing good comprehensibility.

the EJP implementation details are completely separate and not visible in the base code, providing good readability.


It is clear that the MJRT increase in all tested allocation algorithms.

the rate of increase in MJRT when applying the bounded-ANCA algorithm is considerably less.


Simple locality-enhancing transformations Because the oct-tree in Barnes-Hut is a highly dynamic data structure, exploiting locality in the traversals is dif.cult.

as 2 The full Barnes-Hut algorithm consists of several phases; we concentrate on the force computation phase, which is both the most time-consuming phase, and the phase with the computational structure we are interested in.


An example program is given in Figure 2, where DEF and USE are as follows: DEFA = {x, z} USEA = Ø DEFB = Ø USEB = {x, y} DEFC = {x, z} USEC = {x, z} DEFD = Ø USED = {x} If we solve for INb and OUTb, we .nd that z is not live upon entry to D (that is, z ./IND).

z is considered live on entry to C, even though it is never affects the output of the program.


The second implementation consideration was to execute SOS instances in light-weight threads rather than processes.

using threads implies that the global state used by each SOS node must be suitably protected so that the di.erent SOS nodes did not invariably share the global data.


5.3 Mapping of Feature Constraints to Decision Constraints Above, we only provide a mapping of the structure of the feature diagram to decision constraints.

a free feature diagram can have further constraints, both textual and graphical.


We have deployed and run the Place Lab mapping service and the PHT on top of the public Planet Lab-based [27] OpenDHT deployment.

for our experimental evaluation, we chose to use our own independent OpenDHT deployment.


In many approaches [6, 10, 11, 1] these formal representations are only used as a pattern to recover low abstract level components.

in our approach, this formal speci.cation is just the content of the components, so we have a content-oriented retrieval.


On one hand, speech synthesis is considered as far more efficient than recorded words, since the amount of data that has to be transferred over the bandwidth is a critical issue in web system design.

speech synthesis generally generates inaccurate pronunciation.


Recently, a number of generic approaches have emerged that include timing behavior (e.g., MARTE [20]).

these approaches focus predominantly on later development phases or abstract from details such as allowed jitter, which are essential for requirements analysis.


3.3.1 Recruitment Pro.le-cast can be used to perform the dissemination, and a pro.le which includes the locations in the sensing area can be used as the target pro.le.

unlike the original version of pro.le-cast, where the aim is to reach nodes matching a certain target pro.le, for recruitment it is necessary to also reach the nodes that match only a part of the target pro.le.


it still gives the worst slowdown of 8% on average.


The iterative context-bounding algorithm bounds the number of context switches in an execution.

a thread in the program can execute an arbitrary number of steps between context switches, leaving the execution depth unbounded.


In contrast to Scheme and similar to Lisp, Racket provides facilities for adapting its lexical syntax (using readers) and thus supports more .exible syntactic embeddings of DSLs [18].

racket lacks support for a high-level syntax formalism, and reader implementations do not compose well.


JTL has native predicates for extracting the parameters of a method, its local variables, and the external variables and methods which it may access, and as shown, even support for data.ow analysis.

aSTs make it easier to examine the control structure.


Normal method declarations using the language given def expression changes the execution scope of the expressions, thereby prohibiting access to the surrounding scope.

by using the metaobjects, code in the surrounding scope, for example local variables are visible in the declaration too.


In the implementation phase, the agreement scenario is mapped to a technical architecture and application system.

if the agreement scenario is supposed to include some kind of negotiations between buyers and sellers, there are no common means by which the market creator and its stakeholders can reason about the potential form of these negotiations.


In fact, this vision is not di.erent from that of Brooks [3].

since the notion of concept is not precisely de.ned in the article, many researchers have since worked on the concept assignment problem while speaking about widely di.erent things.


We therefore consider data from several points in time.

it should be noted that the goals of this study di.er slightly from those usually considered as common for software evolution.


This approach is a way to do assume-guarantee predictive testing in a system where there are no design-level models.

it may not be practical to generate a new assumption for each trace; we plan to experiment with this approach in the future.


Speculative partial redundancy elimination (SPRE) inserts new computations on low frequency paths and removes them from high frequency paths, with the goal of minimizing the expected number of computations [9,6].

not all computations are suitable for SPRE.


This is possible to a certain degree with bytecode interpreters [11, 12].

we argued in [72] that AST interpreters allow for much more extensive modi.cations.


Self [26] with its Morphic [16] UI library gets around this limitation by supporting the direct manipulation [24] of object run-time structures, although such edits only persist and do not affect the object s code.

our work is able to support liveness through a deep connection between code and program execution as well as direct manipulation whose effects are enshrined in code.


The .fth parameter is automatically provided and computed by the GPU framework and API (GLSL was chosen for this paper.

the algorithms presented here are pseudo-code and they do not take in account any platform-speci.cs); therefore, it s not explicitly passed to the computeDP Iteration procedure.


One way to tackle the state explosion problem is to use models and/or relax execution consistency.File system modelshave allowed, for instance, KLEE to test UNIX utilities without involving the real .lesystem.

based on our own experience writing models for KLEE, doing so is labor-intensive and error-prone.


NODED SIMILARITY BASED LPA Label propagation is a near linear algorithm while accommodate to GraphLab very well.

in order to achieve such a linear complexity, basic LPA sacri.ces some stability, namely introduce random propagate.


This technique has been elaborated in detail by Danielsson [8].

it is dif.cult to see whether we could capture all the possibilities for good fs in a single type.


State-of-the-art approaches to binary obfuscation are based on the following three techniques: 1) inserting, after an unconditional control transfer instruction, junk bytes, which are unreachable at runtime but make disassemblers confuse alignment of instructions, 2) replacing a control transfer instruction with a signal instruction, which redirects a program s control .ow to the target of the original control transfer at runtime, but hides the actual control transfer from disassemblers, and 3) encrypting the body of an IF-statement, which is decrypted and executed only when IF-condition is satis.ed at runtime, but makes disassmblers interpret as data.

those previous techniques have weaknesses in terms of coverage and stealth of obfuscation.


When the execution terminates, they analyze this trace and warn about possible data races.

on-the-.y methods [5, 10, 16, 17] bu.er partial trace information in memory, analyze it, and detect data races as they occur.


Farzan and Parthasarathy s analysis does not track synchronization edges [9].

doubleChecker, which follows Velodrome [14], tracks synchronization edges but tracking synchronization edges can lead to false positives when checking con.ict serializability.


They describe a system that is capable of inferring static type quali.ers, including the ability to have polymorphic functions parameterized by type quali.ers.

their system is limited to type quali.ers that can be uniquely determined at compile time.


In order to determine the radio energy at the receiver, each ray from the transmitter must be traced.

as evidenced in Figure 1, each ray may travel di.erent distances because of re.ections.


They also suggest developing the monitor along with software.

they monitor only for those attacks that can be detected by checking simple constraints.


A workaround for this permissive const semantics is for programmers to use preprocessor macros, designed for token substitutions, rather than general and type safe language mechanisms.

for example the function mileToKm may be replaced with the macro #define MILE_TO_KM(M) ((M) * 1.609344) preprocessor macros are brittle abstraction tools, fraught with type, namespace, and scope problems.


Thereby, it is important to assess the quality of studies and ensure the reliability of study conduct (referred to as rigor).

another important dimension is practical relevance.


In this sense, professional experiments are supposed to validate portions of the hypotheses, in particular those that should be validated in industry projects.

after the analysis and interpretation of the collected data, the initial model composition technique will be improved.


They can indeed be quali.ed as ubiquitous, even if converged computing and networking technologies have still not reached the maturity envisioned by the ubiquitous computing and subsequent pervasive computing and ambient intelligence paradigms.

the current ubiquity of digital systems is technology-dependent.


Unlike static elements, states only have a single metaelement or even none at all.

this metaelement may be from either the technical or the business domain.


Also, one can .nd in [3] a typeful program representation used in implementing an interpreter in Cayenne [2], a functional programming language based on Haskell that supports a dependent type system, where the type assigned to (the implementation of) the interpreter guarantees it preserves types.

none of these techniques support, in a function programming language (not a theorem prover), typeful program representation for potentially open programs, that is, programs containing free variables.


Our aim is to predict the hotness characteristic of only these methods early.

the number of predicted hot methods (shown in column three of Table 2) may be greater than their actual number due to false positives detected during our trace-.le analysis (shown in the column labeled False Positives in Table 2).


We are studying the same kinds of runtime adaptation applied to .ne-grained software such as graphical user interfaces and web server implementations.

this kind of software is de.ned by pervasive use of behaviourally-driven structure.


Forexample,people wantto sharefamilypictures with family members only, they want to share pictures from work with work colleagues, and they want to share their wedding videos with all the guests to their wedding.

today s sharing systemsprovide access control mechanismsbased onidentities and groupsthatvaryfrom one content sharing serviceto another.


process Consumer reads the channel ch and waits until another process (Producer) writes in the channel ch.


Each of the in- vestigative techniques just described has certain advantages and disadvantages.

combining these techniques (as Singer and Lethbridge have done [73]) should produce stronger results.


Several static and dynamic techniques to identify LP tasks at large scales exist.

they largely suffer fundamental shortcomings when they are applied to HPC applications.


The throughput of 2.3 phone calls/s for the BPEL based solution is not su.cient for building a larger scale phone or conferencing solution with hundreds or thousands of simultaneous telephone calls, even taking into account a possible replication of services and more powerful servers.

the performance achievable with the used tools may already be su.cient for other application scenarios with longer session durations, like a VoD solution for example.


In the example, if the far exit becomes another exit of ¯1, then once 1¯is resumed, p2 is replaced by p1 as usual.

once computations in 0 are resumed, p0 is restored including ¯the scope weights of both subscopes.


In principle, we may even have more-than-binary interactions, with a combinatorial explosion.

in a model that strictly follows the structure of a physical system, as we have observed on the railway case study, typically only neighbour components interact, hence the size of the generated model may not explode.


In the versions before 0.9.12 of JFreeChart, setting up the range of a NumberAxis object is carried out by invoking two methods setMinimumAxisValue and setMaximumAxisValue.

from version 0.9.12, those two methods are deprecated, a new method setRange is added and should be used instead.


Depending on which condition applies, Levels attributes the correct energy consumption to the code block at runtime.

the developer should choose these conditions in a way that allows to evaluate them ef.ciently.


The stackis usually threadprivate and(due to thelimited number of registers on the x86) heavily accessed.

assuming accesses to the stacktobethreadprivate meansthatthey canbeperformeddirectly in our applications.stack accesses need tobe adjusted to accountforthe save area we create on stack.Inthe examplethis can be observedininstruction5, wherethe offsetis adjusted upwardby 16bytes.


For example, in Tracematches one can count matches of a pattern open close without a need to reset the monitor after each match as in MOP.

total trace matching is more suitable for runtime veri.cation of formal properties, because it is also the semantics adopted by conventional formal veri.cation techniques and tools.


Thus, the tool may potentially ask zero questions to complete a refactoring.

we shall disregard properties that are only mentioned once in the source code, so search-and-replace will by design always ask at least once.


Modeldriven techniques [16] and other approaches, such as the ortogonal variability model [12], suggest that traceability is a su.cient mechanism to .nd out the justi.cation of the variations by tracing the elements from or to features.

these approaches do not trace the intentions of the stakeholders, nor do they consider that assumptions made at different stages of the product line may become deprecated or invalidated.


The following interview questions were based on their narratives.

qualitative method cannot provide comprehensive and reliable answers to both research questions, especially RQ2.


Historically, Acrobat has provided a complete set of tools for annotation such as sticky notes, highlighter, markup drawing tools, stamps, and so on, which is very empowering to the user.

there were way too many entry points for certain tools such as sticky notes.


The adoption rates are getting very substantial in server and operating system area, in which two dominant OS products Apache and Linux have already set up their brand names with proven quality.

there are still many other areas that people are hesitant in picking up open source products.


They may also be used for implementing management services.

based on our experience in building an autonomic repair service in the context of such systems, we observed that the properties expected from the component model are strong, and seldom entirely satis.ed by the existing component models.


CP-Mineroperatesbyanalyzingthetype 2clonesinasoftwaresystem,andreportingcodeclonewithinconsistent identi.er re-naming as possiblebug.

with CP-Miner, the ratio of false-positive in the reported bug candidate is large; consequently, for large-scale systems, separating true bugs from false ones is a demanding task.


There are hundreds of touchscreen devices with a wide range of hardware con.gurations.

because of the minimalist industrial design of modern smartphones we conservatively assume that all interactions with a user occur through the touchscreen.


In fact, given the thorough virtualization of the processor hardware, including the MMU, instruction emulation is mostly needed for virtualising devices.

pure virtualization of device-register accesses is likely very expensive even where the architecture fully supports emulation.


Additionally, in applications that do not require real-time synchronization, several other techniques are proposed to estimate and remove clock o.set and skew o.ine in captured data sets such as a packet delay trace [16, 27].

in the Internet, each node is either a router or a host which is wired to a constant power source and has one or more stable and powerful CPU s. some other networks have only very limited resources such as scarce energy, unstable processors, and unreliable and low communication bandwidth, which we refer to as resource-constrained networks .


THE SSC -METRÔ RIO MODEL On the one hand, formal modeling requires the de.nition of a formal language, and this has been addressed by restricting the Simulink/State.ow language to a semantically unambiguous subset through modeling guidelines.

when a large requirements set is involved in formal modeling, also the architecture of the model comes to be a fundamental issue.


This is possible because the feature model identi.es the key concepts of the concern, and hence the domain-speci.c language!

the speci.cation of a list of tags by itself does not yet suf.ciently de.ne a DSL, because the list only speci.es the concrete syntax of the DSL, but not its semantics.


At present, the complexity of IVol is unknown and is left as an open question for future work.

we show that IVol can be cast as an integer linear programming (ILP) problem.


MapReduce, the moving computation to data paradigm for many pleasingly parallel applications, assumes that data are resident on local disks and computation is scheduled where the data are located.

on an HPC machine data must be staged from a broader .le system (such as Luster), to HDFS where it can be accessed; this staging can represent a substantial delay in processing.


Determining VM Type As wepointed outin Section 4, the decision on whether a particular VM is an LSVM or an NLSVM is left up to the user/administrator.

it may be possible to infer the type of a VM by dynamically monitoring its I/O and computation behavior.


The Python interpreter performs dynamic type checking for many operations on builtin types.

sometimes the interpreter forgoes these type checks as well as some null checks for performance reasons.


Thus, once a physical register is allocated at renaming for an instruction, it remains "pinned" until a subsequent instruction super- sedes it at retirement.

a register may become dead much earlier: as soon as it is superseded at renaming, and all its consumer instructions have read its value.


Therefore, we achieved shorter veri.cation times.

we had an overhead of generating a SystemC ESW model.


tiling loops is impossible at this stage.

the polyhedral phase of poly+ast chooses the pro.table loop order We evaluated the following six experimental variants for each benchmark.


Since the predicate value is obtained during reverse execution, there is no time or memory overhead encountered during forward execution of F .

in this method, if the value of any variable used in the predicate expression (the value of r4 in this case) has already been destroyed before reaching the reevaluation point, then that destroyed value must be recovered during reverse execution beforehand.


The style of all tasks can be customized.

a zoom function or automatic layout is not available.


On x86-64, this reduces the number of page faults by a factor of 512 (other platforms are similar), substantially reducing contention on the address space lock.

applications that map many small regions (.les or anonymous memory) cannot bene.t from this solution.


Some of these concerns have been alleviated by the appearance of metamodeling languages [8] representing the abstracts syntax of DSML-s, and metaprogrammable tools [25] that can be adapted easily and inexpensively to di.erent domains.

abstract syntax metamodeling -although an essential step -does not solve the problem caused by the lack of precise and explicit speci.cation of DSML semantics.


Some traditional centralized methods, such as creating Rtree for each partition [3], can be adopted in each data node.

it may increase the cost of maintenance in some cases.


return n The only visible difference to classical parser combinators is the use of ., which indicates that the de.nitions are corecursive (see Section 2).

we will see later that the parsers types contain more information than usual.


They split relations for small-step operational semantics and well-typing on a feature basis.

the .nal .xed points are constructed manually instead of having a generic representation of inductive families.


Consequently, a holds over such a state sequence, and we should have D(y = x) and D(y = x ) both valid.

this implies that x = x should hold at all states, which is false because x and x differ at all oddindexed states.


But it would be counter-intuitive for developers to move from a view to its model to specify relationships because models lack the visual layout of views.

views may not contain su.cient information for model matching because all information about model elements may not be preserved in the views.


In WaveScope [29], Flask [30], and ATaG [31], the data.ow model is essentially used to mask distribution.

our focus is to decouple data processing from storage operations, and to abstract the latter.


Schedulingfor a twoissue slotprocessor is required.

one should notice that registers are not allocatedin that stage of the compiler andhence the values are still estimates.


3.5 Zero Initialization Related to object allocation is zero initialization, which is mandated by theJVM speci.cation [18]; depending on its type,every .eld is guaranteed to be initialized to a zero value of 0, false,or null, respectively.

this zeroing has a surprisingly large impact on performance [29].


The argument for the impossibility is that one of the participants must always go .rst .

we believe that secret handshakes can be integrated into key exchange protocols to protect both the initiator and the responder against an active attacker, at least in system settings where it is practical to tolerate the following unfairness between a pair of legitimate users: Alice learns that Bob is legitimate without guaranteeing that Bob also learns Alice s legitimacy.


In other words, TBLAS  1 2 4 8 16 32 64 128 256 5121024 Number of cores programs used 25% less compute cores than ScaLAPACK.

for the per-core performance, we divide TBLAS s overall performance by 4 × NumberNodes, instead of 3 × NumberNodes.


An argument in favor of ALs is that a program can be extended at many points by using sophisticated mechanisms for pattern matching and dynamic crosscutting.

in a collaboration (in the sense of our de.nition) these are not necessary because they unnecessarily complicate the expression of a role.


On the one hand, in a system where badge movement is frequent this should be included as a property to verify.

if the ABLS system was used in a hospital situation where badges were associated with patient s beds then guarantees on the correctness of polling results would be less important.


For example, Ada Magic s output includes calls to a C function rts elab check that is used to verify that packages are elaborated in an appropriate order.

under SPARK rules the semantics of a program are not a.ected by elaboration order; the check can never fail.


There also had been client-side task evaluation attempts for an early version of iTasks using the same plug-in based interpretation technology [30].

our approach, to give one general solution for both of the problems is a novel strategy.


The abstract representation of programs in Spoofax is based on trees, where dynamic rules superimpose graph structures.


These highlight the importance of optimizing page load times.

there have been few attempts to understand how different aspects of website complexity impact the time to load web pages.


A general understanding of programming language restriction is that languages are restricted because they are too complex or because some programmers have used them to write bad code [8].

in system programming with high-level languages, restrictions exist for more principled reasons: correctness and performance.


Escape analysis and its application to stack object allocation, scalar replacement, and synchronization elimination is very effective for improving performance.

quite often it suffers from the fact that objects escape from only rarely executed code, especially from the backup path of a devirtualized method call, and thus its effectiveness with the FBC approach has been limited in practice.


Here they can use much of the code that they are given with the original program, so they tend not to get hung up in algorithmic details.

they are challenged to be sure that their design really successfully separated problem-dependant aspects of the program from the algorithmic aspects.


As the system is transactional the internal concurrency control mechanism avoids some form of cycles although it does not provide full serializability.

for all our experiments for TxGAE, there were many aborted transactions, and in some cases the abort rate of read-write transactions was up to 20%.


The type system also provides strong guarantees that all views asociated with a Piglet will be modi.ed accordingly when the underlying data structure is modi.ed.


The operations described so far do not share any data, as each invocation by process p accesses only WS[p].

init_extract and extract are slightly more complicated.


The performance of X10-enabled MapReduce on 4 nodes with a 4 MB test file.

for the parallel reduction case, the performance could be explained by the fact that it is a recursive function, which is already naturally slow.


This poses major issues, rendering traditional forensic methodologies (such as the use of write blockers) insuf.cient to preserve the digital evidence.

as we report in §4.2 we were unable to replicate their experiment, even using the same OS, scripts, drive (including .rmwares and versions) and working conditions.


Output variable domains are assessed in the same two ways.

while values for input variables can be easily specified in test matrices, output values across a specific domain are much more difficult to produce.


These two types relate closely to monolithic and assembly components in CCM.

tinyOS does not have a separation between component types and their implementation.


When the second node fails, the unresponsive nodes quickly cause more working threads to be blocked and lead to very low concurrency.

(b) Scalability: Response Time (a) Scalability: Throughput both ED only and EP+ED maintains high concurrency through 0.5 100  event-driven request processing, and thus can achieve much better 0.4 80 throughput even when two nodes become unresponsive.


Overall, we could not detect a clear pattern for one of the groups.

regarding the minor mistakes for T5, we assume that preprocessor annotations in general (i.e., independent of the discipline) have a (negative) effect on source code changes.


On the one hand, it defines XML as an output format (GML 3.2.1. already foresees four different, semantically equivalent, encodings).

this format defines aka wrapper around the other formats.


In the PCM, data .ow is more abstract and does not include information on data formats.

it might be possible to replace the current modelling language to specify the behavioural description of services, i.e.


Certainly the Racket implementation is rather more optimized than our design.

while our design requires semantic support for partial functions and rei.ed types, and syntactic support for destructuring, the remainder of our design avoids re.ection and uses straightforward, object-oriented design techniques.


The ER system does not necessarily trace the entire execution that is replayed.

the EFF system traces the entire execution that is replayed.


The type system for DEEP can prove that (.x.x)(y)= y, because the left-hand side reduces to the right, even if y is not statically known.

it cannot prove that x + y = y + x, where x and y are unknown variables; DEEP does not handle arithmetic identities.


Transfer of execution to an overloaded object method requires jumping to the result of a table lookup.

the layout and structure of these tables are well-known, allowing the trace assembly implementation to replace an entry pointing to a JIT-compiled method with the location of a corresponding trace fragment.


We have experimented with capturing forms, interviews and tuned elicitation workshops [9].

working with a best practice or associated material can also remind them of something they did or saw before.


The .rst two are, simply: do not transfer (data is only stored on the phone), and transfer immediately.

since researchers may not need real-time access to what they collect, and transmitting data over 3G connections may bear a cost on participating users, we included a means for asynchronous data transfer.


Similar modi.cations are also possible in public clouds where the cloud provider itself offers a desktop cloud service to users.

the desktop cloud service may also be implemented by a third-party that leases servers and storage from a public IAAS cloud provider (e.g., if Onlive s Desktop service were implemented on top of Amazon s EC2).


The overall best performance after the pruning optimization is always achieved by the arbitrary Boolean approach.

the conjunctive solution might temporarily lead to a better performance when reducing the predicates by the same proportion, e.g., shown in Figure 11(b).


For nearly all benchmarks, exit-dominated traces comprise between 10 and 25% of selected traces.


In addition, they define fail states that are introduced to model the notion of failure.

they do not use activity diagrams to model the relationship between plans, goals and roles played by the agent.


controlling concurrency and failures with transactions [16].

slight variations of our implementation can o.er several alternative policies and solve those limitations.


without using all the roles and specific process found in the SPLE literature.

it was pretty clear during the study that the companies employed (different degrees of) SPLE.


On one hand, programmers can apply our approach to check new developed Java programs.

our approach can help to check whether many existing Java programs have correctly implemented the composition property.


emerging to facilitate the creation, publishing, and exchange of audio browsable Web content.

adapting to voice browser technology still remains a signi.cant burden for many Web content providers.


Finally, by resorting to a dedicated 2 thread, the overlapping issue is trivially solved.

3 due to the risks of oversubscription or decreased parallelism, the thread dedication approach is usually not practical in 4 MPI [2, 19].


We have chosen Wrangler for our experiment because the process is better explained on a code base which is small enough so that the interested reader can retrace its steps, yet large enough to make the experiment quite challenging and the experiences worth writing about.

we have also done something similar on large parts of Erlang/OTP.


Like refactorings, security-oriented program transformations are structural transformations that can be automated without a deep understanding of the program.

they require parameters, and choosing good parameters does require deep understanding.


It does not take into account any input structure that may be known beforehand, e.g., if some byte strings are more likely to occur than others.

it has the advantage of being application independent.


(3) limited room for negotiation due to the fact that international cloud providers, especially American ones, use their own standard agreements they unlikely to modify, thus, customers are not able to secure their data the way they should.

cloud providers entering into an agreement with Norwegian government agencies would have to fulfill specific criteria [43].


The analysis of value co-creation in service systems with GORE methods may provide new insights for future research, such as the development of customer-centric information systems [2].

it remains a question of future research to show how much successful they can be in practice, in separate or in conjunction with other methodologies and techniques.


One might imagine that prefetching would always be successful if the user paused long enough.

links on the page are not the only way to navigate to another page.


These nodes can be coalesced with other nodes in the usual manner.


Library Linking Because of differences in the runtime model, we cannot directly link HRC compiled object .les with GHC s runtime or with GHC compiled libraries.

many programs and libraries contain C or FFI code fragments that are not representable in external Core, and that will result in link errors if not handled properly.


In a similar fashion, synchronization support in Cray T3E is provided with the help of atomic memory operations (AMOs), viz., fetch & inc, fetch & add, compare & swap and masked swap [46].

the usage of these primitives does not guarantee a sequentially consistent execution.


He can trade this for other goods on the open market at prices p. With this interpretation, Bi -yi is the amount of his own good that he chooses to keep.

notice that this is not a standard exchange economy, as the upload rate is not a true commodity; rather, the commodities are the rates of speci.c .les that are uploaded.


Of course, the downside is its impact on the workshop agenda, as the use of experts and time to produce essential deliverables might be lost.

we believe that dogmatic adherence to the agenda can inhibit creative thinking, so facilitators need to be able to redesign creativity activities in real time.


There are same stemming algorithms for Farsi language.

in this paper, Kazem Taghva s algorithm is used as the basis and it was changed to improve the performance of the algorithm.


To address this problem, a range of research efforts have focused on techniques for capturing external and non-deterministic inputs, thereby allowing post-mortem deterministic replay [13, 20, 28, 33, 40, 44, 49, 50, 52, 55].

these approaches have been slow to gain traction in the commercial world for several reasons, including high overhead, environmental complexity (e.g., interactions between multiple licensed software and hardware from different vendors), and substantive privacy concerns.


They did not regard web pages as interactive but felt that search facilities provided interaction and that therefore this could be classed as e-learning.

they were then confused as to whether if one read a news item on a web page and learnt from that whether that could be classed as e-learning.


Simultaneous slices can also be computed using the PDG- based approach [33] and using the iterative solution of data flow equations [47], because the slice with respect to criteria {C1,... , Ck} is simply the distributed union of the slices constructed for the individual slicing criteria C1,... , Ck.

using Espresso-produced slicers, the simultaneous slice can be produced at no extra com- putational cost.


The presentation programs can produce WWW presentable on-line documents, either via common doc- ument formats (such as postscript or pdf), via vendor supplied 'browser plug ins', or as bitmapped graphics.

none of these secondary .formats provides for a smooth integration with the rest of the resources on the Internet (for instance the course plan pages discussed above) nor full utilization of the power of hypertext.


Our observation is that the setting of values to parameters does not mean the value is not subject to change.

numerous informal comments suggest some alternative values ( you can set this lower if your printer can handle tiny towers ).


The inference required for polymorphic ownership requires many more ownership variables and constraints than a monomorphic ownership system [21].

the ownership constraints collected have the same form as those collected in a monomorphic type system.


In this approach, M3 contains meta-languages for structure, presentation and behaviour, M2 contains complete de.nitions of all aspects of a language, and M1 contains a complete description of the diagram or language instance.

we suggest to use a relative numbering scheme instead of M1-M3 to emphasise that the absolute location of a model is not important, but rather the connection to the levels directly above (meta-model of the model) and below (the instances of the model).


Several solutions, including one leveraging cloud elasticity to support auto scaling, have been proposed [12].

most of these systems [32, 36], only consider data variability as a factor for auto scaling decisions and assume that the underlying infrastructure o.ers same performance overtime.


We found that more precise points-to information did indeed result in less propagated data-.ow information during slice computation, as expected.


As AutoSoft develops safety-critical software it is important to ensure that sufficient documentation is in place so that components may be traced throughout development and therefore plan-driven practices are required.

as the company desires to increase its productivity, reduce the length of its software development lifecycle and become more competitive, AHAA suggests adopting a more hybrid approach.


When an event occurs, its event handler is executed and the event is activated.

some tasks posted directly or indirectly from the event handler would execute after the event handler exits.


expression, then we must push stack frames to hold the pending state needed when these return points are resumed.

we can still shrink-wrap the stack prior to allocating these return frames, if some of the calling context s return points are also going dead at this call.


It is often di.cult to integrate such frameworks into an existing software development environment, especially if the test framework is meant to support only a certain environment.

the integrability of a test framework is important.


Aspect-oriented systems have been proposed for this purpose, notably to manipulate service orchestrations modularly, for example, using AO4BPEL [6] and in particular for the control of the QoS properties of orchestrations [2].

no aspect system exists that enables the modi.cation of session types while maintaining their strong correctness guarantees.


An advantage of internal DSLs is this feature, composability.

internal DSLs have drawbacks in the syntax the syntax of internal DSLs is restricted by their host language.


4kBlocal memoryfreeperformance Deferredcoalescing signi.cantly reduces the overhead of small region allocationinSMA.Most traces show20-60%improvement when using either the CAM or LM schemes.

the improvement is slightlybetterfortheCAM scheme asit candefer coalescing of any memory region size, while theLM scheme can onlydefer coalescingforsub-block sized regions.thedifferencewasmore marginal than we expected, suggesting that typical applications request such a wide variation of sizes that the most bene.t is seen over the small subset of sizes which are guaranteed to be reused.


Both static and dynamic slices rooted from the failure site (line 13) contain the culprit (line 5).


Nowadays, contexts are commonly used in systems to manage thread-bare spatio-temporal characteristics such as user location and date/time of system interaction.

vOIP and multimedia-based web transactions can carry a variety of user attributes which can enrich user context.


Such tracebased pro.ling can potentially be used for data dependence checking.

their algorithms are speci.cally for compressing memory streams.


This may be unsettling because it seems to place too many restrictions on Gi.

it is only unsettling because we are not used to encountering polymorphic environments.


In the future it might be worth to validate the performance of FTF algorithm in experiments with software projects of different sizes or from different domains than those used here.

since we know that the choice of the base learner may have dramatic effects on the behavior of FTF algorithm experimenting with different base algorithms seems a good research direction too.


The root feature Navigation is present in all variants, similar to all mandatory child features (Graph, Wgt, and Gtp), which must be included in a variant i. the parent (i.e., feature Navigation) is included.

feature Connected is an optional feature that can be included if the parent is included.


Our results provide further illustration of the promise of normal form bisimulation as a basis for syntactic theories and proof principles, demonstrated by earlier results for other pure and extended .-calculi in the literature (Sangiorgi [31] and Lassen [18, 20, 21]).

we note one caveat: Although our theory for the combined .µ.-calculus captures key functional and imperative aspects of the programming language Scheme, it lacks constants such as nil, cons, numerals, and arithmetic operators.


However, the synchronous model lacks .exibility, because the system can be blocked during execution.

asynchronous RPC model provides high .exibility and concurrencyand is widely adopted in client-sever systems designs [11].


Our treatment of the labeled bottom type .lGp deserves some explanation.We initially tried to label bottom types witha single label, as in .l.

that approachfails to capture the correct blame tracking behavior.


The expected results (specific practices) specify what must be obtained with theeffective process implementation.

models for software process improvement like MR-MPSjust define "what" should be implemented and not how it should be implemented.


Heterogeneous analysis tools support more than one speci.cation language for modeling a system and properties to be checked against the system.

homogeneous analysis tools use the same language to model both the system and properties.


This has the advantage of centralizing all student code and requires a simpler autograder that copies code from each student s directory, builds their code and evaluates their submissions.

the use case is much more complex when we move to a massively parallel environment such as XSEDE, with a course that currently scales to hundreds of students and that we would like to extend to MOOC scale (thousands of students).


SOABench[3] and PUPPET[2],forinstance, supportthe creation of mock-up services in order to test work.ows.

these prototypes are restricted to emulating non-functional properties (QoS) and cannot be enhanced with programmable behavior.


The two repairs minimizing the Hamming distance between original and repaired configurations are: Select 250kbits/s CAN bus ; Deselect 1 Mbits/s CAN bus  Select ABS Controller ; Deselect Non-ABS Controller  This simple example was adapted from [19].

the user may find that one of the possible repairs (such downgrading to a non-ABS controller) is not really desirable.


Chemical metaphors have been proposed to facilitate dynamic service composition in pervasive and distributed computing systems [24], and they appear to well tolerate diversity and evolution (because they can accommodate a large number of di.erent components with the same simple set of laws).

a metaphor strictly adhering to the idea of a single chemical solution would hardly address the aspects of spatial distribution that characterize large-scale pervasive systems, unless properly coupled with some bio-inspired aspects, as we have recently proposed in [24].


[25] assess the e.ect of noise through detailed simulation of its (per site) components.

this section analytically shows that if the single-node probability for delay is small enough, the e.ect of size is linear: it simply multiplies the single-node probability.


There are many ways this could be implemented, ranging from a BitTorrent-style network [10], where data is centrally tracked and all participants share relatively equal loads, to KaZaa-like super-peer networks, where select nodes are assigned greater responsibility in the network.

applying a traditional P2P network infrastructure to scienti.c computing, and in particular volunteer computing, can be highly problematic.


M axB if OP(x, y) over.ows M inB if OP(x, y) under.ows (1) OP(x, y) otherwise urating operations.

standard high-level languages, such as ANSI C, provide no direct support for saturating arithmetic.


This system generates street maps through L-systems which were extended to handle many different requirements and creates building geometry on the subsequently generated allotments.

using strictly a rule-based approach makes it difficult to create new rules into the production pool to let the road creation mechanism generate realistically looking road networks.


N-MASS performs approximately the same as maximum-local in most of the cases.

when the memory allocation in the system is unbalanced (allocation map 0000 for both workloads, allocation maps 0001, 0010, and 1100 for WL1), the additional cache-balancing of the N-MASS scheme improves performance relative to maximumlocal.


Broadly speaking, CDP can be implemented in two different ways, i.e., either integrate it seamlessly to the target .le systems or more generally make it sit at the device block level.

the stateof-the-art CDP implementations suffer from various limitations, e.g., huge implementation complexity, non-trivial performance interference.Inthisstudy,we introduce BVSSD,a new block level versioning system speci.cally designed for the emerging .ash-based SSD.


2Nested classes (see Section 3.2) have access to private members of their enclosing classes.

a nested class is always de.ned within the same source .le as its enclosing class, so both classes are always compiled together.


For workloads with frequent memory allocations and deallocations (first category), shadow paging provides poor performance dueto frequent updatesto guest pagetables [53].

vMM Direct allows page table updates to proceed without any VMM intervention.


In general, an enterprise wants to design a cluster system that is optimized for multiple performance metrics including high throughput, fairness, and low response time for interactive jobs.

optimization on one metric often conflicts with the others.


Reducing energy needs and the carbon footprint by approximately a factor of two is certainly a significant achievement energy is one of the major costs in running a data center, and any less CO2 emitted into the environment is for the better.

our field is in many ways used to orders-of-magnitude and exponential increases in performance and utility, e.g., Moore s Law, Metcalfe s Law, and the concomitant increase in link transmission capacity (e.g., from 10 Mbps to 10 Gbps Ethernets in a short period of time).


Error detection at the architectural level relies on monitoring mechanisms, or probes, for detecting erroneous states at the interfaces of architectural elements or in the interactions between these elements.


Furthermore, it also appears that as the workload becomes heavier, the maximum GC pause remains the same for HA.

fR and default experience longer pauses as the workload increases.


there is no need to manually specify such rules.


In this study, we observed that a developer who uses the OOG may modify fewer classes.

we do not claim that using OOGs for code modi.cation limits the length of change propagation, since modi.ability seems to be a quality attribute of the software itself.


Traditional optimization algorithms like gradient descent have been applied to solve this problem [11], but, the most efficient techniques are based on genetic algorithms that have been successfully applied in several works [13, 16].

these works focus on generating one test case for each test objective but cannot be applied to generate a global test suite.


Depending on the order of the observers in the chain, an exception thrown by one observer may be caught by another observer or propagated down the chain.

the observers, their orders in the chain, and the behaviors and .ows of their exceptions are not known to the subject.


When g11 is split, a12 is in the future and g12 appears in the past.

split(1, 2, 0.0, g11) = ((1.0 g12), (0.0 a12)) Extract(1.0 g12) = (1.0 g12) a13 which is bounded to g12, must be launched after e2 (see Figure 4).


While our presentation is in parts visionary and not yet realized in a real world scenario, we believe that these ideas are feasible since they are based on the integration of existing approaches.

one of our main intentions is to spark discussion towards the consideration of user input as a .rst order concern in development processes and application architectures.


I assume that all schedules guarantee that any action about to be executed is always enabled.

execution of an action can still fail if the function Algorithm does not terminate; in this case, the algorithm is not executable in this schedule.


The subroutine MC GATHER works in essentially the same way.

the size of the array gathered from each communicator depends on the size of the communicator.


In grid computing, Markov chains have been used to model workload for scheduling (Song, Ernemann, and Yahyapour 2004) and load balancing (Akioka and Muraoka 2003).

unlike these efforts or those that quantitatively estimate performance or reliability, this work uses Markov chain modelling to understand alternative system behaviours that may occur as a consequence of significant system-wide events or decisions: in this case, the failure to meet fundamental service guarantees for grid systems.


A single node deployment of the monitoring service may easily handle the monitoring data from a cluster containing a few tens to a few hundred nodes.

if the cluster grows to a thousand machines or more, the amount of monitoring data that is generated by the clients will overwhelm the single node monitoring service.


(3) Tracking the tweets involved in conversations is relatively easy through searching on both replies and hash tagged-topics.

the resulting linear list of contributions is sometimes difficult to interpret due to the immediacy, sheer number, and lack of thread structure.


For most benchmarks, the overheads are effectively unchanged.

for two speci.c benchmarks, SPEC INT s libquantum and SPEC FP s namd, is there a very noticeable difference of roughly 10% (not shown in table).


Tothisend,FERRARIreliesoncodeduplication within method bodies, similar to the approach presented in Section3.

asFERRARIlacks supportfor merging multiple independent bytecode instrumentations, none of the case studies presentedinthispaper canbeimplementedwithFERRARI.


For instance, architectural support can be used for major upgrades of the system, whereas continuous integration is used when smaller changes within the same architecture take place.

since designing the architecture with collaboration explicitly in mind and setting up the version control system both require explicit effort, we believe that for many smallscale experiments these are considered too extensive means, and little facilities for cooperation which could be later required in the form of e.g.


The within-subjects comparison of varied-performing students shows that the amount of time a student spent (in hours) on his or her well-performing assignments (M=27.31, sd=43.22) was slightly less than (F(1,1)=7.51, p<0.01) the time spent by the same individual on poor-performing assignments (M=30.66, sd=41.61).

students who consistently achieved A/B scores (M=37.82, sd=48.71) spent nearly twice as much time (p<0.001) as students who consistently achieved C/D/F scores (M=21.92, sd=34.94).


MCX and MC-GPU exhibit a very low degree of coalescing to begin with, due to the nature of Monte Carlo simulation.

gPU-MCML exhibits a very high degree of coalescing because most of the uncoalesced accesses have been eliminated through buffering in shared memory.


An interesting alternative would be the use of non linear integer programming,however scalability problems would still arise.

integer programming is often faster than GAs.


C/D coverages correlate moderately, likely a consequence of abstractions in the model.

both exhibit a positive correlation with error detection.


Then every time the function is called, the stack state will be written back to the global memory, and reloaded on return.

this can be avoided by carefully placing the scratchpad functions sstore, and sload in the program.


In contrast, the annotative implementation of undo  dim Undo(one, many) in refines Buffer { Undo(int back = 0,Stack stack = new Stack()); void set(int x) { Undo(back = buff, stack.push(buff)); Super(int).set(x); } void undo() { buff = Undo(back,stack.pop()); } } Figure 5: Undo re.nement u with annotative variation.

in Figure 3 requires direct modi.cation of the base program and clutters its de.nition with code that is only sometimes relevant.3 the compositional undo features contain redundancy not found in the annotative representation, complicating their maintenance.


DESIGN IMPLICATIONS & FUTURE WORK The observations and subsequent interviews showed that the Knight tool is a valuable tool for modeling in practice.

as the above results point out, improvements are needed.


Native interfaces are shown as an O, library interfaces are shown as X Figure 1 indicates that interfaces might be categorized into three broad categories -Few Implementations and Many Dependents (usually native interfaces in developer-defined source-code), Many Implementations and Few Dependents (usually imported library/framework interfaces), Some Implementations and Some Dependents.

simply identifying these outliers does not help to explain why they are present, if these interfaces are suitable for the design they form part of, or if/when these sorts of interfaces are generally desirable.


Therefore it is generally not possible to move objects during reference counting.

rC Immix seizes upon two important opportunities to copy objects and thus mitigate fragmentation.


This is a result of the larger in-The Alltoall operation is interesting because the size of the terrupt overhead in the virtualized environment.

note that messages exchanged between nodes increases with node count.


In terms of a concrete syntax for expressing MOF AS, OCL can express read-only operations on models and can therefore not be used as-is in the context of AS.

it provides precise mechanisms for querying and navigation, which cannot be discarded.


o t h e r C o n c e r n ( O b j e c t ) ) && a r g s ( o ) && c o n t e x t ( ) { o t h e r C o n c e r n ( o ) ; }} The mechanisms used in this solution are similar to the ones used in the aspect IncludeStrategy.