Definition, implementation and validation of energy code smells: an exploratory study on an embedded system

Optimizing software in terms of energy efficiency is one of the challenges that both research and industry will have to face in the next few years.We consider energy efficiency as a software product quality characteristic, to be improved through the refactoring of appropriate code pattern: the aim of this work is identifying those code patterns, hereby defined as Energy Code Smells, that might increase the impact of software over power consumption. For our purposes, we perform an experiment consisting in the execution of several code patterns on an embedded system. These code patterns are executed in two versions: the first one contains a code issue that could negatively impact power consumption, the other one is refactored removing the issue. We measure the power consumption of the embedded device during the execution of each code pattern. We also track the execution time to investigate whether Energy Code Smells are also Performance Smells. Our results show that some Energy Code Smells actually have an impact over power consumption in the magnitude order of micro Watts. Moreover, those Smells did not introduce a performance decreas

Energy Complexity for Sorting Algorithms in Java

This study extends the concept of time complexity to energy, i.e., energy complexity, by showing a strong correlation between time complexity and energy consumption for sorting algorithms: Bubble Sort, Counting Sort, Merge Sort and Quick Sort, written in Java and run on single kernels. We investigate the correlation between wall time and time complexity, as well as the correlation between energy consumption and wall time. The primary finding is that time complexity can be used as a guideline to estimate the energy consumption of O(n*n), O(nlog(n)) and O(n + k) sorting algorithms. The secondary finding is that the inputs producing the theoretical worst cases for Merge Sort and Bubble Sort did not produce the worst case wall time nor the worst case energy consumption

Towards an energy aware DBMS: energy consumptions of sorting and join algorithms

Database management systems comprise various algorithms for efficiently retrieving and managing data. Typically, algorithm efficiency or performance is correlated with execution speed. However, the uptime of battery powered mobile- and embedded systems strongly depends on the energy consumption of the involved components. This paper reports our results concerning the energy consumption of different implementations of sorting and join algorithms. We demonstrate that high performance algorithms often require more energy than slower ones. Furthermore, we show that dynamically exchanging algorithms at runtime results in a better throughput

Software-sorted geographies.

This paper explores the central role of computerized code in shaping the social and geographical politics of inequality in advanced societies. The central argument is that, while such processes are necessarily multifaceted, multiscaled, complex and ambivalent, a great variety of ‘software-sorting’ techniques is now being widely applied in efforts to try to separate privileged and marginalized groups and places across a wide range of sectors and domains. This paper’s central demonstration is that the overwhelming bulk of software-sorting applications is closely associated with broader transformations from Keynesian to neoliberal service regimes. To illustrate such processes of software-sorting, the paper analyses recent research addressing three examples of software-sorting in practice. These address physical and electronic mobility systems, online geographical information systems (GIS), and face-recognition closed circuit television (CCTV) systems covering city streets. The paper finishes by identifying theoretical, research and policy implications of the diffusion of software-sorted geographies within which computerized code continually orchestrates inequalities through technological systems embedded within urban environments

PowTrAn: An R Package for power trace analysis

Energy efficiency is an increasingly important non-functional property of software, especially when it runs on mobile or IoT devices. An engineering approach demands a reliable measurement of energy consumption of software while performing computational tasks. In this paper, we describe PowTrAn, an R package supporting the analysis of the power traces of a device executing software tasks. The tool analyzes traces with embedded markers, a non-invasive technique that enables gauging software efficiency based on the energy consumed by the whole device. The package effectively handles large power traces, detects work units, and computes correct energy measures, even in noisy conditions, such as those caused by multiple processes working simultaneously. PowTrAn was validated on applications in realistic conditions and multiple hardware configurations. PowTrAn also provides data visualization that helps the user to assess the measurement consistency, and it also helps to highlight possible energy outliers

Nurturing Agribusiness: A Sustainable Farming System for Tomato Crop Management Leveraging Machine Learning

The agriculture industry is undergoing a transformative shift with the introduction of IoT technology, enabling global connectivity for farmers. This technology offers a plethora of advantages, ranging from precise seed selection based on soil analysis to efficient crop maintenance, water management, and enhanced marketing support for improved profitability. To further enhance tomato farming practices, we propose the implementation of a smart farmer marketing assistant that streamlines the process of segregating yield based on its growth stage, reducing labor and time requirements.Further, the frame work is capable of early-disease management system that can detect  diseases like early blight,light blight, buck eye rot and anthranose and suggest remedy.  By adopting this innovative approach, financial losses associated with traditional methods are minimized.The traditional practice of combining all categories of vegetables (ripened, unripened, and partially rotten) in a single container often results in reduced shelf life for the produce. In our framework, we employ color sorting to categorize the vegetables, ensuring proper packing into their respective bins. This valuable data is made accessible through a cloud environment, providing potential buyers with comprehensive information about the yield, its category, and pricing. This increased visibility empowers farmers to reach a global market and sell their produce at competitive prices. In this context, we present a case study focused on the tomato crop, where we have successfully developed a prototype utilizing ESP32, a color sensor, and Google Firebase. This comprehensive framework effectively harnesses the power of IoT, Machine Learning, and potential marketing strategies, transforming the way farmers manage their crops and connect with buyers on a global scale with highly accurate 87.9% experimental results

Performance Evaluation of Sorting Algorithms in Raspberry Pi and Personal Computer

Nowadays, more and more data is going to be collected. Most of the collected data must be sorted to be analysed. Thus it is important to use efficient algorithms to save time and energy. This is especially important for battery-operated devices that collect and sort data directly. The lifetime of the battery can be remarkably extended by choosing effective sorting algorithms. Furthermore, processors with lower clock frequencies can be used, leading to lower battery consumption. This thesis focuses on the time complexity of algorithms (bubble sort, insertion sort, quick sort and heap sort) executed on raspberry Pi and personal computer. In this thesis, a client and a server have been implemented. The client is a Graphical User Interface (GUI) that generates random numbers, which are sent to the server. On the server the random numbers are sorted and the sorting time is measured. After sorting, the random numbers will be sent back to the client where they are displayed on the GUI. The sorting time is also send to the GUI in order to display it. It is to mention that the time consumption is measured with timing functions of the C library. An oscilloscope has been used to check if the timing function works properly. At the end, the performances of four sorting algorithms on Raspberry Pi and on the Personal Computer (PC) are compared.fi=Opinnäytetyö kokotekstinä PDF-muodossa.|en=Thesis fulltext in PDF format.|sv=Lärdomsprov tillgängligt som fulltext i PDF-format