Lisa Roux
email: eroux@iutbayonne.univ-pau.fr

Thierry Nodenot
email: thierry.nodenot@iutbayonne.univ-pau.fr

Patrick Etcheverry
email: patrick.etcheverry@iutbayonne.univ-pau.fr

A Classification Approach to Recognize On-Task Student's Behavior for Context Aware Recommendations

Keywords: Learner behaviour model, E-learning, Supervised Classification, Recommender Systems

The increasing development of e-learning systems has raised the necessity to apply recommender systems with the aim of guiding learners through the various courses, activities, etc. at their disposal. The learner-oriented approaches allow the recommendations to fit the user's needs as precisely as possible. Nevertheless, due to the multiplicity of possible educational situations and individual particularities, offering adaptive recommendations and diversity is still a major challenge. In order to improve this aspect and provide the learner with recommendations appropriate to both their current specific needs and general profile, we focus on an hybrid system whose knowledge will be augmented through the learner's activity and results. This system will base its analyses and future recommendations according to the evolving student's profile and behaviour during the task. For that purpose, a first step is to categorize the on-task student's behaviour. This paper focuses on this problem and proposes a model, provided by educational sciences, on which the recognition process could be based.

Introduction

In recommender systems (RS), two important components need to be considered: the users and the items. The main challenge is to recommend a short selection of appropriate items (i.e. items that fit the user's needs or interests) to a given user, in order to help them to choose from a wide variety of items. In e-learning, the recommendation is mostly based on the content of the items and the collected data that describes the online user's behaviour. Providing the learner with appropriate learning recommendations is a major challenge, since each learner has specific needs and way of learning, depending on their own interests and cognitive involvement, and the learning situation.

In order to provide personalized recommendations taking into account the evolution of the on-task learner's behaviour, we propose in this paper a learner model relying on educational sciences and aiming at describing the cognitive strategies of a learner during a problem-solving activity. This learner model is part of a RS architecture that we detailed in [START_REF] Roux | A Multi-layer architecture for an e-learning hybrid recommender system[END_REF]. The learner model presented in this study has been chosen for its genericity: it is expected that it can be trained and used for any problem-based learning [START_REF] Wood | Problem based learning[END_REF] in practicum-centered situations (i.e. practical exercises, projects) [START_REF] Gary | Project-based learning[END_REF]. Each situation is described as a series of tasks through the guidelines provided to the students, a work environment with the suitable software so that the students can perform the task and possibly collaborate, a set of resources (e.g. numerical documents, work files produced by the students), success criteria for each task, an available support through a LMS comprising aids, resources, tips, components for a solution, course supplements, etc.

This paper focuses on the student's current behaviour classification and is organized as follows: related works on recommendation approaches and e-learning RS is given in Section 2; after having described the cognitive model on which the proposed solution is based and the overall functioning of this solution, Section 3 show the first results that we obtained; Section 4 outlines conclusions of this study.

2

Related works E-commerce RS are mostly based on matrix factorization [START_REF] Bell | Matrix factorization techniques for recommender systems[END_REF]. A matrix of n users and m items is used to represent the data on which the calculations will be done, each matrix cell corresponding to the rating given to item i by the user u. Collaborative and contentbased filtering are widely used methods because they are both efficient and easy to implement, but the knowledge based filtering and hybrid approaches can also be employed. The education RS are based on the same filtering methods in a variety of approaches, from matrix factorization (e.g. [START_REF] Thai-Nghe | Predicting Student Performance in an Intelligent Tutoring System[END_REF][START_REF] Salehi | Application of implicit and explicit attribute based collaborative filtering and BIDE for learning resource recommendation[END_REF]) to complex classification methods, such as fuzzy-tree [START_REF] Wu | A Fuzzy Tree Matching-Based Personalized E-Learning Recommender System[END_REF], convolutional neural networks [START_REF] Shu | A content-based recommendation algorithm for learning resources[END_REF], neuro-fuzzy technics [START_REF] Sevarac | Adaptive neuro-fuzzy pedagogical recommender[END_REF][START_REF] Kinshuk | Adaptive tutoring in business education using fuzzy backpropagation approach[END_REF], etc. In some works, deep attention has been paid to allow the teacher to implement their own rules [START_REF] Sevarac | Adaptive neuro-fuzzy pedagogical recommender[END_REF]. When used, the learner model is mostly based on their knowledge background [START_REF] Sevarac | Adaptive neuro-fuzzy pedagogical recommender[END_REF], learning objectives, past activities [START_REF] Khribi | Automatic Recommendations for E-Learning Personalization Based on Web Usage Mining Techniques and Information Retrieval[END_REF], learning style [START_REF] Qomariyah | Recommender System for e-Learning based on Personal Learning Style[END_REF], knowledge level, and sometimes several of them [START_REF] Wu | A Fuzzy Tree Matching-Based Personalized E-Learning Recommender System[END_REF][START_REF] Sevarac | Adaptive neuro-fuzzy pedagogical recommender[END_REF][START_REF] Dwivedi | Effective Trust-aware E-learning Recommender System based on Learning Styles and Knowledge Levels[END_REF]. These models can be categorized as follows: the models based on the student's learning trajectory and those based on their educational needs. However, so far, it appears that none of the existing e-learning RS make recommendations based on both aspects. Moreover, using the methods of e-commerce RS in the education area raises the question of pedagogical efficiency and some ethical issues. Similarly, the selection of the learner model and the choice of basing (or not) the recommendations on a teaching model are crucial stakes that require careful attention. In accordance with the proposals that we have made in previous researches [START_REF] Roux | Recommender Systems in e-learning: axiological, epistemic, and practical implications of the designing choices[END_REF] that explored the ethical and epistemological issues of e-learning recommender systems, the learner model presented in this paper is provided by the educative sciences. It has to fulfill two requirements [START_REF] Roux | A Multi-layer architecture for an e-learning hybrid recommender system[END_REF]:

1. The classification of students must be meaningful.

2. It must be pedagogically useful and relevant.

3 Proposed solution 3.1 Description of the student's behaviour : the mode of reasoning and the degree of activity When a learner is working on a pedagogic task, they can be more or less confident, proactive, hesitating, etc. and the teacher generally takes into account the signs of ease when they want to help and guide them: they recommend to read a document, see another similar task, etc. depending on the student's needs, that is, how much they feel comfortable with the issues to be addressed during the task. However, although it is well documented that the learners' emotions when completing a task have a significant impact on their performances and stance (i.e. perseverance, dropping out) [START_REF] Pekrun | Academic emotions in students' self-regulated learning and achievement: A program of qualitative and quantitative research[END_REF][START_REF] Pekrun | Academic emotions and student engagement. Handbook of research on student engagement[END_REF], we can hardly automatically determine how they feel during the task: one's feelings are internal thus very difficult to assess for an outside observer.

In some papers, the emotion recognition is operated through various technical or technological devices (e.g. computer vision [START_REF] Bosch | Detecting student emotions in computer-enabled classrooms[END_REF][START_REF] Tonguç | Automatic recognition of student emotions from facial expressions during a lecture[END_REF]), smart cushion [START_REF] Gravina | Emotion-relevant activity recognition based on smart cushion using multi-sensor fusion[END_REF], voice recognition [START_REF] Mannepalli | Emotion recognition in speech signals using optimization based multi-SVNN classifier[END_REF]) but, since we want our system able to work with reduced hardware costs, we chose to base our system on a learner model that describes their behaviourthus on an observable learner activityand that comes from the educational sciences.

In the problem-solving activities, learners alternate between two main modes of reasoning, which are exploration and exploitation.

Exploration: This strategy aims at experimenting with new alternatives or at acting on the environment in order to generate new stimuli [START_REF] March | Exploration and exploitation in organizational learning[END_REF]. In our experiments, we expect that the learners undertake manipulative actions on tools, environment, available objects, etc., trying and testing different combinations.

Exploitation: This strategy consists in the use of existing knowledge (declarative, procedural) in a given situation. It aims to use it in order to build hypotheses, ideas, and strategies to suit the problem-situation they meet, then get involved in a reality-check.

In our experiments, we expect that the learners test their hypotheses/approaches (e.g. their specifications) so that they can validate them or not.

The relationship between the exploitation of old certainties and the exploration of new possibilities is a central concern of studies in adaptive processes [START_REF] March | Exploration and exploitation in organizational learning[END_REF]. Sometimes learners have to take time to exploit existing knowledge, but they also may have to explore the situation in different ways in order to handle and test the various means at their disposal, so that they can develop new knowledge then raise new solutions [START_REF] Axtell | Shopfloor innovation: Facilitating the suggestion and implementation of ideas[END_REF].

There are two main advantages coming from this model. First, although there can be ambiguous situations difficult to categorize, there are easily observable practice patterns that allow a good class definition for machine learning. Moreover, these behaviours, although objectively observable, can be an expression of the students' ease during the task. For example, whether a learner continues to use the exploitation problemsolving strategy while facing difficulties that they fail to overcome, one possible explanation might be that they lack confidence in exploring new insights, new ways of using the available tools, etc. On the contrary, a learner who would keep trying to explore without success could lack both theoretical and practical knowledge about the environment or the tools. In the former situation, the learner could be encouraged to perform easy tasks in order to build confidence, while in the latter, they could be advised to strengthen the knowledge and skills necessary to complete the task in order to build appropriate hypotheses. In this way, appropriate recommendations can be made to the student, based on the history of their modes of reasoning during the current task, combined with two other information: the amount of time they stay in the same mode and the degree of difficulty encountered. The latter is calculated through a questionnaire.

Learning steps

Our system requires two intertwined learning steps: the former to determine the classification rules of the student's current reasoning mode, the latter to define the function used to identify their current activity level given their reasoning mode. We composed six indicators, which have been selected because they fulfil three requirements: 1. They can be obtained by aggregating data describing the mouse and keyboard actions of the student 2. They have to participate to describe both the student's current reasoning mode and activity degree 3. They have to be generic (independent to the task), because the final recommender system is expected to work for any problem-solving task.

In our proposal, the student's behaviour is decribed by a 7-dimensional vector :

Frequency of document shift: This indicator shows whether the student regularly shifts back and forth across the available pedagogical and work documents. It is the average of the number of times the student has launched or clicked on another document than the active one in five minutes.

Frequency of the work verification: This indicator shows whether the student regularly checks the validity of their work. In the case of a programming task, it is calculated by dividing the number of times the student has launched the compilation operation by the number of complete structures in their program. This is an optional indicator, since not all software programs can offer such a functionality Rate of activity: This indicator assesses whether the student intensively uses the keyboard and the mouse (e.g. clicking, rolling the mouse wheel, using the scrollbar), in comparison with the average students' rate of activity (number of actions per minute).

Rate of writing: It indicates how much the student writes, on average, in comparison with the average students' rate of writing (number of written character per minute).

Frequency of erasure: This assesses the student's certainty about what they write. It is defined as the number of times the student presses an erase-key per minute.

Rate of the working document elasticity: This information is described by two indicators. The frequency of erasure is insufficient to evaluate adequately the student's production progress. Indeed, when we detect that they have pressed an erase-key, we do not know whether they have erased only one character or a bigger selected extract of the text. This indicator reflects the degree of variability of the size of the working document 𝑆 𝑖 . 𝑆 𝑖 is measured at regular time intervals (30 sec). The indicators are calculated as follows, based on the average size of a document and its standard deviation :

m = ∑ |𝑆 𝑖 -𝑆 𝑖-1 | 𝑛 𝑖=1 𝑡 ( 1
)
𝑅 𝑒 = ∑ | |𝑆 𝑖 -𝑆 𝑖-1 | 𝑡 𝑖 -𝑡 𝑖-1 -𝑚| 𝑛 𝑖=1 × 𝑡 𝑖 -𝑡 𝑖-1 𝑛 (2)

Classification and evaluation

Data collection ranges from the acquisition, at runtime, of the different sources of traces (collection per student's workstation) to the gathering of these traces into an objectmodel that can further be exploited (queries, mining). At the end of that process, described in [START_REF] Roux | Supervised classifications and process to detect exploitation and exploration student's behaviours in higher vocational Education[END_REF], in average 500 macro-interactions per student were collected. We obtained the archives of 60 students' actions. In order to classify them, we labelled manually these data, by watching the 60 students working on a programing task. Several classification strategies have been investigated in our work. Since the student's activity depends on their current problem-solving strategy, we considered the cascade hybridization method, which performs the problem-solving strategy classification followed by a regression of the activity.

Concerning the classification step, due to the specificities of our data sample (i.e. small, based on surveys carried out by human observers), only classification methods that can be applied on small samples and robust to noisy measurements may be used. For the first step, which consists in classifying the data into two classes (i.e. exploitation and exploration), three different classification methods were therefore considered: Random Forrest (RF), Naïve Bayes (NB), KNeighbors (KNN). Indeed, KNN is mostly used for small samples with few explanatory variables, since the algorithm speed slows as the number of observations increases and the results are less accurate with many characteristics. NB does not require huge amount of data neither, and is not sensitive to irrelevant characteristics. Although it is efficient on large dataset, RF can also deal with little ones. Moreover, it reduces overfitting, which is particularly harmful for noisy datasets. We used 75% of the original dataset to train the model and 25% to test it. Due to the scattered data distribution, we used KNN with k=2,3,4,5. We calculated the error rate, which computes how much items are wrongly classified among the testing data set, and the f1-score for each classification. The results are reported in fig. 1 and show that the classification is better when k=3. Basically, the f1-score is the harmonic mean between precision and recall [START_REF] Salton | Introduction to Modern Information Retrieval[END_REF][START_REF] Van Rijsbergen | Information Retrieval[END_REF], which are respectively how many of a class is found over the whole number of elements of this class and how many are correctly classified among that class: We compared the results by using those three classification methods, that is 3-NN, RF, NB. As Figure 2 shows, results are better with 3-NN, although they look quite satisfying in RF and NB, with a quite little error rate. In order to confirm these observations, we used SHAP, which is a game theoretic approach to explain the output of any machine learning model. It connects optimal credit allocation with local explanations using the classic Shapley values from game theory and their related extensions [START_REF] Strumbelj | Explaining prediction models and individual predictions with feature contributions[END_REF]. The results obtained using SHAP shed new light on these first results. Fig. 3 shows that the characteristics used to classify data are not really decisive for 3-NN, whereas the distinction of classes based on the same characteristics seem relevant for RF (fig. 4). The classification provided by NB does not appear to be very conclusive (fig. 5), since the characteristics seem not discriminating, except for a very reduced number of individuals. All these results lead us to think that our model is quite promising, especially using 3-NN and RF, but has to be enhanced, notably through improvements to the dataset, in particular by increasing the number of observations, and testing classifications using multiple versions of our existing characteristics. Indeed, we can use some descriptors that, although repetitive, will describe data from different perspectives. Then, an important task will be to select the most appropriate information. For example, in these first tests, the calculation of the working document elasticity is based on the number of lines of the work document. Yet, this information can be expressed in bytes, number of words, number of lines, number of meaningful blocks (e.g. in the context of a programming task, in could be a variable declaration, a condition block, a function).

Although we have the intuition that the number of meaningful blocks would be more significant, we have to ensure our hypothesis through some data feature selection methods. Similarly, the student's activity can be expressed in either an atomic (e.g. clicks, rolling, writing a character) or a larger level with meaningful actions (e.g. document shift, move in the document, sequence writing).

Conclusion and perspectives

In this article, we proposed an approach to recognize a learner's behaviour during a task. It is based on a student model that comes from the educational sciences. In relation with this model, we presented the characteristics used to describe and classify the learner's behaviour and applied three different classification methods (K-NN, Random Forest, Naïve Bayes) to examine whether the chosen model and characteristics can provide a sound foundation for classifying the students' behaviours and recognize them. The results are quite encouraging, but the datasets are still very small and other tests have to be performed with larger ones. Thus the next step is to collect vast amounts of data.

For that purpose, an automatic labelling tool appears to be necessary, since manual categorization is extremely time-consuming. Our idea is to ask the learners to answer, each 15 minutes, a little questionnaire of five questions. The automatic labelling will be based on their replies. In this way, once we have collected enough data, we will be able to select the most appropriate classification method and the definitive characteristics. Indeed, combined with our process of automatic collection and fusion of traces, this labelling tool will contribute to feed our recommender system with rich and numerous traces of students. By processing the keyboard and mouse actions of the students, features of their professional gestures, indicators on the content of the files that they have produced or modified, etc., we think that we can aim for a classification, then a RS intelligible for the teacher and their students. The coming months will allow us to confirm these ambitions and first results, firstly for programming task. Then we will extend our range by applying these methods for students of others educational fields involved in problem-solving situations and working on specific software.

Fig. 1

 1 Fig.1 Evaluation of k-NN classification with k=2,3,4,5

Fig. 2

 2 Fig.2 Evaluation of 3-NN, RF, and NB classifications

FigFig 4 .

 4 Fig 3. SHAP on 3-NN classification


Bernard Kaddour
email: bkaddour@liris.cnrs.frjq@lirmm.fr

Joël Quinqueton

Proposal for compilation techniques of monitoring tasks to improve applications management performance

The emergence of middleware solutions and new services, even on small devices, will need adapted distributed management solutions which address these specificities, both in terms of software design and in terms of performance. We propose a management system where these high-level and low-level management concerns are separated. In particular for JAVA based solutions, we suggest a low-level management agent tightly tied to the JVM/JVMTI and able to receive and to manipulate programmable monitoring expressions. To avoid conflicts with applications already using JVMTI instrumentation techniques, we dynamically compile these expressions into machine code to reduce overload and minimize performance lost.

Introduction

Since some years, more and more smart phones or personal digital assistants are widely available and used. These small devices still suffer from some limitations compared with high end fixed terminals, for example lower CPU performance or smaller memory size, but even now days they already have enough processing capabilities to host complete high Operating Systems -either Windows or Linux dedicated versions -and they appear more and more as autonomous embedded systems. Meanwhile, industrially accepted middleware solutions appear [START_REF] Ejb | Entreprise JavaBeans Specifications version 2[END_REF] [START_REF] Omg | [END_REF] for new distributed applications. These middleware are currently available for small devices [START_REF] Openccm | [END_REF] and even Multi-Agents Systems based solutions have been introduced in the research area [START_REF] Carabelea | Multi-Agent Platforms on Smart Devices: Dream or Reality ?[END_REF].

Such new distributed applications and services whose components may partially or totally be executed by small devices implies high optimizations and new flexible needs for their management to be effective.

Managing disperse heterogonous entities has already been investigated in the network community and standards defined [START_REF]Operations for Version 2 of the Simple Network Management Protocol (SNMPv2)[END_REF] [START_REF]Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2)[END_REF] but they not address software management at low-level.

We propose a management system which tries to take into account these particularities and we introduce a system where high-level and low-level management concerns are separated. The high-level management part relies on messages interception mechanisms which, coupled with Aspects Oriented Programming [START_REF] Kiczales | Aspect oriented Programming[END_REF] concepts, provides facilities for management activities to dynamically operate, enhance and manage JAVA based applications transparently. The low-level management part introduces and uses programmable monitoring tasks tightly related to the code of the managed JAVA entities and is concerned by performance optimization aspect. Importance of performance for management has already been depicted [START_REF] Martin-Flatin | Web-based management of IP networks and systems[END_REF], taking as example a manager in charge of managing hundreds of objects. The massive incoming of network services for small devices imposes to take this point into account. We introduce monitoring tasks that are compiled to minimize management impact from a performance point of view.

The high-level part is not developed here. In this article we present in section 2. the principles of our management system. The section 3. presents the low level management part and the monitoring tasks. Section 3.1. depicts interactions with the underlying JVM/JVMTI and the compilation process whereas section 3.2. presents ideas used for the code generation. We conclude with some future works and perspectives.

Overview of our management system

The high-level management part of the management system (named kernel of management system or KMS) is based upon Aspects Oriented Programming concepts and uses the AspectWertz [1] (AW) tool to provide dynamic and flexible management facilities.

Most of these facilities rely on the interception and filtering of messages exchanged by the managed application.

Management entities used by the KMS are activities. They are composed of management functions and filter functions.

When received by a KMS, either from a human administrator or from another KMS, an activity can be deployed: its management functions are executed in a dedicated environment and its embedded filters are dynamically plugged to the managed application. The KMS addresses security issues and provides services to the activities.

Activities are java .jar files, with one entry implementing the Activity class known to provide particular methods. In turn, an activity can delegate one or many monitoring tasks towards the low-level part of system. These monitoring tasks are monitoring expressions (represented as resources in an activity .jar file) which can keep a watch on the classes or objects' byte-code at run-time.

Monitoring expressions

Monitoring expressions (eMons) and their associated agent is the core of our monitoring system, the low-level part of KMS.

Monitoring expressions are mainly composed of (i) expressions based upon fields and variables present in the different classes and instances found in the managed application code and (ii) an event to emit when one of the expressions becomes true.

eMons can be considered near to the DISMAN [10] -and its associated MIBs -spirit. They are its generalization and don't only limit to SMNP variables but also consider JAVA software applications and their JAVA byte-code. First is given the scope of the eMon. The scope defines the way the eMon's expressions will be evaluated. It can be "method" for a sole evaluation at entry and exit method points, "thread" if an evaluation is required when a thread appears or disappears, periodical, or "always" if the expressions must be immediately re-evaluated after a variable/field modification.

"eMon_name" is not attached to one particular thread and is defined regardless of the thread which runs it.

By default, eMons inserted in the system are considered inactive until someone or something (e.g. another eMon) explicitly activate them. "eMon__name" is here marked has active and must be activate immediately (as long as expressions it is composed of are defined, for example expressions including local variables of a method m() are defined only if at least one thread executes m().).

Follow some declarations. They can be simple shortcuts for ease, typed or not, in relation with the monitored code, e.g. (m, m0, C), or some local temporary variables used for the eMon own needs.

m0 is defined as the local variable at index 0 of method m() in the class named "C". Indexes in place of full named variables (or fields) are allowed as the monitored code may have been stripped of its variables names.

temp_1 is an eMon local variable and has not direct relation with the monitored code. These eMon's local variables must be typed. Their introduction was originally dictated by at least a possibility for the eMons to dynamically obtain and store informations available from the monitoring system (e.g. the JAVA thread number in execution) but also the possibility for expressions to act as counters measuring the difference taken between two evaluations of an expression [START_REF] Kaddour | Administration d'applications distribuées par Aspects et expressions programmables[END_REF]. They evolved and became general purpose variables.

The expressions body, composed of the main monitoring expression enclosed in brackets. It can be preceded by expressions to evaluate and store before the main expression is evaluated whereas following the main monitoring expression are expressions to proceed after the main expression evaluation.

To gain in flexibility, some add-ons are allowed:

-built-in functions provided by the system. This set of functions includes usual system-call functions (kms date(), kms_arch(), kms_strstr(), ...). From a design point of view, they can be seen as the public methods provided by the core KMS.

-Special MIB access functions. As the system is designed to interact with the SNMP protocol [START_REF]Operations for Version 2 of the Simple Network Management Protocol (SNMPv2)[END_REF], a group of functions allowing MIB [START_REF]Information Base for Version 2 of the Simple Network Management Protocol (SNMPv2)[END_REF] accesses is included [START_REF] Kaddour | Administration d'applications distribuées par Aspects et expressions programmables[END_REF]. One function per basic SNMP type: kms int_mib(), kms_bool_mib(), kms_ostr_mib(), ... .

-built-in functions in relation with the underlying monitoring system. They can give to an eMon information directly provided by the JVM. A thread, object or class ID can be obtained this way by an eMon.

-@@last() is the last evaluated value of the main expression.

The eMon specifies the Time To Live of the expression and the kind of event the expression will send when turning true. The TTL can be expressed by means of a maximum number of activations the expression can reach or by a duration time.

After that, the expression is removed by the system from its table of expressions to monitor and a notification is sent to the activity's owner of the expression (by mean of an int expressionReached(int expId) call, a method implemented by the Activity class). SNMP events are also supported [START_REF] Martin-Flatin | Web-based management of IP networks and systems[END_REF].

These information are provided to the monitoring system trough the remove and on_remove statements.

When removed, "eMon_name" generates to the eMon's activity owner a callback with 12 as parameter and it activates the sleeping eMon named "another_eMon". It finally sets to 0 the local variable sum defined in the m() method.

Modifying such a monitored code variable is only allowed at remove time and not in the expressions body. It is an easy and temporary way to avoid unwanted monitored code behaviors that are known to appear then the main monitoring expression is true.

The expected behavior of the KMS (the whole management system) is such that one can either have to manage a few eMons introduced by a human administrator or have to deal with large sets of eMons automatically introduced by activities. In the last case, we may excepted redundancies between the eMons.

We are led to take care of performance aspect and to introduce an algorithm which addresses immediate re-evaluation of eMon's expressions as soon as even only one of their involved variable has been modified.

The needed performance optimization for reevaluation of large number of expressions have similarities with the challenge of filtering high throughput network which has led to new fast matching algorithms [START_REF] Srinivasan | Packet Classification Using Tuple Space Search[END_REF] [START_REF] Gupta | Packet Classification on Multiple Fields[END_REF].

The common way to speed up expressions processing is to use real CPU native code. We chose the IA32(x86) as it is the most representative and common CPU currently used. It hasn't specificities such as large number of registers or long instructions possibilities. Translation towards most sophisticate architecture would be possible.

Some differences with usual compilation. First, we have over the used variables a much more lighter control than a compiler usually has. Variables are lend by the JVM and can at the best be read or modified through get and set functions. An optimization is to avoid these time consumers Java Native Interface /JVM Tool Interface (JVMTI) [START_REF] Jvmti | [END_REF] functions as far as we can and rather use a cache mechanism for the objects, fields and local variables the expressions need. Secondly, eMons' expressions are loosely coupled with the application code they monitor and are evaluated asynchronously with the Java code executed by the JVM. Hence, we can't statically discover from the monitored code some registers optimizations for the eMon's generated code.

The overall architecture

The used architecture takes advantage of features provided by the JVMTI introduced by Sun. At first available through the JVM Debugger Interface /JVM Profiler Interface couple, this API offers the possibility to attach an agent to the original java byte-code. This agent has facilities to register customized hooks at runtime to the java byte-code, such as e.g. hooks to be informed when a field is modified or when a class is loaded by the JVM.

In particular, it is possible for an agent to modify or inject new java byte-code in the original one, this is known as instrumentation [START_REF] Hprof | A Heap/CPU Profiling Tool in J2SE 5.0[END_REF] [START_REF] Maebe | Instrumenting selfmodifying code[END_REF]. Despite attractive as this injected new byte-code is next automatically compiled by the underlying JIT, we have not chosen a pure instrumentation approach for at least two reasons.

First, instrumentation freezes the monitoring process. When inserted, an eMon is considered as always active and can't afterwards easily be removed, nor we can dynamically add or activate new incoming eMons. Second, only one agent can modify the bytecode this way, and that's the way AspectWerkz [1] already took to provide Aspects used by the high-level management part of the system.

Figure 1. Agent architecture.

We then choose the more drastic approach that is to take in charge the eMons compilation process.

This agent is the monitoring system. First of all the agent places hook functions to be executed when a class is loaded, when a thread enters or exits a method, fields modifications, etc. or when a breakpoint event is generated by the JVMTI. The agent creates its own memory zones, mainly the pool of cached variables and storage areas for eMons compiled code.

When an eMon is inserted in the agent, it is parsed accordingly to its definition, relationships with its siblings eMons are created and finally it's DAG representation is constructed.

The DAG is constructed in a usual manner with the partial and incomplete information available as variables/fields types are generally unknown as this step, neither are their storage zones and as a consequence nor are the operations types. This is a difference with traditional or JIT compilation.

Associated to the DAG nodes are the classes of variables or fields needed to complete the DAG compilation plus a fast to compute hashkey.

As DAG nodes are unary or binary operators, the hashkey is a 32 bits quantity build from the node left part type, the node right part type and a xor of the left and right parts node quantities. This key is then used to find DAGs nodes similarities among eMons DAGs. Each time a node appears to be used, it's usage_number is incremented.

When a new class is loaded the previously registered loadClass hook function attached to the JVMTI takes control over the JVM. Then we create our own representation of this class with fields offsets or methods ID identifiers and the class is marked as "known", considering the build representation accurate even if the class is later unloaded. This mechanism speeds up the parsing process but implies that the monitoring agent doesn't properly work with hacked byte-code differently modified in between two consecutive loads by the JVM.

For classes with variables involved in awaiting eMons' DAGs to complete, fields/variables types are obtained and memory zones are allocated to store static or member fields and member local variables. All these storages take place in the pool of cached variables which are later used by the compiled code.

Current JVMTI doesn't provide for local variables modification the same modified event mechanism it allows for fields. In the case of eMons with method local variables and with a scope sets to always, we have to manually seek where these variables are modified in the java byte-code. So, without any instrumentation modification intents, we walk through the byte-code methods and look for java op-code offsets where local variables are modified. Breakpoints (JVMTI's breakpoints are simple events sent to a Breakpoint() event manager) are placed for each one of the encountered offset and the index of the modified variable is registered. Finally two tables are created for the breakpoint event manager.

The first one is an association offset-calls sets where a calls set is a sequence of call cells, each cell contains a call execution code towards the compiled code to execute for the re-evaluation of one expression using the modified local variable. A call cell can be empty and is modified accordingly to the eMon activations/un-activations. Calls sets are modified accordingly to eMons removal or new eMons arrival. This two stage call process -rather than one or two list(s) containing addresses of compiled code to reevaluate -was preferred as eMons arrival/removal remains rare once the java code is in execution. This The second table is an (offset, next offset) hashtable which tends to improve the breakpoint manager performance for without loops method code. When called, the breakpoint manager firstly gets (GetLocal<Type>()) and updates the modified variable in the pool of cached variables and then checks if it is called with the excepted next offset, if this is the case then the calls sets to execute are immediately found, otherwise the offset hashtable is used to obtain the appropriate call-sets.

Emon's DAGs for which the new incoming class was the last expected one to complete information variables are then compiled. The operations types are evaluated and the associated code generated using the addresses in the pool of cached variables, empty call cells waiting for these expressions to be compiled are filled. The generated code tries to minimize the expressions re-evaluation process.

Underlying compilation ideas

To describe how the most often used parts of expressions are compiled to reduce the overall reevaluation process, we'll treat the case of the (x +y) +(u *v) expression (E), without object reference for the sake of simplicity.

Nodes of the expression are labeled with binary numbers composed of 0 and 1's. Starting from the root with an empty label, at each step, left node's label is build by concatenating a 0 to its father's one, right node label by concatenating a 1. Such an labeling tree scheme was also used to built fast matching tables in the network filtering area [START_REF] Srinivasan | Packet Classification Using Tuple Space Search[END_REF]. It appears that the label of a variable leaf node describes the path in the DAG from the leaf node towards the root node an gives the list of the nodes witch need to be re-evaluated when the variable is modified. All the other nodes aren't affected by the variable modification and their last known result remains correct.

A bloc is a part of the DAG with only one operator and able to memorize its last evaluated result. The expression E is formed of the bloc (x +y) and the bloc (u *v). The generated code of each bloc can immediately be obtained from code templates that we instantiate according to the types, the operation and an available free register at compile time, tracking of free registers is done with a usual free registers stack.

The generated code for the bloc (x +y) obtained from the (int, int, add) code template is: mem_xy dw 0 ev_xy mov reg, @x; // free reg ==reg add reg, @y; // op ==add mov mem_xy, reg ret as storage zone of x and y in the cache are known. The same goes for the bloc (u *v), with the next free register.

The whole machine code associated to the expression E is obtained in linear time from the generated codes of (x +y) and (u *v). It is composed of an evaluation code if x or y is modified, an evaluation code if u or v is modified and a complete evaluation for the most general case.

Here is the evaluation code of E when x or y is modified: mem dw 0 _Entree_xy call ev_xy add reg, mem_el_uv mov mem, reg ret A table (modified variable, entry point) is maintained and later used to select to right evaluation code to execute (via a call cell) when a variable is modified.

This way minimizes the re-evaluation of common sub-expressions, for example in the case of 0 <(x +y) +(u *v) <5,(x+y >0 && x +y <3); the bloc x +y is effectively evaluated only once if x (or y) is modified and never for a modification of u.

A major drawback of the approach is the extra memory needed compared with a straight forward compilation of expressions. This is an often seen counterpart when using cloning techniques [3][15].

Another disadvantage of this approach appears when considering small expressions with few (e.g. 3) variables where a usual compilation consummates less memory and have a better execution time. But when the number of variables is over 3 or when a common sub-expression is shared by many expressions, using a partial re-evaluation mechanism seems better.

It has finally been chosen to use partial reevaluation only for DAGs with a usage_number upper or equal than 3 (the extra-memory used by the generated code is then acceptable) and if no more than one object instance is needed.

Future work and conclusion

The purpose of this work is to investigate the problem of management for distributed applications with performance aspects in mind. We suggest a management system with a low-level management part able to deal with managed software components at runtime. It uses facilities provided by the JVM/JVMTI and compiles monitoring expressions on-the-fly to improve performance of the management system.

Currently both high and low level management remain too tightly coupled. In particular in the case of distributed management, complex monitoring expressions involving instances executed on different systems (for example variables in the client classes code and variables in the server classes code) need to communicate through their associated activities. We plan to definitively separate the monitoring part of the management system and enhance agents with communication abilities for variables values exchanges, leading to an autonomous distributed monitoring system.

It has been pointed out that the case of eMons using only kms_<type>_mib() calls, without further JAVA references, are to consider. This leads to the creation of an autonomous program (and not a library) build from the agent library which could then manage devices supporting SNMP interactions.

A second investigating field is the creation of MIBs from which standardized management tools could interact with the proposed system.

  scheme avoids unnecessary C(agent)/Asm(eMons) switches and CPU cycles losts.The second table is an (offset, next offset) hashtable which tends to improve the breakpoint manager performance for without loops method code. When called, the breakpoint manager firstly gets (GetLocal<Type>()) and updates the modified variable in the pool of cached variables and then checks if it is called with the excepted next offset, if this is the case then the calls sets to execute are immediately found, otherwise the offset hashtable is used to obtain the appropriate call-sets.Emon's DAGs for which the new incoming class was the last expected one to complete information variables are then compiled. The operations types are evaluated and the associated code generated using the addresses in the pool of cached variables, empty call cells waiting for these expressions to be compiled are filled. The generated code tries to minimize the expressions re-evaluation process.

Figure 2 .

 2 Figure 2. Labeled DAG.


Nguyen Thi

Tuyet Mai

Claire Mangeney

Nordin Felidj

Thermosensitive polymer-coated plasmonic nanostructures for reversible confinement biomolecules

INTRODUCTION

Biomedical applications of stimuli-responsive surfaces started attracting interest in the 1980s, particularly on the basis of work by the group of Hoffman [START_REF] Hoffman | Applications of thermally reversible polymers and hydrogels in therapeutics and diagnostics[END_REF]. Bio-interfaces with stimuli-responsive/switchable bio-affinity have been of considerable recent research interest. The use of switchable surfaces has been discussed for cell culture, drug delivery and tissue engineering [START_REF] Kikuchi | Pulsatile drug release control using hydrogels[END_REF][START_REF] Jagur-Grodzinski | Polymers for tissue engineering, medical devices, and regenerative medicine. Concise general review of recent studies[END_REF][START_REF] Gupta | Hydrogels: from controlled release to pH-responsive drug delivery[END_REF][START_REF] Langer | Advances in Biomaterials, Drug Delivery, and Bionanotechnology[END_REF]. These surfaces are typically prepared by grafting environmentally sensitive macromolecules onto a substrate, where the type of macromolecule and substrate are chosen depending on the intended use of the surface. A typical molecule used for this purpose is poly(Nisopropylacrylamide) (PNIPAM), which is hydrated and hydrophilic below the lower critical solution temperature (LCST) in the physiologically relevant range at 32 o C, but above the LCST, the polymer segments are thought to become more hydrophobic. This temperature-dependent hydrophobicity transition has been exploited to selectively switch the interfacial properties of PNIPAM and its consequent interactions with cells and biomolecules [START_REF] Xu | Surface-Active and Stimuli-Responsive Polymer-Si(100) Hybrids from Surface-Initiated Atom Transfer Radical Polymerization for Control of Cell Adhesion[END_REF][START_REF] Akiyama | Ultrathin Poly(N-isopropylacrylamide) Grafted Layer on Polystyrene Surfaces for Cell Adhesion/Detachment Control[END_REF]. The change in hydration of the PNIPAM renders the PNIPAM surface adhesive or non-adhesive to bio-molecular [START_REF] Ma | non-fouling'' oligo(ethylene glycol)-functionalized polymer brushes synthesized by surface-initiated atom transfer radical polymerization[END_REF][START_REF] Gautrot | Exploiting the superior protein resistance of polymer brushes to control single cell adhesion and polarisation at the micron scale[END_REF][START_REF] Azioune | Simple and rapid process for single cell micropatterning[END_REF][START_REF] Patel | Rapid cell sheet detachment using spin-coated pNIPAAm films retained on surfaces by an aminopropyltriethoxysilane network[END_REF][START_REF] Kumashiro | Modulation of cell adhesion and detachment on thermo-responsive polymeric surfaces through the observation of surface dynamics[END_REF].

Adhesion between particles of sizes in the micron to nanometer range and solid surfaces is a key factor in many industrial applications. Hardly any real surface is smooth at a submicroscopic level and practical surfaces often possess significant roughness or are nanostructured for specific applications such as biomaterials, tissue engineering and cell cultures [START_REF] Singhvi | Engineering Cell Shape and Function[END_REF]. Surface roughness or structuration play an important role in adhesion since it reduces the contact area between the bodies leading to significantly reduced interaction. Surfaces may possess features in several length scales, but due to the short range of the van der Waals interaction, structuration in nanoscale ultimately determines the strength of adhesion. Invention and progress of colloidal probe technique have boosted the studies of adhesion and the effects of nanoscale nanostructuration or roughness. Recent studies have quantified the relative importance of the geometry, surface roughness and medium properties on the adhesion of the approaching bodies as their sizes are scaled from micro-to nano-scale.

In this work, we describe design and preparing of novel systems including plasmonic nanostructures coated by PNIPAM brushes as smart platforms for bio-particles reversible confinement. The combination of lithographic gold nanostructures and thermoresponsive polymer brushes leads to a new generation of hybrid gold/polymer system for efficiently switched from bio-adherent to bio-repellent by convenient temperature stimuli.

EXPERIMENTAL

Materials

Reagent grade solvents were purchased from VWRProlabo and Alfa Aesar. 2-Bromopropionyl bromide (BPB) (97%, Aldrich), triethylamine (TEA) (99%, Merck), CuBr (98%, Sigma-Aldrich), N,N,N',N",N"pentamethyldiethyltriamine (PMDETA) (99%, Acros Organics) were used as received. N-Isoproylacrylamide (NIPAM) (99%, Acros Organics) was purified by recrystallization in n-hexane solution. Bovine Serum Albumin (BSA) 98% was obtained from Sigma-Aldrich.

Elaboration of gold nanostructures array

Golf nanoparticles arrays are fabricated by electron beam lithography (EBL). The starting point is a flat substrate that is conducting to prevent charging. For optical applications, ITO covered glass plates have become widely used. The substrate is spin coated with an electron sensitive resist, typically 90 nm thick. Resists as polymethylmethacrylate (PMMA) consist of macromolecules that are modified upon exposure to high-energy electrons, resulting in a changed solubility. A desired sample pattern can thus be transferred to the resist by writing the pattern with an electron beam and subsequent wet chemical development. The resulting patterned resist layer serves as a mask for depositing the sample material by vacuum evaporation. Finally, a lift-off step removes the resist mask and excess material on top of it, leaving the sample structures on the surface.

Functionalization of gold nanostructures by PNIPAM brushes

Synthesis of diazonium salt:

The 4-Hydroxyethylbenzene Diazonium Tetrafluoroborate Salt (+N2-C6H4-CH2-CH2-OH) was synthesized following this protocol: A stirred solution of 2-(4-aminophenyl)ethanol (0.69 g) and HBF4 (1.8 mL) in acetonitrile (3 mL) at -10 °C was added dropwise to a solution of tert-butylnitrite (0.63 g) in acetonitrile (3 mL) at -10 °C. The resulting mixture was kept overnight at -10 °C. The precipitate was washed three times with 50 mL of diethyl ether, then with 50 mL of acetone, and finally evaporated under vacuum. The 4-(2hydroxyethyl)benzene diazonium tetrafluoroborate salt was stored at -10 °C.

Initiator-modified gold surfaces:

The atom transfer radical polymerization initiator was grafted in 2 steps. (i) Spontaneous grafting of 4-hydroxyethylbenzene diazonium tetrafluoroborate salt (0.003 M) was achieved on cleaned gold nanostructures array by incubation for 6h at room temperature. (ii) Then, the terminal hydroxyl groups were treated with 2-bromoisobutyryl bromide (0.1 M, toluene) in the presence of TEA (0.12 M) for 5 min to produce bromoterminated ester groups.

Atomic Transfer Radical Polymerization (ATRP) of NIPAM:

Solutions were prepared and kept at room temperature during degassing by passing a continuous stream of argon through the solution while being stirred. The polymerization solution was prepared by adding a solution of an organometallic catalyst to a solution of NIPAM monomer. The extremely oxygen sensitive organometallic catalyst was prepared by adding a 5 mL solution of PMDETA in MeOH (200 µL, 1 mmol) to 30 mg of CuBr (0.2 mmol). A 3 mL portion of the resulting green solution (which could possibly turn blue due to presence of CuBr2 and provide unsuccessful ATRP) was added to a solution of NIPAM monomer (2 g, 18 mmol) in 11 mL of deionized water under a continuous stream of argon. The polymerization solution was allowed to stir during degassing for 15 min and then transferred into a flask containing the initiator-modified gold surface. The resulting solution was allowed to stir at room temperature under argon for 20 min. Substrates were then removed from the flask and rinsed thoroughly with ethanol and water and subsequently dried under a flush of argon.

Instrumentation

AFM in air was performed on Nanoscope III digital instrument microscope in tapping mode to map the morphology. AFM images were processed and analyzed using the application WSxM and FabViewer. The extinction spectra were recorded by far-field extinction micro-spectroscopy in the 500-1000 nm range. The spectrometer is coupled to an upright optical microscope equipped with a 50× (Olympus, numerical aperture NA=0.35) and 100× (Olympus, NA: 0.8) objectives for experiments in air. Extinction spectra recorded in water at various temperatures used 100× immersion objective (Olympus, N.A: 1)

RESULTS AND DISCUSSION

Characterization PNIPAM-coated gold nanodots

GNDs array is fabricated by electron beam lithography (EBL) on an ITOcovered glass substrate with a diameter of ~220 nm and a height of 50 nm (see Fig. 1). A strong extinction of this array emerges at 600 nm in air due to excitation of LSP (Fig. 2.2c -black line). The pNIPAM brushes were grafted on the GNDs array by using our multi-step strategy (described in Fig. 2).

The stepwise strategy for the preparation of the hybrid plasmonic system GND@pNIPAM consists in three major steps: (i) The spontaneous grafting of the aryl group derived from 4-hydroxyethylbenzene diazonium tetrafluorborate salt (HEBDT) to produce -OH terminated aryl moieties, covalently anchored to the surface; (ii) Esterification of the anchored -OH groups with 2-bromoisobutyryl bromide leading to bromo-terminated gold surface which allows to initiate the Atomic Transfer Radical Polymerization (ATRP) and (iii) The grafting of pNIPAM brushes from the surface via surface-initiated ATRP. The thickness of PNIPAM grafted on GNDs array was measured by AFM in air at room temperature. The AFM images of GNDs before and grafting of PNIPAM allow estimating the dry PNIPAM thickness which is around hdry ~10 ±2 nm (in air at room temperature, PNIPAM adopts a collapsed conformation), see Fig. 3a,b. In water at room temperature (below the LCST), the PNIPAM adopts a swollen conformation. The swelling ratio defined as α = hswollen/hdry (where hswollen and hdry corresponds to the swollen and dry brush thickness) was deduced from our report to α ∼ 2 [START_REF] Nguyen | Engineering Thermoswitchable Lithographic Hybrid Gold Nanorods as Plasmonic Devices for Sensing and Active Plasmonics Applications[END_REF][START_REF] Nguyen | Tunable Electromagnetic Coupling in Plasmonic Nanostructures Mediated by Thermoresponsive Polymer Brushes[END_REF]. Thus, the PNIPAM thickness in the swollen state can be deduced to ∼ 20 ±2 nm. Increasing the external temperature up to 40 o C in water (above the LCST of PNIPAM) induces a dramatic change of the polymer conformation of which the thickness significantly decreases upon heating to, 10 ±2 nm. The extinction spectra of GNDs array before and after the polymerization process indicate a red-shift of 35 nm of the LSPR wavelength (Fig. 3c). This red-shift is attributed to an increase of the local refractive index around the GNDs in presence of the polymeric layer. Interestingly, when the GND@pNIPAM array is immersed in water and heated from 20 o C (below the LCST) to 40 o C (above the LCST), a red-shift of 8 nm of the LSPR wavelength is observed, as shown in Fig. 4. This red-shift is attributed to collapse of the polymer brushes above the LCST, leading to an increase of both the polymer density close to the NPs and the refractive index of the surrounding medium. Note that the stability of our system has been checked through 6 cycles in temperature, indicating that the links between all of the components are strong, therefore making our plasmonic device very stable (inset Fig. 4).

Confinement of protein on the PNIPAM-grafted gold nanostructured surface

As ready mentioned, pNIPAM brushes are hydrated below the LCST of 32 o C, while above the LCST, the polymer segments become more hydrophobic. The change in hydration of the pNIPAM renders the pNIPAM surface adhesive or non-adhesive to bio-molecules. In order to investigate this behavior, we considered the thermo-controlled adsorption on GND@pNIPAM of a model protein, the Bovine Serum Albumin (BSA). The dry grafted pNIPAM thickness was hdry ~ 10 nm. It is known that the hydrophobic interaction has a major role in protein adsorption phenomena. When the temperature increases above the LCST, the surface becomes more hydrophobic. Therefore, the polymer brushes collapse and are susceptible to adhere larger amounts of protein. By using the plasmonic GNDs array structures, the adsorption of BSA as a function of temperature of the incubation procedure can be monitored by the modification of UV-vis spectra. Adsorption of BSA on GND@pNIPAM substrate was carried out by incubation of the substrate in the aqueous solution of BSA 10 The desorption of BSA from pNIPAM brushes was carried out by immersion of the sample (after BSA adsorption at 50 o C) in water at 20 o C. Then, the sample was rinsed in water at 20 o C and dried by nitrogen gas. Fig. 6 shows the evolution of extinction spectra of GND@pNIPAM as a function of desorption procedure time. A blue-shift of LSP wavelength is observed versus the time of immersion of the sample in water at 20 o C due to a decrease of the refractive index of the surrounding medium caused by the desorption BSA molecules from the polymer brushes. Nevertheless, we can observe that by incubating the sample in water at 20 o C for one day, the extinction spectrum couldn't be restored to the initial spectrum of nanostructure before BSA adsorption. This observation indicated that some BSA molecules still remain robustly adsorbed to the gold nanostructure substrate or insertion into the polymer brushes. In fact, the metallic nanostructures which are rough can provide several sites for proteins adsorption on its surface. To verify our hypotheses, the process of thermo-induced adsorption/desorption of BSA molecules was done several times. The experimental results were shown in Fig. 7. For the first cycle, when the temperature decreased, the LSP wavelength couldn't be restored to the initial position before the BSA adsorption because several BSA molecules were trapped as mentioned above. However, from the second cycle, the shift of LSP wavelength of nanostructure becomes reversible and reproducible. Thus, the hybrid structures including GNPs and pNIPAM can be efficiently switched from bio-adherent to bio-repellent by convenient temperature stimuli. In conlusion, we showed two examples of possible perspectives of the confinement of latex particles and protein on the hybrid thermosensitive plasmonic nanostructures GNP@pNIPAM. The temperature-dependent hydrophobic/hybrophilic property of pNIPAM was exploited to switch the adsorption/desorption of a protein bovine serum albumin. With the above characteristics, this hybrid nanostructures can be used in biomedical and biological applications such as enzyme immobilization, cell sorting, protein adsorption and purification.

Figure 1 .Figure 2 .

 12 Figure 1. SEM image of gold nanodots array

Figure 3 .

 3 Figure 3. AFM images of GNDs (a) and GND@pNIPAM array (b). Extinction spectra in air of GNDs array before (after grafting of initiator groups)-black line and after polymerization-orange line (c).

Figure 4 .

 4 Figure 4. Extinction spectra of GND@pNIPAM recorded in water at 20 o C (blue line) and 40 o C (red line). Inset: Variation of the LSP wavelength of the GND@pNIPAM array in water as a function of the external temperature for repeated temperature cycles 20 o C and 40 o C.

- 2 M

 2 at 20 o C and 50 o C for 2h. The substrate then was rinsed by water at the same temperature (20 o C or 50 o C), dried by nitrogen gas and characterized by UVvis absorption spectrometer. Fig.5displays the extinction spectra recorded in air at room temperature of GND@pNIPAM before (black curve) and after incubation in a BSA solution at 20 o C (green curve) and 50 o C (red curve). These results show that the LSP shift is negligible when the sample was incubated in BSA solution at 20 o C. In contrast, a red shift of the LSP wavelength  ~ 12 nm is observed after incubation the sample in the BSA solution at 50 o C. This can be attributed to the adsorbed protein on the polymer brushes which increases of the refractive index of the surrounding medium of GNDs. It to note that in the absence of BSA solution, the plasmon band of GNDs is not changed after the same experiment procedure.

Figure 5 .

 5 Figure 5. Extinction spectra recorded in air at room temperature of GND@pNIPAM nanostructure before (black curve) and after incubation in the BSA solution at 20 o C (blue curve) and at 50 o C (red curve).

Figure 6 .

 6 Figure 6. Extinction spectra of GND@pNIPAM with adhered BSA protein (red curve) after immersion in water 20 o C for 10 min (green curve) and 60 min (pink curve) (all spectra were recorded in air at room temperature). The pink curve is close to the blue

Figure 7 .

 7 Figure 7. Variation of the LSP wavelength of GNP@pNIPAM array recorded in air as a function of adsorption/desorption cycles of BSA molecules.