{"id":10860,"date":"2023-09-14T10:47:38","date_gmt":"2023-09-14T08:47:38","guid":{"rendered":"https:\/\/www.iese.fraunhofer.de\/blog\/?p=10860"},"modified":"2024-02-19T12:30:40","modified_gmt":"2024-02-19T11:30:40","slug":"smartness-in-software-based-systems","status":"publish","type":"post","link":"https:\/\/www.iese.fraunhofer.de\/blog\/smartness-in-software-based-systems\/","title":{"rendered":"The Pursuit of Smartness in Software-based Systems"},"content":{"rendered":"

In this Fraunhofer IESE <\/a>blog post series, we will explore the pursuit of smartness in software-based systems. In this initial post, we will discuss the concept of „smart“ within this context, pinpoint what lies at the heart of smart-based systems, and illustrate why context awareness enables smartness in such systems.<\/p>\n

What qualifies someone (or something) as \u201csmart\u201d? General definitions of the word \u201csmart\u201d include \u201chaving or showing a high degree of mental ability\u201d [1], \u201cintelligent, or able to think quickly or intelligently in difficult situations\u201d [2], and \u201cquick at learning and understanding things; showing this ability\u201d [3]. Interestingly, the Oxford Learner\u2019s Dictionary also provides an additional definition that is specific when the adjective is applied to devices: In such cases, smart would mean computer-controlled<\/em> (\u201ccontrolled by a computer, so that it appears to act in an intelligent way\u201d [3]).<\/p>\n

Computer-controlled devices have been around for decades now; however, not all computer-controlled devices have been called \u201csmart\u201d. Consider, for instance, the term smartphone<\/em>. It was coined in the late 1990s to refer to a new type of device that, although primarily intended to work as a regular phone, came with additional capabilities such as Internet connection, e-mail, calendar, and web browsing. Back then, these<\/em> things qualified a phone as smart<\/em>. Note, however, that mobile phones preceding the smartphone era were already computer-controlled (for example, the Nokia 3310), but were not perceived (nor branded) as smart.<\/p>\n

While this example illustrates how the word \u201csmart\u201d has been used loosely in industry, in academia a more specific meaning is observed: Research on smart systems has been historically related to the development of Artificial Intelligence, for intelligence \u2013 be it artificial or not \u2013 underpins smartness, in a stricter sense.<\/p>\n

Smartness in domains, devices, and applications<\/strong><\/h2>\n

Nowadays, the word \u201csmart\u201d seems to indicate what everyone yearns for in terms of software-based systems. Let\u2019s organize it in three levels: At the highest level of abstraction, there are smart domains; at the lowest, smart devices. We argue that between these two extremes and forming the core of smartness in software-based systems are smart applications.<\/p>\n

Smart domains<\/strong><\/h3>\n

It is not difficult to find industries where there are movements towards enabling smartness<\/em>. Industry players and researchers alike want agriculture to be smart agriculture<\/em>, they want manufacturing to become smart manufacturing<\/em>, they want health improved towards smart health<\/em>. The same holds true for mobility, cities, energy, construction, or government, to name but a few examples. Frequently, smart domains describe software infrastructures that enable the collection, processing, and distribution of data, which provides the basis needed for the development of smart applications. In other words, a smart domain is not smart in a strict sense, but it creates the conditions for (data-driven) smartness to flourish through smart applications.<\/p>\n

Smart devices<\/strong><\/h3>\n

At the other end of the spectrum, we could consider the device level as the lowest level. Internet of Things (IoT) developments have given rise to what has been called smart devices<\/em>, usually for their networking and data collection capabilities. In a house, for example, there may be several smart devices, outlets, door locks, lightbulbs, and appliances. What characterizes such a house? First, the digital character of some of its constituent elements; next, the fact that these elements are connected, i.e., that they have the ability to exchange data; finally, the ability to provide a basis for smart applications<\/em> working together to enable usage scenarios that we may refer to as use cases of a smart device<\/em>.<\/em><\/p>\n

One may argue whether labeling something as smart isn\u2019t just a marketing decision rather than an expression of a well-defined feature. Is a door lock really \u201csmart\u201d just because it has an Internet connection and receives a signal to open or close? Similar to smart domains, smart devices act as enablers for the development of smart applications. In other words, what makes a software-based system smart, in a strict sense, is the development of smartness at the application level.<\/p>\n

Defining smartness in applications<\/strong><\/h2>\n

After taking a look at definitions of smartness at the domain level and at the device level, let\u2019s consider what is at the core: the application level.<\/p>\n

Applications are expected to be designed to support user tasks, and such support can be achieved in different ways. For example, it is possible to conceive of an application that provides the user with all the functionalities they need, but packs it in an awful user experience. Users want applications that not only work, but that work well. Users want applications that not only deliver the expected functionalities, but that also surprise them positively. As a matter of fact, industry players want to exceed their user\u2019s expectations in order to keep up with the competition. One way to achieve this is to add intelligent behavior to applications \u2013 in other words, to turn applications into smart applications.<\/p>\n

Another aspect to be taken into consideration refers to when<\/em> the term \u201csmart\u201d is applied to a certain entity: What may have been considered smart then<\/em> is no longer regarded as smart now<\/em>. Anyway, independent of the level of abstraction and the time, the decision to add the term \u201csmart\u201d to a certain entity seems to be bound to exceeding expectations<\/em>. This was true when the term \u201csmartphone\u201d was coined, is still valid today, and reflects the maturity levels of perceived smartness in applications.<\/p>\n

A well-known model for framing user expectations is the Kano Model [4]. In general lines, the model says that there are three types of functionalities. The first (and most obvious) are satisfiers<\/em>: These are functionalities explicitly<\/em> expected by users, which they know they want, and which therefore make them feel satisfied when found to be working properly. The second type is called dissatisfiers<\/em>: These are functionalities implicitly<\/em> expected by users, therefore not always declared. If these functionalities are found in the system, they may not be noted at all; however, if they are not put into the system, their absence will, in fact, be noted and cause dissatisfaction. Last but not least, the third type of functionality is called delighters<\/em>: These are functionalities that users expect neither explicitly nor implicitly in a system; if they are not put into the system, one will barely miss them; however, once they are implemented and delivered to users, these functionalities cause the so-called \u201cwow effect\u201d on them. One has to note that expectations change over time, and the delighters of yesterday are the dissatisfiers of the future. Consider, for example, touchscreen capabilities in smartphones: When Apple introduced the iPhone in 2007, scrolling over a list with a finger gesture caused a sound \u201cwoooow!\u201d<\/a> in the audience (delighter), but 15 years later, touchscreens with gesture recognition are more than trivial in the smartphone arena (dissatisfier).<\/p>\n

Interestingly, while the expectations regarding a device may be fulfilled by connection capabilities and data exchange, in applications these things are commodities nowadays, and smartness calls for more. Taking up the dictionary definitions: for smart applications, it is not just about being computer-controlled, but about showing intelligent behavior.<\/strong><\/p>\n

Context awareness as an expression of smartness<\/strong><\/h2>\n

One representative class of delighters are context-aware functionalities<\/em>. Context-aware functionalities are functionalities that take context into consideration to produce a certain system behavior, typically an adaptation or a recommendation. By means of sensing the context of the interaction between the user and the system, a context-aware system is able to change its behavior as needed by the user, but without the need for explicit input from the user<\/em>.<\/p>\n

Although \u201ccontext awareness\u201d is not a well-known term among end users and even practitioners, research in the field has been intensive for decades now. This idea is well summarized in the following quotation from researchers Pinheiro and Souveyet [5]:<\/p>\n

Before being considered as context-aware, applications such as those [\u2026] can be seen by consumers and non-expert designers as \u2018smart\u2019 applications, since they propose what can be perceived as an \u2018intelligent\u2019 behavior with data collected from the environment. Indeed, being able to observe the physical environment, to dynamically adapt its behavior without any human intervention are behaviors commonly perceived as \u2018intelligent\u2019 (or \u2018smart\u2019) by consumers.<\/p><\/blockquote>\n

Analytical research work on what characterizes a software-based system as smart also points to context awareness. In a recent study [6], researchers concluded that smart systems are characterized by communication (i.e., data exchange) capability, embedded knowledge, learning capability, reasoning capability, perception capability, and control capability. And, as a result of the interaction of these characteristics, context awareness appears as an emerging property of smart systems<\/em>.<\/p>\n

Context awareness in practice<\/strong><\/h2>\n

There are plenty of examples of context-aware functionalities in the software-based systems most of us use every day:<\/p>\n