The MVC pattern advocates separation of concerns between three entities: models capturing app data, views describing the visual appearance and the controller which handles transformations between models and views along with navigation control.

to encourage rapid adoption, it is more pragmatic to augment existing popular frameworks with new abstractions, e.g., by creating framework-specific plugins/libaries, instead of creating a new ecosystem from scratch.


Not surprisingly, most modern web programming frameworks spawned over the last decade, e.g., Ruby on Rails, Django, Symphony, ASP.NET, Backbone.js, enforce some form of MVC-based design.

our survey shows that these frameworks lack suitable programming abstractions which enable MVC-based design end-to-end.


We consider a scenario in which development is underway for the release rn, which started with source code from the release rn-1.

the commits submitted after the release rn-1 are for the release rn.


In general components follow the idea of information hiding.

this is not true for the generic model components discussed in this paper.


Each point in P can be written as a convex combination of the points in vert(P ).


The reachability problem for BMS and MMS is fixed parameter tractable, where the parameter is the number of variables.

it is polynomial for BMS and MMS with fixed dimension d.


Recent work addressing the stability analysis of controllers at code level has been mainly focused on the controller alone.

most of the properties of interest of control software lie in how they interact with their environment.


De-duplication technique is employed to save only one copy of the identical pages across multiple VM snapshots [21, 22, 42].

these works pay no attention to the availability of snapshot files, or in other words, they expect the underlying file system or storage device to provide the availability.


HDFS stripes a file into disperse disks, so it is difficult to quantify the loss of file for real disk failures.

we randomly select pages and mark them as lost when reading them from HDFS.


Removing page cache from memory state is one compelling approach to reduce snapshot size effectively, and has been well studied [14, 17, 37, 43, 44].

these works still suffer from several drawbacks.


For example, any network packets received at server also get recorded as non-deterministic events in the record log and are streamed to the client (so that it can reconstruct server’s state).

the user is provided the illusion of controlling the server and viewing its console remotely (even though the console is actually that of the client’s replayed VM).


This is because LXC's cgroup freezer [24] mechanism begins consuming more time for un freezing a VM, and hence does not scale.

the number of frozen VMs is limited by this increased transition time, to approximately 300.


Thus, we believe that within this operating range (up to 250 booted, 300 frozen VMs) all transition times remain largely constant, regardless of the number of booted and frozen VMs.

we represent the average transition times (within the operating range) as the transition matrix T3×3 (shown in Table 2, where ti, j=time to transition from state Si to Sj).


As mentioned earlier, each world also maintains a version number, which increments monotonously with every modification that happens at the world.

when the state changes from SQ to SQI, the version number would increment by 1.


The second consequence was that team members who had not been able to attend Kidsteam sessions in-person were now able to do so in the virtual environment.

one team member's mother had an unexpected change of work schedule and he was unable to attend KidsteamUB sessions.


widespread use of social networks has lead to an environment where huge amounts of data are created on high and unpredictable rates.

the volume of data, needed to be processed, demands a distributed approach.


Two-stroke engines also exist and are sometimes used in aircraft and marine engines, as well as some trucks and motorcycles, due to a more compact size, a lighter weight, and greater efficiency.

due to exhaust pollution, twostroke engines are losing out to, and being replaced by, fourstroke engines in many applications, especially in modern cars (which is our focus).


Since the player fires slower weapons sooner than faster weapons, effectively “leading” the Saucer more, by the time the faster weapon is fired, the outgoing queue has cleared.

when the second weapon is fired, there is no queue, so no opportunity for optimization.


On the other hand, post-mortem methods have a number of disadvantages.

they are unsound, given that they may not point out every implicit communication link in a distributed system.


Note that the higher the number of  potential vulnerabilities flagged by static analysis, the higher the overhead incurred at runtime.

for efficiency, it is crucial that static analysis flag as few false-positives as possible.


As depicted, the heap overhead depends on the applications.

the global overhead introduced is not a blocker issue as it is relatively small in comparison of the total heap size.


In the case example, the browser session parameters have been abstracted to qualitative levels in order to enable less experienced customers to select a variant.

there is also the possibility to set custom session protection by setting individual session parameters under CustomBrowserSessionValidation.


Compared to the current state in Magento, the conceptualization was used to record implementation constraints from features and countermeasures to the architectural entities.

all inconsistencies between the selections could be checked; this aspect is currently lacking in Magento.


On one hand, security requirements, including high-level security goals and system level specifications, need to be realized in the design.

security requirement definition relies on having the design in place: without information about the intended solutions, the threat analysis cannot fully identify possible targets of an attack [9].


Security variability in SPLs is addressed in a few studies that mostly focus on requirements [21] and goal models [13].

variability must be managed also in the design: security solutions, such as authentication, authorization and input validation, tend to crosscut both structures and views in the architecture [31, 22].


Thirdly, the configurator treats requirements R as the set of rules that a specific product instance must satisfy, stated as KumbangSec instances that must be present in the configuration, or as attribute values that these instances have.


KumbangSec artifact assumes that security variability is implemented as a number of purposefully introduced design tactics.

a security variant consists of a number of countermeasures, which are implemented as design-level tactics in the product line architecture.


Existing big data processing frameworks such as Hadoop and Spark require jobs to be submitted as a binary jars/libs rather than runtime functional calls.

the resulting data after applying a Transformer can be used for machine learning using a Learner or it can represent the extracted knowledge discovered from the original data.


Data-intensive mobile apps often rely on data located in the cloud.

access to this data is likely over a lower-bandwidth and multi-hop connection, compared to the higher-bandwidth, single-hop connection that exists between a mobile device and a surrogate.


This is because the Offload Server becomes a bottleneck as all communication between mobile devices and the surrogate would go through this component.

some systems that implement Fault Tolerance tactics (Section 4.2) place the responsibility of detecting and managing disconnections in the Offload Client and Offload Server which therefore benefits from the single point of communication of the latter alternative.


However, if used at all, these techniques use the software architecture only in a very coarse-grained manner.

it is hard to make accurate predictions using task-based approaches.


With the supply side of the equation shifted (Figure 2), it would be reasonable to assume that we would already be seeing greater use of data to avail the above benefits in many if not most development projects.

6 In Bangladesh, mPower has supported several projects where the above principles have been applied, through negotiations with donors.


They also provided leverage for creating and maintaining strong ties with classmates, by providing a capability they could share in exchange for sighted assistance.

their unequal access to resources in the classroom also created dilemmas for their relationships with peers, fostering resentment among students without access to these amplifying devices.


Loop i is a parallel loop and therefore we can redistribute the stores among the threads to ensure coalesced access.

we can use the i loop in the thread code as an additional source of parallel threads, and compute a new 2D geometry in place of the original 1D one, such that accesses will be coalesced for tx: in this example this amounts to (1) making i the tx dimension, updating bx correspondingly to capture N threads; and (2) make the original tx dimension ty in the transformed code.


Both threads use the same shared lock fil system->mutex to coordinate the shared access to fil->system->unflushed->spaces.

in the dynamic execution, the thread always does not update it, if the buffer is explicitly disabled by the user (i.e., fil buffering disabled(space)=TRUE).


For other events, the recording strategy of PE R F PL AY is quite flexible, ranging from complete recording to selective recording.

pE R F PL AY chooses selective recording whenever appropriate.


Therefore, a performance debugging tool is needed to assist the programmer in addressing the problem of ULCPs in their code.

we propose PE R F PL AY, a replay framework to help programmers understand ULCPs in two aspects.


Pointer analysis in general is difficult for compilers, limiting optimization possibilities.

in terms of CFG construction, function pointer analysis has distinct advantages over conventional pointer analysis.


Our observation is that, in general, it is difficult to predict the impact of corunning applications until run-time, as the co-runner applications in the workload may not be known ahead of time.

compiler-based tile size selection approach could not have accurate prediction on the runtime application behavior.


More specifically, our reactive tiling tries to determine the ideal tile size (from among a fixed set of tile sizes) under an OS/hardware-given cache allocation and the tile size selected by the application may affect the OS/hardwarebased partitioning decision in the next epoch.

the cache partitioning decision in the next epoch is a function (among other things) the tile size selected by the reactive application.


Existing cache-oriented compiler optimizations such as tiling are largely agnostic to such cache partitioners.

they are not aware of the existence of such partitioners and therefore cannot adapt to it dynamically.


Much higher energy and power savings are seen (up to 22% and 41% respectively) in some cases.

the savings for some of the benchmarks are limited by the current implementation of the optimization, rather than the technique itself.


The last writer slice at C for log type shows that it was written last by Thread 1 at A, in the log rotation code, which should be atomic.

the last writer slice shows the programmer the need for log rotation to be atomic with respect to the insert code to prevent this failure.


When the failure occurs, Thread 1 is at the assertion in append().

thread 2 may have completed its erase and moved on to some unrelated code.


Our approach is based on observing this IR-to-assembly translation, and testing if the two are semantically equivalent.

for each IR-to-assembly translation used by the compiler, ArC heck tests if the IR and assembly instructions have the same behavior.


For each IR operator, we also specify constraints relating its input and output, and propagate these constraints on the output of an operator to its inputs.

we use these constraints to generate inputs that will yield the desired output.


Our approach, called ArCheck (Architecture Specification Checking), leverages the structure of a modern compiler to achieve architecture independence.

today’s compilers consist of front-ends, typically one per sourcelanguage, that translate source-code to a common intermediate representation (IR).


Previous section discussed some basic ideas on what to save and where to save for the snapshot.

web platforms allow multiple apps to run on a single JavaScript engine.


Due to the halting problem, we cannot statically prove that all bad functions will eventually be lowered.

the presented lowering algorithm always reduces non-recursive calls of bad functions.


All instances of Line 0 run in parallel on three cores.

core 1 happens to take longer initializing its private memory, delaying execution not only in Core 1 but also in Core 2.


For example, on x86 hosts, the constant-like nodes could be commonly optimized by the instructions with 32-bit immediate, while on MIPS hosts that do not support 32-bit immediate, constant-like nodes can only be optimized by converting to move-like and add-like node.

when migrating HE R M E S to different hosts, distinct host-specific features should be considered to revise the instruction templates (or optimization rules) to improve the potential performance gain.


According to the published results [1], the translation throughput of Peephole is at most 200 instructions per second.

the average translation throughput of HE R M E S is about 37K instructions per second, which significantly outperforms Peephole.


For a function call, the related return instruction is emulated as a conventional indirect branch, which requires expensive guest-to-host address translation.

in spite of different guests, a call emulation is characterized by a constant-like node that generates the Guest Return Address (GRA), and the TRA should be recorded once the GRA is generated.


Of course, the feature can be added to new machines which are not yet delivered.

there should be a way to add new features to the machine, even when the machine is already delivered to the customer.


The manufacturer of the machine cannot offer fully customized products as modifying the components for each customer would be too laborious and would result in extensive software versioning.

the manufactured machine batches are too small to gain the benefits of the efficiency of the mass-production.


This is quite natural as implementation of some of the functionalities such as boom kinematics requires special expertise.

it is advisable that a malfunction of a single feature do not disable the whole system, only the malfunctioning features should be disabled.


However, if there is no trace of the original roles within the pattern definition, it is possible to modify the elements of copied solution in an arbitrary way after the pattern has been applied.

the properties of the solution, for instance with respect to safety, might not be valid within the system although a pattern guaranteeing these has been used.


In the used UML modeler, the targets of the role binding are only shown by their name.

we added stereotyped dependencies to the elements of the pattern solution (in the right hand side of the figure 6) for illustration purposes we did that for the two software components only, the other elements are bound as well in the model.


The constraints defined within a pattern use the binding information to validate the bound application model elements.

it must be possible to filter available patterns with respect to this classification.


As a consequence of following the MACRO-MICROFLOW pattern, the overall architecture design activity is driven by a businessprocess-centric approach.

all design constructs are related to business processes, which need to be modeled and implemented.


That is, today pattern mining is a rather informal or ad hoc process of finding patterns in software systems.

often the pattern author identifies one or more patterns in his own experiences, and then broadens the scope by searching for the identified patterns in related systems and/or looking for related other patterns in the systems under consideration.


Patterns thus represent a conceptualization of problem solving behavior achieved by abstracting from implementations and the explicit decisions software designers have made in software development projects when dealing with many influential forces that constitute complex problems.

software patterns to be newly discovered are successful mental design constructs, which have not yet been discovered as such, but are rather represented as unexplored and unconscious knowledge of expert software designers that is hidden in the software implementations.


Pattern mining is a term used in the pattern community to describe the process of identifying or discovering patterns in existing software systems.

as patterns describe established knowledge rather than original solutions, each software pattern is associated with a number of known uses where the pattern is used in an existing software system (Coplien, 1996).


They represent successful problem solving behavior, which corresponds to the concept that a pattern describes how to and why to solve a problem rather than concretely dealing with what to solve.

they deal with people s behavior to solve complex design problems, and they describe how and why conflicting forces arise and how and why these forces are resolved by a (human) software designer.


The service model and, eventually, the business capability model may be refined and updated.

sophisticated (enterprise architecture) tool-support is required for administrating and updating the models and their dependencies.


For example, the well-known GoF factory patterns allow to specify a concrete (application) class to be instantiated by the injection of a factory object at runtime.

the algorithm that determines when an instantiation will take place, can be fixed by coding a (framework) routine long before the concrete class is decided at runtime (see Fig. 1).


It is often hard to decide whether something is a tactic or a pattern, because there is no precise definition for tactics.

in this work we simply take a given set of safety tactics from [Preschern et al., 2013] (where a more detailed explanation about safety tactics can be found) and consider every architecture which uses several of these tactics as architectural safety patterns.


In our framework, we have to deal with components realized in the C language and an application constructed following the component-based paradigm [Crnkovic 2002].

just experimental but no mature C++ IoC containers are currently present.


However, debugging deployed WSNs is challenging for several reasons - the remote location of deployed sensor nodes, the non-determinism of execution that can make it dicult to replicate a buggy run, and the limited hardware resources available on a node.

existing solutions to record and replay debugging in WSNs fail to capture the complete code execution, thus negating the possibility of a faithful replay and causing a large class of bugs to go unnoticed.


The composition of the request-processor chain reflects the specific responsibilities of a replica and therefore differs between primary and backups.

the primary participates as proposer in the protocol responsible for the reliable distribution of state transactions [35], while backups act as learners.


Although close-to-open semantics do not require Hare to ensure data consistency in the face of concurrent file operations, Hare must ensure its own data structures are not corrupted when multiple cores manipulate the same file.

if one core is writing to a file and another core truncates that file, reusing the file’s buffer cache blocks can lead to data corruption in an unrelated file, because the client library on the first core is still writing to these buffer cache blocks.


Hare's insight is that exec provides a narrow point at which it is easy to migrate a process to another core.

the entire state of the process at the time it invokes exec is summarized by the arguments to exec and the calling process's open file descriptors.


When the file descriptor is not shared between processes ("local" state), the client library maintains the file descriptor offset, and can perform read and write operations without contacting the file server.

if multiple processes share a file descriptor ("shared" state), the offset is migrated to the file server, and all read() and write() operations go through the server, to ensure consistency.


A task that exceeds its memory limit will be the first to be preempted if resources are needed, regardless of its priority, so it is rare for tasks to exceed their memory limit.

cPU can readily be throttled, so short-term spikes can push usage above reservation fairly harmlessly.


The Omega architecture was designed to support multiple distinct workloads that have their own application-specific RPC interface, state machines, and scheduling policies (e.g., long-running servers, batch jobs from various frameworks, infrastructure services like cluster storage systems, virtual machines from the Google Cloud Platform).

borg offers a "one size fits all" RPC interface, state machine semantics, and scheduler policy, which have grown in size and complexity over time as a result of needing to support many disparate workloads, and scalability has not yet been a problem (§3.4).


In this paper, we propose a fine-grained monitoring middleware providing real-time and accurate power estimation of software processes running at any level of virtualization in a system.

our solution automatically learns an application-agnostic power model, which can be used to estimate the power consumption of applications.


Tango targets a heterogeneous environment in which different replicas have different strengths and weaknesses.

it is often beneficial to switch the role of leader as the application enters different phases of execution, and Tango is designed to identify such opportunities and switch appropriately.


The differences in Figures 1 and 2 illustrate that when the server is the leader, it can externalize the UI state on behalf of the client.

when the client is the leader, only the client will generate UI output.


Time Warp [24] improved distributed simulation performance by speculatively executing computation on distributed nodes.

table 1 shows the server's processing time.


Sony, Nvidia, Amazon and OnLive are among the providers that currently offer cloud gaming services [1 3, 10].

cloud gaming faces a key technical dilemma: how can players attain real-time interactivity in the face of wide-area latency?


Somewhat surprisingly, having test players different from training players only marginally impacts prediction performance as long as test and train players are of similar skill level.

we chose to use a single model per coarse-grained skill level (novice or experienced) which is agnostic of the player.


On the other hand, this approach identified 684 new ad module occurrences (7.07% of all 9,676 occurrences), of which only 55 (0.8%) have requested new permissions, compared to ad libraries identified using the non-call-graph method.

in general, this approach increases cost significantly while providing diminishing returns.


A model derived by WI can be used to generate artificial workloads that are close to the actual workload but may have random mutations/omissions.

we can now define the high-level problem solved by WI: Given an input sequence T that we will treat as training data, we wish to compute k and a Markov model Mθ(k) ∈ Mk such that Mθ(k) is a “good” abstraction for the process that generated T.


The vast majority of slow SSD reads happen while the SSD is in the process of servicing segment write requests.

we try to avoid writing to more than two SSDs per ECC group at the same time, and treat SSDs that are in the process of writing data as though they have failed.


The key idea of both techniques is to skip some input data (time-adaptive algorithms) or expensive computations (approximate computing) so as to produce approximate results within the required processing time.

our framework performs full computation over the synopsis (statistical aggregation) of entire input data.


In all cases, schedules with proposed rules perform better than the baseline.

1024 byte value size, rule 1 performs 41%, rule 2 performs 1% and rule 1+2 performs 44% better.


We are not satisfied with this rough classification and apply a text mining approach to quantify the promoted benefits on a more detailed level.

we start to count each occurring pair and triple of words in the collected benefit items.


When it comes to the working conditions of software engineers, employers are confronted with the universal mix of extrovert/introvert and sensitive/intuitive people who decide extremely analytical where to be hired.

recruiters run into a challenge of compensations and benefits as well as in the public reputation of a valuable corporate culture.


We also compare our results with those of Oracle Solaris Studio 12.3 compiler [15], the only compiler to the best of our knowledge that implements some OpenMP correctness checking as well.

since Sun Studio only supports OpenMP 3.1 it cannot handle issues related to tasks dependences.


The variable construct defines 3 Genesis variables sampled from my_vars.

every time the feature computation is processed, the variables dest, src1 and src2 are sampled to select 3 variables from my_vars1 to my_vars5, which are substituted into the code snippet.


automate the generation of vectorized and multithreaded linear transform libraries, providing users with optimized code for this domain of applications.

genesis offers the flexibility to express programs in any domain, but does not optimize them, although optimizations can be manually expressed with Genesis constructs.


Database systems use the journaling techniques in order to guarantee database consistency even at system crashes.

such duplicated write operations shorten the lifetimes of NAND flash storage devices.


Most of the research found checks for consistency only a given state of SPL.

we believe it should be interesting to have more initiatives on accelerating the discovery of inconsistencies.


Objective: In this paper we present our findings from a case study to give a deeper understanding of the challenges and problems of user involvement during software development.

therefore it is not necessary that the users who are involved in the project should also participate and perform activities.


From the SME's perspective, there was a feeling that expectation of the degree and level of her involvement was not clearly articulated at the outset.

the responsibilities of the ECC manager (who was conducting all the requirements elicitation and design workshops) were not clarified.


The very small difference in the control groups is surprising to us because we have assumed that the quantity of correct retrieved elements is significantly lower in the larger system compared to the quantity of correctly retrieved elements in the rather small system.

the participants of the control groups from the both experiments performed rather poorly.


The results pointed out in Section 5 show that the null hypothesis Ho1 can be rejected.

the first experiment took place with 51 students of the software architecture course; the second experiment was conducted with another 56 students of the same course.


Furthermore, since the respective variant should be grounded in the reference model instead of the V-Modell XT Bund, required variability operations had to be defined in a new metamodel variant.

the development approach of the V-Modell XT Bund was replicated by another team in another context.


An exception is the operation type ReplaceTaskDescription : The original operation (defined in the metamodel MM 1.4B ) remains unused, but the copied operation (defined in the metamodel MM 1.4Bw ) was used.

the original operation remains in the set of unused operations, even though an exemplar is present in the analyzed process variants.


The GRADE system initially categorizes evidence concerning study design by assigning randomized experiments a high grade and observational studies a low grade.

by considering the quality, consistency, and directness of the studies in the evidence base, the initial overall grade could be increased or decreased.


When it comes to the papers which refer checklists from the guidelines, we found many papers developed their quality assessment checklists based on previously developed and used quality assessment checklists that can also serve as some sort of guidelines.

compared to SLRs, it was not expected that many SMSes would have performed the quality assessment of the papers included in the SMSes.


However, after extracting the data from these SLRs, we found that 17 SLRs that did not report their quality assessment criteria inside the paper or somewhere available to public.

we divided the 127 SLRs into two lists: 110 SLRs with explicit quality assessment criteria reported, listed in Appendix A, and the other 17 papers (without sufficient information about the quality assessment claimed to have been used) are listed in Appendix B.


Studies indicated that the DPM method was one of the best Carve-fitting methods.

the principles of DPM method are quite different to the original CRC method, and as a matter of fact, this method is not a capture-recapture method.


In recent times, however, there has been growing unease regarding the quality of the Android platform [3].

kumar Maji et al. [13] studied issues reported for four early versions of the Android OS (versions 1.1, 1.5, 1.6 and 2.0) and found most defects to be present in the application layer.


As usual, each research question motivates some data extraction.

the instrument was a spreadsheet, where each column represents a piece of information that had to be extracted from the studies.


It is important to mention that 76 of these 458 studies use support mechanisms only to data analysis and research validity, without applying any mechanisms to guide the planning and the conducting of empirical strategy.

if we consider the studies that use at least one as reference to aid planning and conducting the empirical strategy, we have only 382 studies, in other words, only 43% of the full papers published in EASE, ESEM, and ESEJ apply guides to their empirical methods.


The rationale was that the testing effort might be a proxy measure of the claimed effects of TDD (improved quality and productivity), due to its central role in this technique [6].

the authors claim that, since TDD developers are believed to put more effort in unit testing when compared to test-last developers, the effects on external quality and productivity are likely to become evindent when an high level of testing effort is observed.


No single source document of guidelines for mandatory log events exists to provide a comprehensive overview of what a software engineer should log.

for our current work, we present a methodology for identifying mandatory log events based on natural-language artifacts specific to the individual software system.


Logging everything often introduces resource and performance [4] issues.

heuristic 2 covers the most verb-object pairs (35%); Heuristic 2 and Heuristic 3, together, cover approximately 47% of verb-object pairs; Heuristics 2-4, together, cover approximately 57% of verb-object pairs, etc.


For example, use create instead of make , use edit or add (as appropriate) instead of indicate , and create a blog entry instead of blog .

in use-case based requirements, sentences are allowed to freely follow any grammatical structure and pick from a larger variety of verbs, since use-cases are not constrained to describing only what the system shall do.


It is assumed that the upper level controllers are connected to the network with wired connection.

it is considered that there is no point of attack between the network and the controller.


As technology evolves and new programming paradigms are born, Design Patterns evolve too: patterns for distributed and parallel computing or Cloud oriented and High Performance architectures have been defined to meet current applications requirements.

here we focus on Cloud Patterns, that can be seen as a recent evolution of Design Patterns but especially defined for Cloud platforms and environments.


When a Design Pattern is detected, it is possible to identify a well defined set of software requirements it satisfies: being able to determine the Cloud Pattern that fulfills the same (or similar) requirement can lead to an automatic porting of the examined software system to a Cloud platform.

using patterns characteristic expressed through a semantic based formalism, we propose a tentative procedure to assess the equivalence between Design and Cloud patterns, aiming at providing a set of possible mappings between the components belonging to different patterns.


The main problem is that it could be rather impossible to automatically analyse the content of the patterns described in this way and to compare them with others.

adding negative consequences decreases the evaluated score, since they can have a negative effect on the migrated application, if the Cloud pattern was chosen for the mapping.


At the light of these insights, it makes sense for a developer to switch from continuations to Promises.

the refactoring of existing code bases might be an operation impossible to carry manually within reasonable time.


Such an "all-or-nothing" [15] data placement policy, i.e., placing the whole input of one job in one tier, is likely to yield good performance.

we further vary the partitioning by increasing the fraction of input data on faster ephSSD (Figure 5(b)).


While the central location that acts as a hub is often located in a well-provisioned data center, the resources are typically limited at the edge locations.

the available WAN bandwidth between the edge and the center might be limited.


This 1) greatly reduces the number of operations related to managing the OMS, 2) reduces the amount of information that needs to be cached in the processor TLBs, and 3) more importantly, enables the memory controller to completely manage the OMS with minimal interaction with the OS.

naïvely implementing the second step will involve a TLB shootdown for the corresponding virtual page.


Finally, assuming each cache tag entry requires an additional 16 bits for each tag, across a 64KB L1 cache, 512KB L2 cache and a 2MB L3 cache, the cost of extending the cache tags to accommodate a wider physical address is 82KB

the overall hardware storage cost is 94.5KB


In contrast, with our framework, the system can potentially use an overlay for each virtual page to store metadata for the virtual page instead of an alternate version of the data.

the Overlay Address Space serves as shadow memory for the virtual address space.


Many libraries in the HPC field encapsulate sophisticated algorithms with clear theoretical scalability expectations.

according to this method, we first calculate clock differences relative to the first process, and then set a time window relative to this process in which every process should start the operation.


For the test cases that have known analytical models, like MATMUL (O(n3) FLOPS, O(n3) Loads, O(n2) Stores, etc.), it is easy to validate the generated performance models against the source code, as shown in the previous section.

(See Listing 2 for examples where COMPASS detected strided accesses and SIMD FLOPS.)


Furthermore, white boxes denote the stencil group execution times computed as the sum of the maximum between stencil execution times and communication times.

we estimate the execution time ts of a stencil's that performs cs floating point operations as the time needed to compute the stencil without considering any communication cost.


Our performance model shows that our kernels, like most stencil computations, are heavily memory bandwidth limited.

the correlation factors of 1.5x respectively 1.6x can be attributed to the fact that the kernels attain only a fraction of the peak main memory bandwidth.


We put all stencils that correspond to a specific tiling hierarchy level into brackets.

a hierarchical tiling results in a nested bracket expression with the outermost bracket term representing the bottom of the tiling hierarchy.


Each task in the TDG has a list to include its predecessors (plist ).

heat diffusion shows higher overall improvement over the different configurations.


In this regards, they are not the same as the CPUs and therefore when we divide work across the nodes, and between the CPU and the accelerator, we need to partition such that the accelerators only require data transfers with their hosts.

the task graph for the problem is such that the tasks assigned to any accelerator have data-dependencies only with their host CPUs.


Considering the Xeon PhiTM s higher core count the situation becomes worse, as there are approximately 134 MB of RAM for every Xeon PhiTM core, compared to 2 GB of RAM for each CPU core.

the Xeon PhiTM is most effectively used as a large SMP node, programmed using a shared-memory paradigm.


Currently, ASPaS supports two variants of bitonic merging networks, because their corresponding permutation operators can symmetrically and completely utilize all elements in each input vector.

other merging networks, e.g., odd-even network, cannot rearrange all elements and need more masks to hide irrelevant elements in each concurrent step, leading to additional overhead.


after threaded through the wires of the network, these 4 elements are sorted.


As a result, for every 16*16 elements, the “no-vec” version needs 16*60 = 960 comparators to partially sort the data.

the code generated by ASPaS only needs 60 vector comparators, and then uses 4 data-reordering operations (Eq.1) for each pair of vectors in the aspas_transpose to transpose the data.


All previous decisions, which resulted in any kind of design or implementation, constitute a limiting factor constraining the ongoing development.

current research is aware of the influencing nature of design constraints but does not sufficiently address them, especially not in the context of design decision reasoning during software evolution.


Solution Repository: The tool has a repository containing solutions, grouped by different categories like architectural styles, design pattern, frameworks, COTS, and refactoring solutions.

to complete the process, the selected solution ADOutcome from the previous step is implemented in the last step.


As stated in our previous work [6], the proposed testbed considers game software as inter-connected components, which function as cooperative modules via inter-component message transfer.

a game application is decomposed into a number of pieces, which either executed in the cloud or the players terminal, according to the status of devices and network quality.


In other words, a game application is decomposed into a number of pieces, which either executed in the cloud or the players terminal, according to the status of devices and network quality.

the testbed is required to be capable in perceiving the application runtime environment, making decisions of workload allocation, and facilitating the dynamic inter-connectivity between cloud/terminal components.


Matrix M is computed using matrix Ci-1 and variance ssi-1 that are carried over from the previous iteration.

based on our analysis, the most promising PCA approach for large datasets is the probabilistic PCA.


This happens because MLlib-PCA performs dense matrix operations on the covariance matrix.

this simple optimization can benefit several other machine learning algorithms.


In order to extend SecLoc to support data re-storage, we extend SecLoc as follows: 1) After the initial storage at state t0, for each time of data re-storage, we allow users to specify a new (random) state and encrypt data at this new specified state.

as long as the storage stage occurs, a new state would be involved.


Similar to the black detection problem in the Lego assembly task, detecting white paper is not as easy as looking directly at the RGB values.

we use an approach similar to the board localization approach in the Lego Assistant to reliably detect the easel surface (Figure 6(b)).


However, as seen in Figure 6(e), this detection can be noisy because of shadows and creases.

that would be necessary, for example, if we were to tackle the far more challenging and difficult task of enabling a blind person to play.


Likewise, the target address calculation for multiple ToCs to the same target address can be done once.

many redundant target address calculations can be eliminated.


A prepare-to-branch (PTB) instruction has been previously proposed [3].

note that the SP architecture eliminates the need for a RAS since the return address is known at the point of the return ToC.


The approach used in KESO's alias and escape analysis is based on the work of Choi [10].

behavior, results, and features of the analysis for stack allocation are similar.


For each run of the optimization pass, allocations are propagated at most a single level up against the direction of the call hierarchy.

running the pass multiple times will increase the maximum scope extension level.


Again, the LLVM compiler's auto-vectoriser fails to exploit any vectorisation opportunities.

the port produced by FREE RIDER substantially outperforms the baseline implementation.


However, what we have observed is that industry has developed its own set of VM tools, potentially reducing technology transfer from academia, which is vital for any research field.

in order to contribute to the establishment of VM tools standardization at architectural level, we strongly believe that reference architecture concepts can support such an establishment.


They contain essential knowledge for developing products encompassing: the knowledge for designing concrete architectures of systems of a given application domain; development best practices; and software elements.

this paper discussed the importance of an architectural standardization for variability management tools based on reference architectures in order to provide several benefits at developing these tools, such as, promoting interoperability and integration, increasing reuse of projects experiences, and establishing development best practices.


one should determine the appropriate formalism level for describing domain elements (e.g., legislation, standards, quality requirements, and system compliance), infrastructure elements (e.g., software elements, hardware elements, and architectural styles), application elements (e.g., constraints and functional requirements), and crosscutting elements (e.g., domain terminology, external communication, decisions, and internal communication) of reference architectures for embedded systems.

a formal description can support the automated comparison and/or selection of components for instantiating these reference architectures.


Considering that components can be used for realizing reference architectures, we also investigate how they could be expressed in such a formal description.

we focus on embedded systems due to the sophistication required for systems in this domain.


Model-Driven Development (MDD) is a software development approach where models are first-class citizen [24].

a special type of abstract model, so-called metamodel, is essential to this approach.


In order to discuss how component-based development can contribute to the definition and use of reference architecture in practice, in this position paper, we outline some fundamental characteristics of components and composition and posit their relevance to reference architecture.

compared to objects and architectural units, mapping features to/from encapsulated components is relatively straight forward, since such components have no external dependencies, and are therefore very loosely coupled (via coordination).


A component model defines components and their composition.

rather, software units are usually glued together, albeit often using very sophisticated programming frameworks.


When reaching this level of capacity the number of cores per node is expected to increase significantly [6] while node memory capacity and I/O latency and bandwidth are expected to not be able grow at the same pace (due to power consumption and technology limitations respectively).

the gap between CPU and I/O capacity is expected to increase, and I/O to become a performance cap for certain applications.


The software defined execution environment of a composite solution can be very complex.

solution operators levy requirement on the execution environment, for example, scaling behavior, access rules, compliance policies.


When a client is running on Azure, we see much more performance improvement because Azure disk performance is worse than AWS as we shown in Figure 2.

we omit the result because there is too much performance variance in Azure disk to be generalized.


That is, retrieving data located from a nearby DC is not always better than a local DC as Figure 1(d) shows.

determining the boundary between nearby and remote is an open question.


We now describe the process for calculating the histogram.

the method of Cho et al. did not extract the embedded watermark.


3D printing content is a new form of content being distributed in digital as well as analog domains.

its security is the biggest technical challenge of the content distribution service.


The original sphere has radially uniform surface normal vectors in all directions based on the center (See Fig.3(a)).

in the layered sphere most of the surface normal vectors are changed along the z-axis primary test not the x-y plane (See Fig.3(b)).


Also, at any given time, only a small number of applications (up to w) are generally expected to be processed given the DS-Pc.

whenever the service-queue is processed in our VARSHA framework, the number of times that our region-selection heuristic would need to be invoked is bounded by a relatively small constant integer.


In [5], authors claimed the first use of probabilistic model checking to perform RAM analysis of satellite systems.

use of exponential distribution to model both failure and maintenance is a major limitation of their work.


Open initiatives like openSCAD [16] and openJSCAD [21] are gaining footholds within the scripted-CAD community.

these tools allow programmers to produce end-user interfaces for customizing models which allow users to alter features such as width, curves, or text.


In our static analysis approach, we focus on comparison of the difference between permission and intent usage for each mHealth app.

to the best of our knowledge, none of the related work proposes the framework of auditing on mHealth apps, which monitors the resource usage patterns of mHealth apps in real-time and triggers alerts to users if abnormal resource usage patterns are detected.


For example, it is possible to store multiple worksheets, and to include not only data, but formulas, macros and images.

it is possible to extract not only data but metadata and annotations as well.


This is useful for statistical purposes, but not for identifying the riskier zones and seasons.

these visual overviews were co-designed together with a series of stakeholders, taking into consideration their feedback and recommendations.


Similarly, a distance 1 occurs in the case that there is only a single undecoded neighbor, which can then be recovered uniquely.

a distance of 0 or 1 provides information about the recovery of neighbors that are part of a received linear combination, and thus they can be viewed as an ACK on a group of symbols (i.e., neighbors of the linear equation).


Not only does the tester not have control over the internals of the system she now also does not have control over the environment in which the system is executed.

the same test, executed at different times, may cause different loads in the system.


Ideally, in objectoriented systems, for each production class, we have a related counterpart in the test section.

the size of the test suite increases linearly with the size of the system.


We start with 340 apps and unfortunately 42 apps fail to go through due to the same reason as we mentioned above.

here we only show our experimental results for the rest 298 apps.


Of special interest to our analysis are the dangerous and signature* permissions, because of their impacts.

increased system complexity means, in general, not only more functionality and larger source-code, but also more intricate system architectures.


While it is inherently hard to perform large-scale dynamic analysis, we acknowledge the limited size of our 100-app corpus.

obviously, if the verification is not implemented correctly, an attacker could impersonate the server.


Observe that Algorithm MVC specifies up to K + 1 iterations, each iteration consisting of 3 steps enumerated in the algorithm.

the algorithm may potentially terminate before completing all K + 1 iterations (due to the check in step 3).


First, observe that the four ports of the nodes introduce more choices for the scheduler in every step.

these new choices, if treated uniformly, result in the same multiplicative factor for both the “positive” (an (l, q0) interaction) and the “negative” (an (l, q1) interaction) events, so the probabilities of the process are not affected at all by this.


Informal description: Every node u has a unique id idu and tries to simulate the behavior of the unique leader of the protocol of Theorem 1.

whenever it meets another node for the first time it wants to mark it once and the second time it meets that node it wants to mark it twice, recording the number of first-meetings and second-meetings in two local counters.


This was very convenient for studying the capability of such systems to self-organize into abstract networks and it helped show that arbitrarily complex networks are in principle constructible.

this is not expected to be the actual mechanism of at least the first potential implementations.


Figure 1 suggests a link between the phase lengths and the number of nonperfect time steps.

every phase of an epoch except for the last one contains only non-perfect time steps.


One is a Linux kernel; the other is an LWK.

none are sufficient to include the latest crop of LWKs.


One approach to making the approach more robust would be to use an exhaustive set of test cases, covering all possible error conditions and program inputs.

in many cases, particularly for those who use commercial software, the source code for programs is often not available.


Phase angle differences across different buses in a system are a measure of static stress across the grid and its propensity to instability.

phase angle differences are required to be monitored with respect to predetermined stability thresholds.


A global scheduling mechanism was employed for load balancing, decreasing the contention and improving performance.

the other is the SW2 node (of Guillimin), consisting of two Dual Intel(R) Sandy Bridge EP E5-2670 2.6 GHz CPUs, 8 cores per processor, 8 GB of memory per core, and a Non-blocking QDR InfiniBand network with 40 Gbps between nodes.


This paper explores the use of transactional memory as an alternative to conventional synchronization mechanisms for managing the pending event set in a Time Warp synchronized parallel simulator.

we explore the application of Intel's hardware-based transactional memory (TSX) to manage shared access to the pending event set by the simulation threads.


When the simulation does appear to run normally, it executes slightly faster than the strictly static thread assignment scheme.

the instability of this migration scheme made it infeasible to obtain data.


This way we achieved differentiated configurations in terms of the relation between the event execution granularity, and the granularity of the extra-ticks’ interval (recall this has been set to 100 microseconds).

the adopted settings allowed us to determine different actual likelihoods for an extra-tick to interrupt an on going event (in fact such a likelihood is higher when the event granularity is greater), which gave us the possibility to assess our time-sharing architecture when changing the likelihood that a higher priority task can be detected as standing while the execution of an event is in progress.


Then, the model computes the time the car will need to traverse the node, adding traffic slowdowns which are again computed according to a Gaussian distribution.

the probability of finding a traffic jam is a function of the number of cars which are currently passing through the node.


Such a reduction, which can lead to improving the memory locality and the cache/RAM hierarchy efficiency, can be considered as a reflection of the whole optimization process leading to well-suited tradeoffs between log and restore overheads.

these literature solutions do not directly tackle the issue of memory-access efficiency in NUMA platforms.


The sequential execution is a baseline one, which allows us to verify the level of speedup achievable via parallel runs.

the glibc-based parallel run is a reference one allowing us to assess the effectiveness of the ad-hoc NUMA-oriented memory management support for Time Warp (when compared with standard memory allocation and management facilities).


Since no transformation is done, the warehouse retains all the information embedded in the data.

with that format of data, there is more chances that interesting information can be found.


Then, few of the most important challenges related to large data warehouse are described.

the difficulties related to data storage from the sensors are reviewed and many of the data mining problems in the context of Big Data are discussed.


The main advantages of the method are that the dataset is easy to understand and process and the risk of losing information is limited for simple sensors.

the story is different for more complex sensing technologies such as ultrasound and laser range scanner.


Loop transformations are known to be important for performance of compute-intensive programs, and are often used to expose parallelism.

even if a compiler is capable of automatically transforming a loop nest to expose parallelism, the resulting code may be complicated and different from the original, making it difficult to understand and/or to maintain for the programmers.


many transformations involving loops often obfuscate the code, and are cumbersome to apply by hand.


For example, in Couch CMS the backslash and double-quote character is replaced to prevent an outbreak of double-quotes.

an attacker can terminate the current script tag and start a new JavaScript context that requires no quotes by injecting </script><script>.


Exploitation of injection flaws almost always requires special characters.

next to numbers, alphabetical letters can be considered to be a safe character set.


In this section, we describe the ways that students combined usercentered design and programming sophistication to create their digital stories.

we also found that, perhaps not surprisingly, when not specifically prompted, students tended to view their project from their own perspective, omitting interactive features that could be understood by an outside user.


When compared to the programming in Logo, this drastically reduces the number of actions a user needs to make to achieve the same level of functionality (compare Figure 2 and 3).

the SCP appears to provide the ease of use that comes with a non-programmable control-panel with the functionality of a programming environment.


However, in scenarios an action does not always end the process.

an action step in the scenario creates a gap in the plan graph relative to the scenario.


The key difference to [1] is that the local monitors have a predefined, in general not fully connected, communication topology.

a local monitor can in general not know the truth of all propositional variables.


These graphs can then be used by subsequent testing processes within the GUITAR framework.

the study focuses on programs written in C or C++, which use GUI libraries such as GTK or Qt.


We describe both mechanisms with four groups of design axes related to four questions: When (temporal characteristics), What (content characteristics), How (medium characteristics) and Where (spatial characteristics).

the What group of feedforward contains a subgroup highlighting the potential impact of the feedback mechanism onto the content of the feedforward mechanism.


For instance LightGuide [27] displays the gesture to execute through visual cues as if on the user’s hand (egocentric).

this projection of the gesture does not follow the hand, but is anchored in a specific location in the world coordinates (absolute).


Figure 5 shows an example tree representation of a search space with weights assigned to each sub-branches.

all of them follows general syntax: name of transformation followed by parameters of the transformation as shown below.


The idea is to identify regions which the compiler may be able to optimize or specialize using information about values or shapes of certain variables at runtime.

given the cost of runtime specialization, such regions should contain potentially expensive operations such as loops or array library operations.


Furthermore, their appearance reminds the stakeholders of the well-known concept of hyperlinks.

this approach is intuitively comprehensible for stakeholders and integrates seamlessly into their workflow.


Engineers and designers prefer free-hand drawing and writing in early design and modeling phases [5, 7].

the AugIR enforces informal and incomplete sketches and avoids strict modeling languages.


Because of interchanging between different means of transportation, the traveler needs to process a sequence of unimodal steps.

the phase during the trip of an intermodal travel chain consists of several unimodal sub chains.


During the trip/on the vehicle: The traveler needs information in order to navigate to the destination, about the right direction and route.

intermodal trips place exhaustive demands on support for managing disturbances.


Technically, all our design choices were possible from within the new CMS, and our IT department was willing to help us implement those choices in whatever way they could.

during the summer, one of the graduate students in the class was hired to continue the migration of the content from the old site to the new one, and was charged to implement as many of the design changes as possible.


Active databases that use the event-condition-action paradigm have been extended with fuzzy conditions to handle uncertainty [7].

they focus on uncertain ECA-rules rather than uncertain data, and they do not support speculative calculations.


The software requirements engineer can observe that the MSD RemoteLockDoors, responsible for the actual locking operation, correctly activates the MSD LockingFeedback triggering the turn signal feedback operation.

he also reveals that the MSD SpeedLockDoors activates this MSD, if he simulates both use cases together.


However, he also reveals that the MSD SpeedLockDoors activates this MSD, if he simulates both use cases together.

the coordination behavior requirements specify that the speed locking activates the turn signals during driving, which can cause safety-critical confusion in the traffic.


Based on the above analysis, even if cpm.a1 is helped, its end time will still be delayed to the 18th day without cpm.a2 helped.

currently, many software companies provide dedicated solutions for specific fields by designing universal business flows.


The different kinds of possible impacts also led to reflections on how to summarize and deal with different values and/or ranges of impacts.

the benefit is that more semantic and other information is added to the model.


The annual workshop shall form the basis for a long-term collaboration between the community members.

the first workshop is conducted as an interactive discussion for the elaboration of initial ideas of how to collect evidence on the impact of agile practices.


Constraint Programming (CP) typically revolves around describing a global system state, which is why always and once constraints are often sufficient.

objectoriented Programming (OOP) revolves modularization of system state and dynamic adaption.


These functions are called from proxies without knowing the internals of their specification.

proceed calls in the external device would be lost, as external devices do not have information about other available contexts.


But in practice, programmers will not write their creation code using object algebras unless they are expecting to have to extend their code.

i do not believe that object algebras provide for unanticipated extension.


Upon first execution, every message to an object resolves to an object-specific AST snippet (message resolution) [15, 18], which is then inserted into the enclosing AST as a replacement for the message.

message resolution replaces object-independent messages by object-specific ASTs.


To this end, FlexJava is a language accompanied with an automated static analysis that supports both fine-and coarse-grained approximation and provides formal safety guarantees.

any computation and data that exclusively affects the annotated variable is safe to approximate.


OLED screens are suitable for optimizing energy consumption of GUIs in apps, because the power consumed by OLED screens depends on the combination of color levels in the screen's sub-pixels.

power models of OLED screens estimate the energy by combining individual consumption of the color sub-pixels [20, 41].


also, by evaluating the solutions on five commercial apps, we confirmed that some project managers and developers are ready to account for GEMMA's recommendations in future app releases.


Indeed, we can see very clearly in the external contributor models (Table 5) that the more forks a project has, the more pull requests are submitted by non-core developers.

some projects may have introduced CI because they were experiencing high interest; also, they may have introduced CI because they already had a strong quality culture.


The loops at lines 14 21 and line 22 implement the second and third steps of SPP respectively.

the loop at line 22 performs absorption.


Given two EFSMs, their technique first computes a set of elementary changes, then uses a static dependence analysis to find which test covers what changes, and finally selects to run only tests that are non-redundant with respect to the changes.

our evaluation does not assume any static analysis and measures the change-related loss in quality for the reduced test suite.


The preceding studies highlight the efforts spent by researchers on developing and testing methods in design higher education.

scholars such as Dorst [10] mentions the low uptake of methods among practitioners, a notion shared by Andreasen [2].


We run it on the Sora SDR platform and demonstrate on a test-bed that it is able to operate in real-time.

it is easier to understand and has very similar performance to the handtuned Sora code.


In [7], the authors proposed an approach based on Gray-Box method to generate test cases from UML Activity Diagrams.

they gave no method to automatically generate test cases from their extracted scenarios.


Additionally, the factory model contains knowledge about the properties of the different components, their interplay, their locations, their maintenance states, etc.

the factory model represents the current production capability of the factory.


For all four metrics described below, classes with high values are more likely to be worse in the SPL quality.

higher values might be an indicative of a smell affecting the SPL design.


Constants and refinements are files that can often be found in Feature-Oriented Programming (FOP) [6].

refinements can change the behavior of a constant if a certain feature is included in a product.


Features can be defined as modules with consistent, welldefined, independent, and combinable functions [4].

(vii) Does the method have tool support?


To address this form of variability, techniques related to dynamic software product lines and run-time tenant-level customization have successfully been applied [21, 26, 30].

saaS offerings are inherently susceptible to many other forms of variability, caused by (i) co-existence of different versions and variants of key components and enabling services, (ii) variations in deployment (e.g.


As usual in domain engineering, the models, here the evaluation schemes, are pre-thought for the whole product line.

for the evaluation schemes it is not yet specified how they are computed, this is done in the activity single view evaluation.


Moreover, for reusing the automatically derived C2FT as final failure analysis the entire process and tool chain would have to fulfill the requirements of the corresponding safety standard.

by analyzing and specifying the failure propagation in parallel to the domain architecture, safety aspects can be immediately considered in the architecture and the reuse of C2FTs from the domain into the product implementation facilitates the failure analysis of the final system and saves effort.


Constraint C4 is based on these archiving events, which are provided by two different probes now, PSteel and PSteelDB.

analyses [2] can be used after evolution to detect potential anomalies such as dead or false-optional features (see Table 1).


The initial set of Core components had provided support for the four extension types identified in Figure 1, and standardized a set of contracts for how extensions and applications would interact, exchange data, and persist SME logic.

we note three key limitations of this experience with respect to evaluation of our hypothesis.


This paper aims to study the AI techniques from the standpoint of their applications in design phase.

it focuses on techniques developed or that are being developed (under conceptual stage/s) of AI that can be arranged in solving problems associated with design phase of SDLC.


The process of this methodology includes set of activities namely; data flow diagram where it converts inputs into the necessary outputs, structural decomposition that is beneficial to improve a structural system model and another activity is detailed design description, which gives the detail knowledge about each function [12].

there are still certain issues, which are given as follows: FI1: A complex system includes various components and levels of subsystems with multiple interconnections that are complex to manage, recognize and predict [13].


However, design phase have a tendency to be production delays, incomplete designs, rework, change orders, and have a big impact in all the development stages.

the usage of AI techniques in order to improve design phase favorably affects the quality of overall software life cycle [4] [5][6].


Starting expertise was better in linear algebra at 3.10 and in C programming at 2.93.


It describes three algorithms to model and predict the satisfaction experienced by individuals using a recommender system for groups, which recommends sequences of items.

the use of curiosity can aid recommendation systems to achieve better prediction rates and also decrease rejection rate if compared to traditional recommendation systems.


This paper also discussed future directions for our multimedia validation approach.

it is possible that the visible amount of a media item has a different form.


The element behavior is identified through its tag name, its HTML attributes and its JS properties.

we check the properties that can alter the static behavior of an HTML element, e.g., event listeners, and the HTML5 attributes that identify the role of an element, e.g., "role".


The non-matching column refers to the average number of blocks that: 1) are over-segmented by the MSoS, 2) have no correspondence with any block in the GT or they are not correctly labeled.

we check the properties that can alter the static behavior of an HTML element, e.g., event listeners, and the HTML5 attributes that identify the role of an element, e.g., 'role'.


Furthermore, Eurema uses runtime models as first class entities considering R 6.

collaboration aspects for the derived requirements R 3 , R 4, R 5 , R 7 , and R 8 are missing.


We propose new concepts that build on those contained in ensemble-based models.

we introduce the ideas of ensemble nesting, dynamic role cardinalities and ensemble fitness.


We also expect many dependencies from other repositories towards BioC since it is an active package distribution that offers the same quality checks as CRAN , and also because it contains many useful datasets.

in order to carry out our empirical analysis, we need to extract data from each of the targeted R package repositories.


Plug-in architectures are a practical vehicle for implementing such extensibility.

in most contexts, plug-in based mechanisms have been considered as implementation level solutions rather than true architectural patterns that shape the designs as a whole.


The percentage of rated extensions for Magento (49%) is of particular significance, considering that it is the platform with the greatest number of extensions.

prestaShop falls short in terms of this metric, accounting only for 23% of rated extensions.


Regarding the main findings of our work, a number of interesting issues arise: Partner shakeouts as a governance tool.

it appears that three main platforms account for roughly half of the market share: Magento, PrestaShop, and WooCommerce.


There are many benefits of automating and optimising architectural assets mass production, but these benefits are not yet exploited fully by today's industries of software-intensive systems, as many issues related to the technical aspects of the development have not been entirely solved.

it may reduce the severity of the technical issues emerging during the construction process, and other risks related to the decision.


Ideally, separate fields could be presented for each viewpoint and characteristic.

the user interfaces in a tool restrict the options, so we condense information that suits our criteria in one field only: subtype.


Thus, having an overview and understanding the architecture of a system is critical for supporting a reasonable evolution, in-line with the desired system qualities.

a considerable emphasis (e.g., [18], [14]) has been put on the need to elaborate software architecture descriptions that depict important views of the considered system from various viewpoints and even two international standards have been released to sustain and systematize the documentation effort ([3], [1]).


Testing as well as verification at the concrete level is more expensive than on an abstract one, especially if some corresponding corrections within the system are necessary.

it makes more sense to have more intensive testing at logical level to reduce the overall size of test suite for the next levels as much as possible.


The priority and role based scheduler in pSync helps to avoid duplicate file delivery.

this increases the file sync time when a small number of nodes are out-of-sync.


This study thus created Logo trend visualization , which is a combination of Radviz and Circle parallel coordinate to provide a guideline to design a competitive logo, based on such background.

likewise, a relevant article in 2014 also showed that MonoCrest took a hint of Monoline while adding the sense of Rhythm.


It can be seen from the results that as the number of the kernels increases, the communication overhead becomes significant and the throughput decreases.

persistent threads approach seems that does not follow the same decay of normal CUDA kernels, providing increased throughput when more than 12 kernels are utilized.


Symbiosis allows for resolving the same issues by relying on devices that already exist on the network.

instead of needing more servers, symbiosis allows for perceiving every new purchased smart device as a potential server.


While all the components presented in Figure 3 are essential, we investigate specific components of the system with a focus on demonstrating SymbIoT’s feasibility, value, and its ability to satisfy its design goals.

we describe our initial take on task configuration and generation, nodes configuration advertisement, and scheduling procedures.


Again, the MPI implementation could be made aware of TPSL mappings and make threads share buffers the same way as in a multithreaded implementation, however this would clearly require additional modifications.

with the considerably increased complexity of recent HPC applications, e.g., demand for components such as in-situ analysis, elaborate monitoring and performance tools, etc., the full availability of Linux APIs has gained high importance.


The advantage is that the intercept is measured for each clock model separately.

the intercept error only depends on the accuracy of a single SKaMPI synchronization and on the error of the slope, which was found to be very small (10-8).


To compare the synchronization schemes of SKaMPI and Netgauge (NBCBench) to the competitors, we have extracted the relevant clock synchronization algorithms from their respective benchmarking frameworks.

we use a fixed window size and disable the dynamic window adaptation as done by SKaMPI and NBCBench.


We show results obtained with MVAPICH 2.0a-qlc, even though it is not the latest version of MVAPICH, but the one that was preinstalled on the system and for which we experienced this significant process skew.

these results are not meant to evaluate the performance of MVAPICH, but rather to point out potential pitfalls when relying on MPI_Barrier for synchronization.


SBMA uses interposition to intercept calls to libc's standard malloc library.

a call to malloc() in a BDMPI program will be performed by SBMA.


Surprisingly, the performance improvement over the serial application, also in Table 3 was more modest.

as was discussed in [9], the serial version, by its very nature has a few advantages over a parallel implementation.


We also note that we use the terms Host and Device interchangeably for CPU and GPU respectively.

gPU based applications have largely been designed for a single compute node with one or two GPUs.


The following interpreter gives the same value i on each request: It i a is indeed interpreted as the Reader monad.

we had to change the data type name and hence modify (the signatures of) addGet and addN, even if their code does not care about the new writer effect and remains essentially the same.


To manage complexity, information systems and control systems are decomposed in modular building blocks called components.

the intelligent interface between the information systems and the control systems are also decomposed to fine grained smart interfaces between the components of the information systems and the components of the control systems.


Language models can only provide help in source code that is similar to source code that it has seen before.

the data sparsity problem, i.e., the need to see instances of many code con-texts, drives the use of larger and larger corpora to train the model.


But the reuse of contents is not always possible if it is location-dependent (as is presented in [13]).

if the content mentions any characteristic of the environment, the reuse is limited.


We have presented a first version of our tool, which creates location-aware applications in-situ.

the authors present six dramas with different purposes, for example, tourism and learning.


However, recall worsens at higher granularities.

increasing the resolution of analysis decreases the ability of the algorithm to observe drifts occurring at finer granularities.


Currently, cloud computing systems such as Amazon Web Services (AWS) [3] and Google App Engine (GAE) [16] offer reliability SLAs specifying the fraction of availability over a fixed time period for their services that users can expect, when they contract to use a service.

they do not provide SLAs guaranteeing minimum levels of performance.


The reason why AppScale s performance is more stable over time is because it is deployed on a set of closely controlled and monitored cluster of virtual machines (VMs) that use a private Infrastructure-as-a-Service (IaaS) cloud to implement isolation.

the VMs assigned to App-Scale do not share nodes with noisy neighbors in our test environment.


We also implemented a HDFS client library with HDFS's Namenode as its metadata server.

since the performance of a single Namenode turns out to be inferior to a single IndexFS server, we only show ShardFS on top of IndexFS servers in the evaluation section.


Our prototype proved its scalability and in addition can be configured by an experienced user to control the trade-off between monetary cost and number of latency violations.

this step is optional, in contrast to the mandatory configuration of the user defined threshold-based approach.


SpotOn generally reevaluates its decision whenever a job’s state changes, e.g., due to a revocation, in order to select a new instance type and market to migrate the job.

on revocation, SpotOn re-executes the greedy cost-aware policy to determine where to restore the job and the fault-tolerance mechanism to use based on the job’s remaining running time.


So, for comparison purposes, we implemented a working version into PowerGraph and LFGraph unfortunately, this option gave much lower accuracy than Zorro.

the inaccuracy was 25% for PageRank on PowerGraph and 51% on LFGraph with this option, vs. 0% inaccuracy using Zorro.


Magpie [3] uses detailed knowledge of application semantics provided by the developer to extract causality from system event logs.

domino automatically captures causality.


The reason is that DOM2 callbacks are not enumerable, i.e., given a particular DOM node, Domino cannot retrieve a list of the node's DOM2 handlers.

domino must interpose on addEventListener(), as we described earlier in this section.


As shown in Figure 2, Domino interposes on timer registration functions using JavaScript's powerful reflection mechanisms.

these systems cannot optimize server-side scheduling using knowledge of the "wide-area" event stream that spans both clients and servers (§3).


Since the server-facing portion of the application lacks a GUI, Node does not expose DOM0 or DOM2 events.

node does support timers and Web Worker-like execution contexts called processes.


Next, dEst uses the weights of the linear regression from dProf to forecast upcoming cost and benefit.

we do not have exact information about future objects since these are dependent upon the user's upcoming actions which are obviously not known.


(2) Non-work-conserving IO schedulers become less effective in virtualized cloud environments.

the IO latency under virtualization is much larger than that in native.


We observe that when three VMs share the same storage, the throughput of VM1 (the low IO-concurrency VM with 16 KB size) is only 60 IOPS using CFQ(Linux) and 1224 IOPS using PS(mClock)  far from the target share 2714 IOPS.

using BAPS(vFair), the average throughput of VM1 reaches 2721, which is quite close to the target share.


Typically, it is more efficient to read fewer large records than many small ones.

a large IO request is slower than a small one due to the device’s data transfer rate.


Holding a reference in two SingleTLOBs and two space maps during a GC phase nearly doubles the costs (additional 84 bytes).

the majority of objects are stored in MultiTLOBs, where the costs for maintaining a TLOB can be neglected.


In order to represent an accurate snapshot of the heap, the trace processing tool needs to merge the object’s characteristics from the allocation event with its new address in the GC move event.

the parsed information of the allocation event must be preserved until the associated object dies.


Control-flow, operation, and collection profiling add a low overhead in ZipPy.

variable access and type distribution profiling add a higher overhead.


There are prior efforts that try to reduce resource consumption on smartphones [38, 44, 39].

these efforts are orthogonal to our work.


Tracking apps permission access patterns: The permission access patterns of an app are not exposed to any user-level tool (or even a system-level tool unless it is enforcing the permission).

zapDroid requires modifications to components of Android to track the permissions accessed by zombie apps.


No free lunch: By quarantining an app, a user essentially removes the app from her phone (albeit temporarily).

if she stopped using the app because of the lack of some features that are later incorporated by an update, she must get to know of these new features from an external channel (e.g., a website), since her phone will not receive updates for quarantined apps.


Broad compatibility: ZapDroid should be usable on most Android devices, if not all.

it must not be limited to working on a specific vendor’s device(s) or on a particular version of Android.


Using blockmap, a programmer can express block and cyclic data distribution [28] across MPI processes, while the debugger uses it to construct a global view of the data at runtime.

languages that manage the decomposition process make it easier for the programmer both during data construction and debugging.


To simplify validating the ported program, and to help a programmer find the root cause of any errors, relative debugging was proposed in the mid 1990s.

this ad-hoc approach is impractical in large-scale programs that decompose the data across a deep memory hierarchy for a number of reasons.


Both the hash-based and P2P methods parallelize data comparison and reduce data traffic between the client and servers.

a hybrid supercomputer containing heterogeneous processors and a deep memory hierarchy allows programmers to exploit multiple levels of parallelism.


A few existing studies have also tried to estimate the reliability of a storage system through simulation [7, 8, 11].

elerath and Pecht [7] have implemented a Monte Carlo simulation for RAID 4 groups to evaluate how time dependent failure and repair rates impact the average number of data loss events that could occur during a given mission time.


This is mainly because disks constitute only 15-20% of the cost of one SSU.

when designing a storage system with performance as the primary objective, it is optimal to buy as many SSUs as possible before optimizing or negotiating for disk price or capacity.


Below 1K nodes, our optimized reorthogonalization algorithms are not differentiated.

at extreme scale, this approach is 2-3Ã— faster.


While it would be possible to manually allocate intermediate value storage, the DSL abstraction allows STELLA to provide backend specific stencil buffer implementations.

each backend optimizes storage layout, alignment, and memory footprint of the stencil buffers.


In addition, the reference order of message receive order must be consistent between a record and a replay.

in the permutation encoding, CDC defines a reference logical-clock order based on Lamport clocks (reference order ), and computes the permutation difference to an actual receive order (observed order )byusing anedit distance algorithm (Section 4.1).


What is more important is for the application to maintain scalability under record and replay, which CDC enables.


In other words, we posit that programming model research on in-situ analytics is needed.

in-situ algorithms are currently implemented with low-level parallel programming libraries such as MPI, OpenMP, and Pthread, which offer high performance but require that programmers manually handle all the parallelization complexities.


For example, consider the graphical depiction of the cumulative sum component in Figure 1, top left.

such loops are at odds with the anonymity of function results in the lambda-style notation.


The metadata itself is commonly DRM-specific.

the TV Middleware Application triggers the DASH Media Player to generate this request.


The unencrypted content is not exposed over this interface.

the platform specific information that is exchanged in the browser context in EME is now exposed to the network.


We presented an application of the analysis contracts methodology to representative analyses from domains of reliability, sensor security, and control.

a major designtime technique to achieve higher fault-tolerance is redundancy adding functionally identical components in order to preserve system's operation in case one of the components fails.


Conversely, control safety analysis [20] typically consid ers data trustworthiness in the normal operation mode, but often ignores trustworthiness in the failure modes that are provided by FMEA.

both of these forms of analysis make assumptions that may be inconsistent with, or ignore modes determined by, the other.


Also pre-escaping and post-escaping strings are completely application and context-sensitive.

these escaping characters will be determined considering the context and the surrounding characters of the injection point.


The reason for restricting our case selection to Java projects was a limitation of the used tools for identifying extract method opportunities (see Section 4.3).

the tool that we used for identifying the extract method opportunities is able of parsing only Eclipse projects.


On the completion of data collection, a pre-processing step took place.

we filtered out of the dataset methods that were less prone to suffer from the long method bad smell.


Until now, the identification of long methods or extract method opportunities has been performed based on cohesion, size or complexity metrics.

the empirical validation of these metrics has exhibited relatively low accuracy with regard to their capacity to indicate the existence of long methods or extract method opportunities.


By definition, the long method smell concerns methods large in size, which have a semantic distance between the major purpose of the method, with respect to a specific functionality, and the degree to which its implementation serves this purpose [18].

we do not perceive all methods large in size as long , but only those whose large size is due to the implementation of multiple functionalities.


It may seem obvious to inherit techniques and strategies used in general settings.

there are a number of factors to consider.


Its economic strength attracts crossborder commuters who represent approximately half of the work force in Luxembourg.

significant flows of vehicles coming from France, Germany and Belgium significantly contribute to the daily traffic load distribution of Luxembourg.


Additional computations have been done in order to retrieve them.

according to surveys, France is the most popular holiday destination of the Luxembourgish population, so this matches the observations.


As Fig. 4 demonstrates, the slowdown forms almost a straight line.

we build a linear regression model where x is the input data size in GB and y is the total execution time.


Preliminary observation of this pilot study indicates that users invest for the personalization differently regarding the data type and interaction complexity.

all participants had an overall positive attitude toward personalizing the interface according to their preferences during use without interrupting their current tasks.


In some cases one widget totally dominates a specific data type (last name, category, maximum).

in case of complex interactions more factors need to be considered for instance number of options, multiple/simple choices.


Our solution relies on the existing trajectory points, obtained from the trace itself, that are organized into clusters to represent anchor points used in the calibration.

our approach is flexible to be adopted in different real traces, since there is no need for looking at a map nor any further information.


Adobe Flash is a popular platform frequently used for creation of advertisements, videos and interactive contents on web pages.

flash player is neither easy to install nor popular on devices running popular and widely used platforms like Google Android and iOS.


Service implementation is outside the scope of this paper and we will exclusively focus on versioning in the context of service interfaces, in particular the structural aspect.

this paper has focused on a solution revolving round the problem of incompatibility in SORC, from both the provider’s and the consumer’s perspectives.


We can conclude that all the studied factors (pleasantness, unambiguousness, applicability) a.ect the understandability of the diagram.

their guidelines suggest, e.g., that different graphics and icons should be used modestly, there should be clarity regarding the meaning of different symbols, and color should be preferred over black and white (but the number of di.erent colors should be restricted).


Namespaces will not be advertised by the routing protocol unless given explicit permission by the DNCS (see Step 4 of Figure 1).

malicious producers may only advertise namespaces under which they are not authorized to serve if they can subvert the routing process verification check or forge a long-term permission token from the DNCS.


Although our nonoutsourceable puzzle alone does not prevent the collection of statistical evidence, in Section 8.2, we argued that by combining our puzzle with a multi-tier reward system, we effectively make it highly costly or unreliable to accumulate statistical evidence over time.

a worker can opt to steal only the “jackpot prize” (which happens only infrequently but offers a large reward), while behaving honestly when it finds a “consolation prize” which is of much smaller amount but paid off at a frequent interval.


Informally, to effectively outsource work to the worker, the worker must know more than a constant fraction (say, 1/3) of the leaves before calling the random oracle to determine whether an attempt is successful.

if the worker knows more than 1/3 fraction of the leaves, due to a simple Chernoff bound, it will be able to easily steal the solution should one be found.


Note that the ID here is bound to the app vendor's server: only this app server is allowed to push messages to the app.

the study does not go beyond this on the push client side.


Authentication here relies on Android's security settings: the receiver should be either private or protected by permission, and all the IPC calls should target a specific package.

he still cannot inject messages to the target app when it verifies user ID.


Taint propagation algorithms generally propagate taint information at the byte-or word-level, i.e., maintain a taint bit for each byte or word of data.

the programs in the second set were chosen as representative samples of trigger-based behavior in malware.


While we have demonstrated promising results, we do not claim that our system is fully mature and has addressed all the challenges.

we believe that we have made a solid step towards this goal.


We choose these 100 apps in a mostly random manner but we also consider the distribution of app behaviors.

40 apps are malware and the others are benign.


Studies [26, 28] have revealed that the existing descriptions deviate considerably from requested permissions.

developerdriven description generation cannot be considered trustworthy.


Furthermore, RPython with PyPy and Truf.e with Truf.e/JS implement complex widely used languages with the goal to optimize the peak performance as much as possible, and indeed reach the performance levels of dedicated JIT compiling VMs.

meta-tracing has been successfully applied to AST interpreters as well [5], thus, we compare both approaches based on self-optimizing AST interpreters.


Generally, they advise to expose runtime constants also on the level of the used data structures.

to prefer fixed sized arrays over variable sized lists, and to use known techniques such as maps [11] to optimize objects to provide the tracer and subsequent optimization with as much information about runtime constants as possible.


Evaluating each rule at most once: this is accomplished by leveraging rule evaluation order.

the function applicableRules is designed so that it returns a list of rules.


This is related to the work on parametric polymorphism and gradual typing [3, 28], which addresses the issue of casting an unknown function type to a parametrically polymorphic type.

matthews and Ahmed [28] use runtime sealing to ensure that arguments of a polymorphic type variable are used parametrically.


Cantor s mapping can generalize decomposition into tuples of greater arity (n > 2), but the decomposition becomes inef.cient to compute [47].

szudzik s mapping is a bijective function amenable for efficient generalization [46]: .


In addition to the synchronization between a VM and its I/O thread, data movement between 2 co-located VMs requires the I/O threads of both VMs to synchronize as well.

we would need 4 free cores to allow 2 I/O VMs to communicate with each other unimpededly.


Here, we measure the performance of exporting data from Hive to MySQL.

hDFS mostly operates in append-only mode, hence we do not need to refresh all information for the mount point.


Similarly, if a connection consumes the entire bandwidth of a network adapter, without further measures, additional adapters or connections usually do not increase performance.

usually, the implementation of the protocol is decomposed into functional modules such as the management of client communication, replica message exchange, or the protocol logic.


Eventually, such an approach leads to a replica architecture where basic tasks are carried out by dedicated threads that exchange their performed work via in-memory queues to preserve the established request order.

it leads to a task-oriented parallelization [27] and an architecture resembling staged event-driven designs [31].


The analysis done so far does not consider the network latency.

this must be taken into account to avoid that some processes locally stabilize and deliver events before having received concurrent events from other processes.


For all these extensions, the Integrity, Validity, and Total Order properties are not affected, and the proofs of the corresponding results with global time and synchronous rounds can be applied without modification.

in all cases, the Probabilistic Agreement property needs to be revisited and analyzed more carefully.


In this paper, we analyze the requirements and the usefulness of the pub/sub paradigm applied to graphs and present GraPS , a graph-based pub/sub middleware.

the contributions of the paper are as follows: 1. We propose a flexible and powerful graph-based publish/subscribe language that allows users to express interest in parts of a graph.


In our case studies, we often observe that the set of nodes in the resubscription significantly overlaps with the node set of the original subscription.

a resubscription operator guarantees the continuity of not missing any publications on nodes in this intersection.


It shows that our system was able to handle the large amount of publications without stressing the computational resources of the brokers.

each row of the table contains the subscription identifier as key, the list of node identifiers covered by the subscription, the original query string in case of a graph subscription, and the client identifier of the client that submitted the subscription.


Both algorithms identify the cycle after 51 simulation steps.

our approach uses less CDMs through the cycle detection process.


Cycle detection proceeds as the CDMGraph is being constructed, i.e., with each CDM sent to a process, combined with its snapshot and, after update, sent to another process.

a CDM carries a consistent view of the fraction of the CDM-Graph already traversed by it, i.e., the processes the CDM has been sent from.


The Internet Engineering Task Force (IETF) is making a big effort for the standardization of protocols that are aware of energy and processing limitations within the smart objects.

the IETF working group for Routing Over Low-power and Lossy networks (ROLL) focuses on the design of an IPv6 Routing Protocol for Low power and lossy networks (RPL) [21].


To understand the impact of this instability on the performance of RPL, we focus on performance indicators such as the number of parent changes and the number of packets lost.

the former indicates the stability of the topology.


Once the music mood-mapping of a particular song is performed on a smartphone, it is updated in the centralized cloud database.

redundant computation of music mood for the same song across multiple smartphones is eliminated.


It is more skewed for raw configs, because most raw configs are updated by automation tools, which are counted as a single author.

some configs are updated by a large number of co-authors.


It minimizes the use of code branches that complicate maintenance.

frequent software releases increase the risk of software bugs breaking the site.


One downside of CHL is that all procedures (including internal layers inside the file system) must have explicit pre- and postconditions.


IR view changes require a leader because polling inconsistent replicas can lead to conflicting sets of operations and consensus results.

the leader must decide on a master record that replicas can then use to synchronize with each other.


Listing 2 shows the actual code for the list add() function that uses RLU.

t2 starts a critical section after the call to synchronize rcu() and hence cannot hold a reference to old data.


The key for correctness is to ensure that RLU protected sections always execute on a consistent memory view (snapshot).

an RLU protected section must be resistant to possible concurrent overwrites of objects that it currently reads.


This modification of the global clock using a single operation has the effect of making all the logged changes take effect at the same time.

if RCU uses a single read-modify-write to switch a pointer to one copy, in RLU the single read-modify-write of the clock switches multiple object copies at once.


We believe that if one would convert Kyoto to RCU by using the per slot locks for synchronization of writers (like we did), it would provide the same performance as with RLU.

it is not clear how to even begin to convert those update operations to use RCU.