adaptive device with underlying mechanism defined by a programming language · 2006-09-29 ·...

Adaptive device with underlying mechanismdefined by a programming language

APARECIDO VALDEMIR DE FREITAS 1,2 , JOÃO JOSÉ NETO 11 Escola Politécnica da Universidade de São Paulo

Depto. de Engenharia de Computação e Sistemas DigitaisAv. Prof. Luciano Gualberto, trav. 3, No 158. Cidade Universitária

São Paulo – Brasil2 Universidade Municipal de São Caetano do Sul

Instituto Municipal de Ensino Superior de São Caetano do SulAv. Goiás No 3400 – Vila Barcelona – São Caetano do Sul – CEP 09550-051

São Paulo – Brasil

Abstract: - An adaptive device is made up of an underlying mechanism, for instance, an automaton, a grammar,a decision tree, etc., to which is added an adaptive mechanism, responsible for allowing a dynamicmodification in the structure of the underlying mechanism. This article aims to investigate if a programminglanguage can be used as an underlying mechanism of an adaptive device, resulting in an adaptive language.

Key-Words: - adaptive devices, self-modifying machines, adaptive automaton, functional adaptiveprogramming language, algorithms and computation theory.

1 IntroductionAdaptive devices were first studied and applied inthe field of compiler implementation in order to getpurely syntactic mechanisms intended to enlargepushdown automata’s expressions capacity [6]. Thetheory of adaptive devices started with simple-to-use formalisms, such as finite state automata,which enabled them - by adding a set of rules – torepresent more complex problems, as thoseconcerning non-regular languages and evencontext-depedent [11].Adaptive technology involves techniques andmethods associated with the practical applicationsof adaptive devices. Chronologically, these devicesoriginated from researches into formal languagesand automata. Formalism, however, stimulatedapplications in several different fields [7].An adaptive device is made up of an underlyingmechanism (eg an automaton, a grammar, adecision tree, etc.), to which what we call adaptivemechanism is conjoined, allowing the structure ofthe underlying mechanism to be dynamicallymodified. If, for instance, an adaptive mechanism isadded to a finite state automaton, it is possible toincrement or remove transitions and/or statesduring the input stream process [8] and to increaseits expression power.Adaptive technology, therefore, is basicallycharacterized by re-using consolidated formalisms

and increasing their expression power at the cost ofa small increment in formal complexity [11].An adaptive device should always be associatedwith a fixed and finite set of rules, which accountfor the reconfiguration of the device, occasionallyconsidering an input stimulus and generating someexit symbol.When guided by rules, a device starts operation in agiven configuration and proceeds with theapplication of some rule from its set up to whenthere are no more input stimuli or when aconfiguration is reached to which application ofrule is not possible. At this point, it is possible todetermine, based on the configuration reached,whether the device accepts the complete sequenceof input stimuli or rejects it.In an adaptive device, a set of rules can bemodified by another one, called adaptive actions,working on the original set of rules. An adaptivedevice, then, is made up of an underlying layer – anon-adaptive device guided by rules – and anadaptive layer defined by a set of adaptive actions.Starting from adaptive automata and following theevolution of adaptive devices, new adaptivedevices were conceived and associated with severalareas, with different underlying mechanisms, suchas statecharts[12], Markov nets [13],computational learning [18], natural languagesprocessing [14], grammars [15], multilanguageenvironments [16], robotics [17], decision trees[11], etc.

Proceedings of the 4th WSEAS Int. Conf. on Information Security, Communications and Computers, Tenerife, Spain, December 16-18, 2005 (pp423-428)

2 Objective

This paper intends to investigate and assure thatprogramming language can be used as anunderlying mechanism of an adaptive device. Justlike an adaptive finite automaton incorporates afinite automaton as an underlying mechanism, anadaptive programming language must use someprogramming language as an underlyingmechanism. We are going to investigate, then, ifthe implementation of adaptive language isfeasible, therefore applicable to problemsrecommending adaptive technology.The adaptive mechanism found in the adaptivelanguage will make it play a self-modifying role,performed by dynamic codes. Self-modifying codesemployed in machine languages are often hard towrite and to keep. Our proposal, however, dodgesthe difficulties common in machine languagesbecause the adaptive technology considers the useof adaptive functions, specified by fixed well-defined rules, which secure reliability to theproposed solution.Another objective is to show the technical viabilityof designing programming languages that modifythemselves to tackle the problem to solve. Aprogram is often divided into parts, in a top-downmethodology. With adaptive languages, thedivision can be made by the bottom-up approach,the language modifying itself towards the problem[3].To reach this objective a functional programminglanguage will be used, with extensible features forthe incorporation of the mechanisms of adaptiveformalism [9]. The choice of functional paradigmdoesn’t restrict the conception of adaptivelanguages exclusively to this paradigm. As soon asthe feasibility of the adaptive languages is assured,further research in other programming paradigmscan be undertaken.

3 Adaptive Devices

An adaptive automaton is the result of a sequenceof evolution of a structured pushdown automatonprocessed by adaptive actions. To each adaptiveaction a new automaton is implemented for thecontinuity of the input stream treatment.To illustrate the applicability of adaptive devices,there follows a practical example quite useful forthe exclusively syntactic resolution of problemsoften found in the recognition of context-dependentlanguages. It is a collector of names (identifiers)which, setting out from an initial situation in the

input stream and classifies then either as foundpreviously or not. By a change in the structure ofthe device that implements it, later recognitions ofnewly-collected identifiers will be dealt with asalready found before.Based on the technique shown in the example, it ispossible to treat – without recourse to tables – thenames of the variables of a language with a singlescope. So, the mechanism implemented in thisexample can inspire substitutes in the recogniserproject that replace the symbol tables with a purelysyntactic mechanism of name collecting [6].At first the adaptive automaton recognises, throughits initial machine of states, any valid identifier, andclassifies it as an ignored identifier. By a structuredself-modifying in the device, the same identifier –if found on a later occasion – will not be classifiedas ignored again.A group of transitions is then created so that thenew identifier is associated with a path by theautomaton states and those take it to a final state,which accepts the identifier and characterises it as aknown identifier.As soon as the identifier is characterised as known,the old path accepting such identifier must beeliminated from the automaton. Likewise, theadaptive call functions responsible for theseoperations must also be rearranged so that newenlargements can take place as a consequence ofrecognitions of identifiers sharing common prefixesto previously found identifiers.To each new identifier found, a set of transitions isinserted into the automaton enabling it to recognisethe new symbol (taking into account the otheridentifiers, previously incorporated) and thetransitions that implement the path leading to therecognition of this identifier in the originalautomaton is eliminated.

4 Definition of the UnderlyingMechanism

Our investigation probes into the viability of usinga functional programming language as anunderlying mechanism of the device, in a waysimilar to that of an adaptive automaton using astructured pushdown automaton as an underlyingmechanism for self-modification. Thisinvestigation will likely enhance the developmentof a functional programming language with theadaptive characteristics.Taken lambda calculus as the basis for functionalparadigm of programming, we will adopt a


language supporting lambda calculus as anunderlying mechanism [2] [4].It is the better adherence to the concepts ofadaptive technology that validates this choicebecause the model allows the construction ofexpressions with the treatment of dynamic codes(usually implemented with constructions of evaltype in Lisp, Scheme or their dialects).That duly considered, the underlying mechanismwill be made up of a functional nucleus based onlambda calculus to operate as an interpreter of alanguage codified by the user.Having this basic functional nucleus extensivecharacteristics, we will design an extensibleadaptive layer to evaluate calls of adaptive actions,which will modify the host language, making itadaptive.With the processing of adaptive actions new codeinstances are obtained and the execution oflanguage is processed by successive context switchbetween the adaptive layer and the underlyingmechanism responsible for the interpretation ofeach code instance.Adaptive programming language will present, at anearly stages, a code block liable to directprocessing by the underlying mechanism until theexecution of some adaptive action specified in themodel takes place.Adaptive language, thus, will be made up of aspace of codes LF1, LF2,.., LFn , so that, startingfrom initial language LF1 and proceeding throughcalls of adaptive functions, language will evolveinto successive configurations LF1, LF2, .., LFn

while execution is under process. The proposedadaptive mechanism holds a close structuralanalogy with the adaptive automaton dealt with initem 3.To demonstrate the feasibility of our proposal, wewill put to use a simplified language based onexpressions. As a rule, an expression is a list inwhich the first element denotes a function and thefollowing others denote the arguments. Eachexpression has to return a value. The languagepresents some native functions to treat arithmeticexpressions and logics with, but the user may alsodefine new functions to be combined with thosealready defined in the language.

5 Adaptive Language Operation

For our adaptive language to be processed, aprocessing environment must be created, made upof the functional nucleus and a control module,

represented by the adaptive machine whoseresponsibility will be to evaluate adaptive calls.Fig.1 shows what happens along the processing ofadaptive language.

Fig.1 - Adaptive Language – Processing Environment

1. The adaptive machine makes the functionalinterpreter’s call based on lambda calculus andpasses to it the initial source code codified bythe user;

2. The functional interpreter will start theevaluation processing of functions in the usualway until some call of adaptive function takesplace. If there aren’t adaptive calls, theinterpreter will behave just as it were in a non-adaptive functional environment;

3. The control returns to the adaptive machine,which will provide the adaptive call handling;

4. Being adaptive actions made up of elementaryactions, the adaptive machine may use adaptivelayer functions;

5. As a result of the execution of adaptive actions,a new source code is generated;

6. This new source code is handed down to thefunctional interpreter, which will take uponitself the continuity of the execution of theadaptive functions.

6 Adaptive Layer Project

In a manner similar to that along the evolution ofan adaptive automaton, when inclusions and/orexclusions of transitions and/or states take place –derived from the calls of adaptive actions – ouradaptive language will also develop duringexecution through the inclusion or exclusion offunctions, thus characterising the dynamics ofadaptive code.The calls of adaptive functions (denoted byadaptive actions) will then favour the features of

Initial Source

Interpreter

LambdaCalculus

Adaptive LayerADAPTIVELIBRARYADAPTIVE MACHINE 4

Source Code

1 5

2

6

3


self-modification in the device. These functionswill be constituted by calls of elementary functions,available in the adaptive layer, which through basicoperations of query, inclusion, and removal oflanguage functions will provide the device withdynamic modification.Our adaptive layer, thus, will be made up ofelementary actions ?adapt, +adapt, and –adapt,responsible respectively for the query, addition, andeliminations functions of the underlying language.This set of elementary actions will correspond tothe rules modifying in consequence the executionof adaptive language.Naturally, for each individual problem, elementaryactions will be extracted from the adaptive layer inamount and sequence convenient for the problem atissue.To generalise consult functions, queries modelledaccording to pattern matching can be specified soas to return the functions list that fulfills the query.For the functions of adaptive layer to perform theirtasks, the functions making up our source programmust be somehow addressed, in a similar way thatan adaptive action – when eliminating or inserting atransition in an adaptive automaton – needs to referto each of the original automaton’s states ortransitions.The language used will be simple and based onexpressions, so that a program in this underlyinglanguage may be reduced to the call of a singlefunction, resulting from the composition of severalother functions.A program P then can be represented under theconfiguration if a list. For instance:

( a ( b ( c ) ( d ) ( e f g ) ) (h i ) )

To make the idea of our functional program easierto envisage to the light of adaptive paradigm, theopening of parentheses will be indexed with the useof labels represented by whole numbers. Theselabels will start with the value 1 in the definition ofthe first function and will gradually increase as thenew definition or function calls turn up along thetext of the program.Since a functional program can be represented by atree-type structure, each label should be seen as anode from such a tree. So, in the previous example,our functional program P will be represented asfollows:

1 2 3 4 5 6( a ( b ( c ) ( d ) ( e f g ) ) (h i ) )

3 4 5 2 6 1

For an adaptive treatment to be operated in afunctional program, it takes first of all a translationframework allowing form a representation of theprogram closer to the adaptive formalism.After the mapping is completed, the program has tobe converted in to a new representation P’:

1 2 3 4 5 6( (F ) ( a ( b ( c ) (d) (e f g ) ) (h i) ) (G ) )

3 4 5 2 6 1

F and G corresponding respectively to the adaptivefunctions previous and subsequent to the evaluationof the function representing program P’.These functions will be responsible for the self-modification of the device and will operate on thelabels attributed to each function making up theinitial program P’. For instance: if it becomesnecessary for the adaptive function F to eliminatefunction d in program P’, label 4 is passed asparameter and as a result of the evaluation ofadaptive function F, node 4 corresponding tofunction d will be eliminated from the tree.This being the procedure, the functional program Pis then represented by a new P’ function, in whichall component functions are mapped form theadaptive functional notation. If there aren’tadaptive functions in the device, the representationP’ will naturally be the same as the initial P, which,in this instance, doesn’t characterize the existenceof self-modifications.Through the identification of each function in theprogram, each corresponding node in the tree ofexpressions can be referred. In the previousexample, the tree would be shown like this:

Fig.2 - Tree representing a program P

With the use of this address outline, exclusive foreach component of the program, it is possible tospecify adaptive functions that, through calls of theadaptive layer, will increase, remove, or alter thenodes of the tree, thus generating an adaptive code.For our adaptive functions to accomplish theedition of the tree, labels should be included in theadaptive language, which allow the addressing ofthe several functions that make up the program.The linking of labels to the functions of the

4label

3

1

2 6

5


program should naturally be optional and turned toonly when the function at issue undergoes self-modification.To implement this function of adaptive layer, amechanism similar to the one employed inCommon Lisp language [10] can be used by meansof the “go” and “tagbody” native functions. In casethese constructs are not present in the functionalnucleus of the adaptive environment, it is possibleto emulate such functions through definitionsstarting from other functions present in thelanguage [1].

7 Conclusions

This paper considers the use of the programminglanguage an underlying device in the adaptivedevice. The language thus obtained allows theintroduction of dynamic characteristics into theinitial code of language. We have shown the stepsleading to this objective.With the concepts and procedures presented alongthis paper, we have shown that the implementationof the adaptive language is feasible and can beconsequently applied to problems to whichadaptive technology is recommended.The next steps will involve strict specification ofthe syntax and semantics of the language proposedalong with the implementation of the adaptivemodule responsible for the control of the adaptiveenvironment. The definition of the functions oflabel treatment and elementary actions of theadaptive layer is to be attended to, as well as theimplementation of routines to control module-switching (adaptive x functional) and theprocedures to treat environment variables.After these specifications, it will be possible toimplement an environment allowing the executionof the adaptive language. Some experiments withthe project of adaptive language have already beenmade, the NewLisp environment [5] being used inthe implementations.

8 References

[1] Baker, Henry G. - Metacircular Semanticsfor Common Lisp Special Forms. NimbleComputer Corporation. ACM Lisp PointersV, 4 (Oct/Dec1992), 11-20.

[2] Barendregt, H.P. - The Lambda Calculus:its syntax and semantics – (2nd ed.), North-Holland, 1984.

[3] Knott, Gary - LispBook – Civilized Software,Inc. – 1997.

[4] McCarthy, J. - Recursive Functions ofSymbolic Expressions and Their Computationby Machine, Part-I. CACM 3,4 (1960), 184-195.

[5] Mueller, Lutz - NewLisp User Manual andReference V. 7.50 – 2004 –www.newlisp.org.

[6] Neto, João José - Contribuição à metodologiade construção de compiladores. São Paulo,1993, 272p. Thesis (Livre-Docência), EscolaPolitécnica, Universidade de São Paulo.

[7] Neto, João José - Adaptive Rule-DrivenDevices - General Formulation and CaseStudy. Lecture Notes in Computer Science.Watson, B.W. and Wood, D. (Eds.):Implementation and Application of Automata- 6th International Conference, CIAA 2001,Vol.2494, Pretoria, South Africa, July 23-25,Springer-Verlag, 2001, pp. 234-250.

[8] Neto, João José - Adaptive Automata forContext - Sensitive Languages. SIGPLANNOTICES, Vol. 29, n. 9, pp. 115-124,September, 1994.

[9] Rocha, Ricardo Luis de Azevedo da e Neto,João José - Uma proposta de linguagem deprogramação funcional com característicasadaptativas. IX Congreso Argentino deCiencias de la Computación, La Plata,Argentina, 6-10 de Outubro, 2003.

[10] Steele, Guy L. - Common Lisp, TheLanguage; 2nd Ed. Digital Press, Bedfor,MA, 1990.

[11] Pistori, Hemerson – Tecnologia emEngenharia da Computação: Estado da Arte eAplicações. Tese de Doutorado – EscolaPolitécnica da Universidade de São Paulo.2003

[12] Santos, J.M.N. - Um formalismo adaptativocom mecanismo de sincronização paraaplicações concorrentes. Dissertação(Mestrado) – Escola Politécnica daUniversidade de São Paulo, Brasil, 1997.

[13] Basseto, B. A., Neto, J.J. - A stochasticmusical composer based on adaptativealgorithms. In: Anais do XIX CongressoNacional da Sociedade Brasileira deComputação. SBC-99. PUC-Rio, Rio deJaneiro, Brasil – 1999.


[14] Menezes, C.E.D. – Um método para aconstrução de Analizadores Morfológicos,Aplicados à Lingua Portuguesa, Baseado emAutômatos Adaptativos. Dissertação(Mestrado) – Escola Politécnica daUniversidade de São Paulo, São Paulo –Brasil, Julho 2000.

[15] Iwai, M. K. – Um formalismo gramaticaladaptativo para Linguagens dependentes deContexto. Tese (Doutorado) – EscolaPolitécnica da Universidade de São Paulo,São Paulo, Brasil, 2000.

[16] Freitas, A. V.; Neto, J.J. - Uma ferramentapara construção de aplicaçõesmultilinguagens de programação. In: CACIC2001 – Congreso Argentino de Ciencias de laComputacion. El Calafate, Argentina, 2001.

[17] Souza, M. A. A., Hirakawa, A. R., Neto, J. J.- Adaptive Automata for Mobile RoboticMapping. Proceedings of VIII BrazilianSymposium on Neural Networks - SBRN'04.São Luís/MA - Brazil. September 29 -October 1, 2004.

[18] Rocha, R. L. A.; Neto, J.J. - Uma proposta demétodo adaptativo para a seleção automáticade soluções. In: Proceedings of ICIE Y2K –International Congress on InformaticsEngineering. Buenos Aires, Argentina. 2000.


adaptive device with underlying mechanism defined by a programming language · 2006-09-29 ·...

Documents