The Internet of Things is gaining traction for sensing and monitoring outdoor environments such as water bodies, forests, or agricultural lands. Sustainable deployment of sensors for environmental sampling is a challenging task because of the spatial and temporal variation of the environmental attributes to be monitored, the lack of the infrastructure to power the sensors for uninterrupted monitoring, and the large continuous target environment despite the sparse and limited sampling locations. In this paper, we present an environment monitoring framework that deploys a network of sensors and gateways connected through low-power, long-range networking to perform reliable data collection. The three objectives correspond to the optimization of information quality, communication capacity, and sustainability. Therefore, the proposed environment monitoring framework consists of three main components: (i) to maximize the information collected, we propose an optimal sensor placement method based on QR decomposition that deploys sensors at information-and communication-critical locations; (ii) to facilitate the transfer of big streaming data and alleviate the network bottleneck caused by low bandwidth, we develop a gateway configuration method with the aim to reduce the deployment and communication costs; and (iii) to allow sustainable environmental monitoring, an energy-aware optimization component is introduced. We validate our method by presenting a case study for monitoring the water quality of the Ergene River in Turkey. Detailed experiments subject to real-world data show that the proposed method is both accurate and efficient in monitoring a large environment and catching up with dynamic changes.

UML statechart diagrams are widely used in spec-ification of software behaviour. For various reasons, during statechart design process, detrimental sections can be introduced in the statechart design that has the potential adverse effects in the development lifetime of the software. This study introduces statechart design anti-patterns to give examples to some of those flawed design practices and proposes ideas to repair them.

State machine replication techniques are widely used to create fault tolerant services in cloud computing. However, reaching consensus between remote regions may take substantially long time. Many algorithms are proposed to solve this problem regarding the geographic locality of the objects while trading off some consistency properties of the system. Most of these studies consider direct replication of arbitrary parts of the system, but contemporary online services share some unique data sources that may not be replicated. This paper proposes a coordinated method to manage shared data sources between replicas by utilizing geographic locality of the data sources. The proposed algorithm present better performance than using a leader based approach in terms of request processing throughput. We provide the design and implementation of the proposed algorithm in detail and present the throughput performance of the algorithm in a geographically distributed environment.

This study presents preliminary results from a distributed checkpointing approach developed to be used with replicated state machines. Our approach takes advantage from splitting and storing partial execution history of the master state machine in a distributed way. Our initial results show that using such an approach provides less memory consumption for both the running replicas and the restoring replica in case of a failure. On the other hand for larger histories and larger number of replicas it also increases the restore duration as a major drawback.

Two-Phase commit (2PC) is a distributed algorithm where a process which wishes to make a commit on a service first needs to make sure that the participating peers are ready for the commit operation. In our study we enhance 2PC for replicated state machine environments by early aborting the state executions of a state machine in case a higher priority state machine checks to commit a value to be written. By applying our approach, when the number of replicas goes beyond 3 our approach wastes significantly less state executions compared to classical 2PC.

https://doi.org/10.5220/0006691604260431

In this study we dig for scrum application practices in distributed offshore development teams of a multinational company which has in-source offshore development centers across the world. Main location of the research is the Turkey center of the company.

As the devices that make up the Internet become more powerful, algorithms that orchestrate cloud systems are on the verge of putting more responsibility for computation and storage on these devices. In our current age of Big Data, dissemination and storage of data across end cloud devices is becoming a prominent problem subject to this expansion. In this paper, we propose a distributed data dissemination approach that relies on dynamic creation/replacement/removal of replicas guided by continuous monitoring of data requests coming from edge nodes of the underlying network. Our algorithm exploits geographical locality of data during the dissemination process due to the plenitude of common data requests that stem from the clients within a close proximity. Our results using both real-world and synthetic data demonstrate that a decentralized replica placement approach provides significant cost benefits compared to client side caching that is widely used in traditional distributed systems.

Web services are commonly used in the communication of software over the web. To fully trust a web service, it should be tested and certified, but testing of web services provoke new challenges. Behavior-Driven Development (BDD) can be applied to the testing of web services. Gherkin language is used to define scenarios in BDD. We used Gherkin language to define test cases for web services and we developed a tool to convert these test cases into JMeter test scripts.

Security concerns are still retarding cloud adoption. While the research community work on clearing these concerns, an optimistic fair cloud compliant logging scheme may ease the cloud to spread. This study proposes a secure logging mechanism. The mechanism employs an online bulletin board as a public write‐only storage for the log records. The bulletin board also acts as a trusted third party during conflict resolution. The secure logging protocol describes how the log records are distributed to the stakeholders. The protocol's security is verified with model checking tools and no security threats could be found.

Federated clouds and cloud brokering allow migration of virtual machines across clouds and even deployment of cooperating VMs in different cloud data centers. In order to fully benefit from these new opportunities, we propose a heuristic that outputs a matching between virtual machine and cloud data centers by taking resource capacities, VM topologies, performance and resource costs into account. Results of our initial evaluation using the CloudSim Framework indicate that, proposed heuristic is promising for a better optimized placement of networked VM groups onto the federated cloud topology.

https://doi.org/10.5220/0005439101130118

Application placement is an important concept when providing software as a service in cloud environments. Because of the potential downtime cost of application migration, most of the time additional resource acquisition is preferred over migrating the applications residing in the virtual machines (VMs). This situation results in under-utilized resources. To overcome this problem static/dynamic estimations on the resource requirements of VMs and/or applications can be performed. A simpler strategy is using heuristics during application placement process instead of naively applying greedy strategies like round-robin. In this paper, we propose a number of novel heuristics and compare them with round robin placement strategy and a few proposed placement heuristics in the literature to explore the performance of heuristics in application placement problem. Our focus is to better utilize the resources offered by the cloud environment and at the same time minimize the number of application migrations. Our results indicate that an application heuristic that relies on the difference between the maximum and minimum utilization rates of the resources not only outperforms other application placement approaches but also significantly improves the conventional approaches present in the literature.

Resource utilization problem has been widely studied for cloud systems where a number of virtualized resources are shared among applications hosted as services. Resource utilization optimization can be confronted at two levels: allocating resources to virtual machines(VM) across physical machines or assigning applications to virtual machines present in the host. With the improving capabilities on virtualization technologies, realizing resource allocation at both levels is becoming more viable using VM reconfiguration and live-migration of applications. In this paper we investigate applying resource allocation optimization at these two levels and the emerging trade-off in deciding the appropriate technique to be used. We first analyze the effect of gradually increasing the amount of resources assigned to a virtual machine using VM reconfiguration and compare our results with fully assigning host's resources without reconfiguration. Later, we investigate the amount of utilization revenue when application live-migration is used for applications having smaller/larger performance needs. Finally, we compare the host utilization for different amounts of cost rates between live-migration and reconfiguration. Consequently our analysis results identify the cost rate and application granularity levels where it is optimal to apply live-migration or VM reconfiguration.

Software as a Service(SaaS) solutions are state-of-the-art advancement of the cloud computing technologies that bring on new challenges in terms of cloud system management. It is the usual case where user jobs(macros, scripts, programs, etc.) are executed as threads inside platform processes making the distinction between user jobs very hard to perform. In case of a problematic thread(such as a thread with memory leakage) system administrator needs to manually detect the problematic thread or even kill the entire process harming the rest of the user jobs in the process. In this paper, we propose a novel approach based on processing the memory footprint of the problematic process. We use Fourier analysis to calculate the energy spectral densities of the memory footprints where threads with different characteristics produce different densities in case of a memory leakage. We represent a thread's memory usage characteristic as a periodic signal with a memory consumption frequency and a unit memory consumption amount. Our results show that for a process involving two threads, it is possible to distinguish the problematic thread by observing the memory footprint's energy density after the anomaly begins. We further investigate our results to relate the thread parameters with the difference between energy densities and derive guidelines on identifying the specific thread causing the problem. As a result we found out that certain thresholds exist for unit memory consumption to be able to identify the problematic thread and also the decomposability of the memory footprint has an exponential relation with the rate of memory consumption frequencies of process' threads.

Leveraging utilization of the shared caches of multicore processors is one of the heavily studied topics of today's chip multiprocessing community. Providing a scheduling mechanism that maximizes throughput by reducing miss-rates of shared caches and preserves the fairness of processor usage is in the center of this problem. Proposed scheduling algorithms in this field usually take advantage of thread level properties of software providing modifications at operating system level. In our study we choose to approach the problem from a different perspective and use software models to guide operating system to effectively map software's objects onto processor cores. In an object oriented software objects collaborate on fulfilling jobs and they may operate on common data. Our scheduling method takes class dependencies into account and tries to schedule objects of coupled classes onto cores that share the common cache. This paper presents case studies on implementations of three software design patterns(Strategy, Visitor and Observer) and an image filtering software implementation. During our experiments we use our cache-aware scheduler in guiding Linux's completely fair scheduler (CFS) to perform more cache-aware schedules and decrease running time around 10%.. Our results promise that guiding/restricting operating system's scheduler using class-relational information present in the object oriented software model can be fruitful in increasing software performance on multicore processors.