Implementation of a reactive autonomous navigation system on an outdoor mobile robot

运营探讨
电力企业无功电压管理存在的问题及措施
邓倩冰
（国网湖南省电力有限公司郴州市苏仙区供电分公司，湖南
无功电压管理是电力企业管理工作的重要组成部分，其与电能质量有着直接关系。

目前，电力企业无功电压管理工作存在许多问题，不仅影响电力用户的用电体验，而且会对电力企业的发展造成不良影响。

因此，阐述了无功电压管理的重要性，指出了主要影响因素，并深入分析了无功电压管理存在的问题，有针对性地提出了解决措施，以提高无功电电力企业；无功电压管理；管理水平
Problems and Measures of Reactive Power and Voltage Management in Electric
Power Enterprises
DENG Qian-bing
Chenzhou Suxian District Power Supply Branch
Reactive power and voltage management is an important part of power enterprise management
there are many problems in reactive power and voltage management in power。

[素质教育]世界跨文化教育理论流派综述[素质教育]世界跨文化教育理论流派综述【正文】跨文化教育（interculturaleducation），一般是指在两种文化之间进行的一种教育。

在英语当中，与之相近的词汇还有“cro-cultural educatio”（多种文化的教育）和“tra- culturaleducation”（异文化的教育）等。

从教育人类学的角度看，人类的一切教育活动都是建立在某种特定文化基础之上的，教育是文化传承的载体。

换言之，每一个人都具有一定的民族所属，而每一种教育也都与特定的民族文化密不可分。

按照教育的民族属性，它又可进一步划分为“单一文化教育”和“跨文化教育”两大类。

前者是指受教育者所受教育基本上仅局限于一个民族的文化，具有单一的民族属性，如早期的美洲印第安民族教育等。

而后者，则是在两种不同文化之间进行的。

如移民教育、殖民地教育、留学生教育、多民族国家中的少数民族教育和多元文化教育等，均属于跨文化教育的范畴。

也就是说，在单一层民族教育的背景上实施异文化教育的现象，都可以视为跨文化教育。

跨文化教育的实践，在人类历史上久而有之。

但人类对这一社会现象进行较为系统的科学研究，则始于本世纪。

特别是在美国等一些西方发达国家里，各界学者自20世纪上半叶起对跨文化教育问题进行了大量的调查和研究，并从不同的立场、目的和学科角度提出各自的观点和主张，形成了众多的理论派流。

时至今日，跨文化教育研究已从美国、英国、法国、德国扩展到加拿大、前苏联、澳大利亚、日本、东南亚及中国等诸多国家。

由于篇幅所限，本文仅择选一些影响较大的跨文化教育及相关理论流派作一简略介绍，供我国有关教育研究人员借鉴和参考。

一、文化变迁论1、文化人类学派的观点本世纪初期，伴随西方殖民地的扩大和传教士的布教等活动，西方文化源源不断地传入世界各地。

许多非西方国家在受到西方文化的强烈冲击后，其民族固有的传统文化迅速瓦解崩溃。

以此为背景，有关文化变迁的研究进一步引起世界各国人类学界的强烈关心。

reactive定义-回复Reactive programming is an innovative approach to software development that is gaining increasing popularity in recent years. In this article, we will delve into the concept of reactive programming, its main principles, and its advantages and applications in various industries.So, what exactly is reactive programming? In simple terms, it is a programming paradigm that focuses on the flow of data and events in a system, allowing for responsive and efficient applications. Reactive programming is based on the concept of reactive systems, which are capable of reacting and adapting promptly to changes in their environment.One fundamental principle of reactive programming is responsiveness. Reactive systems are designed to respond to events and changes in the environment in a timely manner. This means that they can quickly react to user input, network conditions, or system failures, ensuring that the application remains functional and responsive.To achieve this responsiveness, reactive programming relies onasynchronous and non-blocking processing. Traditional programming models often involve blocking operations, which means that the program execution is suspended until the completion of a certain task. In reactive programming, on the other hand, tasks are executed non-blocking, allowing the application to continue processing other tasks while waiting for a response.Reactive systems also emphasize a message-driven architecture. The communication between different components or services is based on the exchange of messages, allowing for loose coupling and enhanced scalability. By decoupling components through messages, reactive systems can handle fluctuations in load efficiently, ensuring that the system remains stable and responsive even under high demand.Another core principle of reactive programming is resilience. Reactive systems are designed to be fault-tolerant and resilient to failures. They achieve this through techniques such as error handling, fault recovery, and isolation. When a failure occurs, a reactive system is capable of handling the error gracefully, recovering from the failure, and continuing its operation without compromising the overall system stability.Now that we understand the main principles of reactive programming, it is important to explore its advantages and applications. Reactive programming has several benefits that make it attractive to developers and organizations. Firstly, it allows for the development of highly responsive and interactive applications, which enhances the user experience. Whether it is a web application, a mobile app, or a real-time analytics system, reactive programming enables developers to build applications that are fast and can react to user input in real-time.Furthermore, reactive programming facilitates scalability. With the increase in big data and distributed systems, scalability is becoming essential. Reactive systems, by nature, can handle large amounts of data and high loads while remaining stable and responsive. This scalability is achieved through the use of message-driven communication and asynchronous processing, which allow for efficient distribution and processing of data across different components or services.Reactive programming also promotes modularity and reusability. By following the principles of loose coupling and message-basedcommunication, reactive systems can be easily composed and integrated with other components or services. This modularity not only simplifies the development process but also encourages code reusability and maintainability.In terms of applications, reactive programming has found its place in various industries. It is particularly useful in domains that require real-time data processing and event-driven systems. For example, in finance, reactive programming is used to build high-frequency trading systems that can make split-second decisions based on market events. In the IoT (Internet of Things) domain, reactive programming enables the development of smart and responsive systems that can handle a vast amount of sensor data and react accordingly.In conclusion, reactive programming is a powerful paradigm that offers numerous benefits in terms of responsiveness, scalability, modularity, and resilience. By focusing on data flow andevent-driven architecture, reactive programming enables the development of highly interactive and efficient applications. Its applications span various industries, from finance to IoT, and itcontinues to gain popularity among developers and organizations looking to build responsive and adaptive systems. With its principles and advantages, reactive programming is undoubtedly shaping the future of software development.。

Reactive ObjectsJohan Nordlander,Mark P.Jones,Magnus Carlsson,Richard B.Kieburtz,and Andrew Black∗OGI School of Science&Engineering at OHSU,20000NW Walker Road,Beaverton,OR97006.AbstractObject-oriented,concurrent,and event-based program-ming models provide a natural framework in which to ex-press the behavior of distributed and embedded software sys-tems.However,contemporary programming languages stillbase their I/O primitives on a model in which the environ-ment is assumed to be centrally controlled and synchronous,and interactions with the environment carried out throughblocking subroutine calls.The gap between this view and thenatural asynchrony of the real world has made event-basedprogramming a complex and error-prone activity,despite re-cent focus on event-based frameworks and middleware.In this paper we present a consistent model of event-basedconcurrency,centered around the notion of reactive objects.This model relieves the object-oriented paradigm from theidea of transparent blocking,and naturally enforces reactiv-ity and state consistency.We illustrate our point by a pro-gram example that offers substantial improvements in sizeand simplicity over a corresponding Java-based solution.1BackgroundIn the traditional view of programming,the program isassumed to be the master of its environment,and interactionwith the environment is accordingly expressed in terms ofthe subroutine abstraction.This programming model datesback to the early age of batch-oriented computing,whenprogrammers saw a need to abstract away from low-leveldetails of peripheral devices—such as card-readers and line-printers—that were used at the time.The key idea here is thatblocking of execution is made transparent;that is,the pro-grammer is supposed not to be interested in knowing whethera subroutine obtains its result by some internal computation,or by means of synchronization with an external device.Despite many advances in language design,this sim-ple,traditional view of I/O still prevails in contemporaryobject-oriented languages.But modern software executes inmuch more complex environments,with interactive point-and-click graphics,ubiquitous networks,multiple threads ofensuring liveness and avoiding deadlocks.Notice,though,that in the AWT-plus-sockets scenario sketched above there is nothing that actually suggests con-current execution;what the extra threads achieve is really the ability to perform concurrent blocking.While concur-rency is an important tool in real-time programming,being forced to use it just to circumvent an inappropriate I/O model is not satisfactory.Also note that an abstract object model of the example would probably consist of just one simple ob-ject,equipped with methods corresponding to the events it is required to handle:mouse clicks,key presses,and packet arrivals.A central argument of this paper is that the heavy encodings needed to turn even simple event-driven models into working code is most unfortunate,and is an important factor behind the perceived complexity of concurrent object-oriented programming.The current practice of using threads to circumvent the traditional I/O model is extremely fragile,in the sense that an accidental call to a blocking operation in the middle of an event-handler will immediately destroy the responsive-ness of that thread.That is,transparent blocking makes re-sponsiveness a delicate property that can only be upheld by careful programming,requiring knowledge not only of the complex APIs that encode events and threads,but also of all operations which potentially might block,and which thus must be avoided.As an illustration,consider the following quote from the documentation for Java’s New I/O library[9]: That a selection key indicates that its channel isready for some operation is a hint,but not a guar-antee,that such an operation can be performed bya thread without causing the thread to block.Itis imperative that code that performs multiplexedI/O be written so as to ignore these hints when theyprove to be incorrect.Clearly some special skill or rigorous discipline is required to navigate safely through such dangerous waters.It is es-pecially noteworthy that this comment concerns a new li-brary with pretensions to make event-driven Java program-ming significantly easier than before.The idea of transparent blocking takes its most so-phisticated form in the remote-procedure-call paradigm,or remote-method-invocation(RMI)as it is called using Java terminology.Again,hiding the intricacies of synchroniza-tion with a remote machine under a familiar subroutine-like interface seems attractive atfirst,because it makes the code of distributed programs look quite similar to code written for use in a strictly local context.However,the similarity is deceptive.A defining aspect of a distributed system is usually that it is subject to partial failure;that is,programs are expected to continue running even if a remote server is down,broken,or otherwise unac-cessible.Contrast this to failures directly affecting the local node:here the failure of one component is equivalent to the whole node going down.So in order to hide distribution,the RMI paradigm must also hide the possibility of partial fail-ures.What this means is that failure of any remote machine in an RMI setup is equivalent to a total system failure.In practice,RMI-based programs can only regain some form of robustness by protecting the remote invocations by timeouts and exception handlers.However,this of course also makes the RMI paradigm considerably less convenient(and distri-bution less transparent)[8].2Reactive objectsThe conclusion we have drawn from the problems asso-ciated with transparent blocking and batch-oriented I/O is that significantly more robust event-based software can be obtained by abandoning indefinite blocking altogether,and letting an event-driven design permeate the whole program-ming model.Thread packages,design patterns,and various middleware layers can only do so much to alleviate the pro-grammer from a fundamentally computer-centric view,and they cannot help at all with enforcing responsiveness as long as every method call has a potential of blocking.Our alternative programming model takes as its start-ing point the intuition behind the classical object-oriented paradigm:objects are autonomous,objects maintain a state, objects have methods,methods execute in response to mes-sages.The main step towards a reactive variant of this model is to relieve the classical model from any ties to the tra-ditional way of viewing I/O.In its place,a more orthodox object-oriented scheme of interaction can be devised:•input—the environment calls a method of a program object•output—the program calls a method of an environment objectMethod calls in these categories do not just carry data,they can also be seen as representing the actual input and output events themselves.Notice in particular the asymmetry be-tween input and output that results from this scheme:output is a concrete act of the program,while input is modelled as a passive capability to react.In other words,objects have full control over the output events,but leave the input events to be scheduled by the environment.The autonomy and integrity of objects is essential to this view,though.Just as it is usually beneficial to view real-world objects as having a certain level of atomicity of op-eration,so is it essential to keep software objects from be-coming invaded by multiple method invocations at the same time.On the other hand,the concurrent operation of distinct objects is a natural aspect of the real world,and we wish ourreactive objects to support the same intuition.We therefore take it as a semantic foundation of our model thatevery object is an autonomous unit of executionthat is either executing the sequential code of ex-actly one method,or passively maintaining itsstate.The combination of inter-object concurrency with internal sequential execution effectively makes a reactive object a union of the well-known concepts of an encapsulated state and a critical region.Because objects are autonomous execution units,it makes sense to distinguish between asynchronous and synchronous method invocations.In the former case,the sender of a mes-sage continues execution in parallel with the receiving ob-ject,whereas in the latter case,the sender and receiver per-form a rendezvous.Of course,only synchronous methods provide an opportunity to directly return a result from the receiver to the sender of a message.At afirst glance,synchronous methods seem to provide a way of reintroducing traditional input methods like getc in the model.We do however make an important restriction that will prohibit such use:no methods—in environments or in programs—must block execution indefinitely.This restriction rules out language constructs like selective methodfiltering,as well as environments that provide naive interfaces to blocking system calls.All that a synchronous method call can do is to compute a reply based on the current state of the receiver,possibly after performing some side-effects.The serialization of all method executions of the re-ceiving object does not change the fact that a synchronous method is essentially an ordinary subroutine,since,by an argument of transitivity,if the receiver is not ready to imme-diately execute a synchronous call,it must be busy servicing one of the non-blocking calls that stand in the way.Reactive objects thus alternate between phases of passive inactivity and temporary outbursts of method execution.In contrast to so called active objects,a reactive object does not have a continuous thread of execution;all executable code of an object is defined in terms of its methods.A method of a reactive object is furthermore guaranteed to ter-minate,provided that it does not deadlock or enter an infinite loop.However,due to the absence of blocking constructs in this model,the only source of deadlock is the synchronous method call,and a cyclic chain of such calls is easily de-tectable at run-time.The reactive object model has been realized in the lan-guage Timber that we will survey in the next section.The model is general enough,though,that we would like to sum-marize a few informal claims about its properties before we go into language details.•Reactive objects is a simple and natural model of event-driven systems on various level of detail,from hardware devices to full distributed applications.•It is a straightforward integration of concurrency and object-oriented programming,with the added bonus of automatic protection of state consistency.•A single reactive object can easily handle input from multiple asynchronous sources.•Under assumptions of freedom from non-termination and a very simple form of detectable deadlock,a re-active object is also guaranteed to be responsive in all states.3Reactive objects in TimberWe will now give the model of reactive objects a more concrete form,by showing how it is realized in the pro-gramming language Timber[4].Timber is a strongly typed, object-oriented language with constructs specifically aimed at real-time programming;however,its foundation in the re-active object model makes it suitable as a general purpose language as well.We will introduce Timber by a small pro-gramming example,after pointing out some distinguishing details.•In the syntax of Timber,=denotes a definition,let intro-duces local definitions,f x y is a function f applied to two arguments,and:=is assignment to a state vari-able.•Methods havefirst-class status:they can be passed as parameters and stored in data structures.•Commands and declarations are grouped using layout.Our example is a variant of the program Ping.java from the New I/O API in Java1.4.This program demonstrates how to concurrently measure the time it takes to connect to a particular TCP port on a number of remote hosts.The Tim-ber source is shown in Figure1,and the output of a typical run looks as follows:dogbert:20.018msratbert:41.432msratburg:NetError"lookup failure"theboss:no responsePing is implemented as an object template(i.e.,a class). It is parameterized over a list of hosts and a port number, and a record env that contains methods for interacting with the environment.Templates define a number of state vari-ables as well as an interface,which is typically a record of methods that the environment can invoke.All methods inping hosts port env=templateoutstanding:=hostsin letclient host start peer=recordconnect=actionenv.putStrLn(host++":"++show(baseline-start))outstanding:=remove host outstandingpeer.closeneterror err=actionenv.putStrLn(host++":"++show err)outstanding:=remove host outstandingdeliver pkt=action doneclose=action donecleanup=actionforall h<-outstanding doenv.putStrLn(h++":no response")env.quitin recordmain=actionforall h<-hosts doenv.inet.tcp.open h port(client h baseline) after(2*seconds)cleanupFigure1.Ping in Timberthis example are asynchronous(as determined by the action keyword).The Ping program is started by creating an instance of the template,and then invoking its main method.Internally, Ping objects maintain the state variable outstanding,a list of hosts from which a response has not been seen.The main method calls inet.tcp.open of the environment in order to initiate a TCP connection to the designated port on every given host(forall expresses a loop construct,with h as a loop variable).These calls do not wait for the connection to complete,though;instead,the local method connect is set up to be invoked when the connection has been established. The record client used for this purpose is parameterized over the host we are trying to connect to,the start time of the program,and an environment-provided record contain-ing methods for communicating with the peer host.For tim-ing purposes,actions can refer to the pre-defined variable baseline,which is set to the arrival time of the event that triggered the action.After all connections have been initiated,the asyn-chronous method cleanup is scheduled to be called two seconds after the baseline of main.Note that nowhere does the execution of main block,it just sets up other actions to react to future events.All methods of an object can safely manipulate its state variables in a single-threaded fashion. E.g.,it is irrele-vant here that some methods are defined within the record client,and others elsewhere.Thisflexibility allows us to express a straightforward solution using only one object, with a single state variable.In contrast,the Java program is 287lines of code,has ten class variables,and needs three threads:one for the demultiplexing of connection events, one for single-threaded printing,and one for timeout.4Related workThe reactive object model described in this paper was first developed for the programming language O’Haskell[7]. The current work is,however,ourfirst attempt to distill the programming model as a contribution in its own right. Our language Timber inherits much of its basic design from O’Haskell,but adds several important features,of which the notion of a time-constrained reaction is the most relevant to this paper.Current work on reactive languages is mostly concerned with the synchronous approach to reactivity[3,5].The main hypotheses made in this model are that computations take zero time and event delivery is instantaneous.From these as-sumptions it follows that events received or generated some-where between two clock ticks are actually occurring simul-taneously,and hence,for example,multiple invocations of a particular method during an instant must be indistinguish-able from just a single invocation.The unification of the object and process concepts is an idea that stems from the Actor model[1,2].However,the state of an actor is identified with its current mapping from names to method bodies,and messages to undefined meth-ods are simply queued.Hence actors do not possess the re-sponsiveness property we are emphasizing with our model. Moreover,the Actor model lacks anything similar to our syn-chronous methods,and asynchronous message delivery is not order-preserving.References[1]G.Agha.Actors:A Model of Concurrent Computation in Dis-tributed Systems.MIT Press,1986.[2]G.Agha,I.A.Mason,S.F.Smith,and C.L.Talcott.A foun-dation for actor computation.Journal of Functional Program-ming,7:1–72,1997.[3] A.Benveniste and G.Berry.The Synchronous Approachto Reactive and Real-time Systems.Technical Report1445, INRIA-Rennes,1991.[4] A.P.Black,M.Carlsson,M.P.Jones,R.Kieburtz,and J.Nord-lander.Timber:A programming language for real-time em-bedded systems.Technical Report,/ PacSoft/projects/Timber/,April2002.[5] F.Boussinot,G.Doumenc,and J.Stefani.Reactive Objects.Annals of Telecommunications,51(9-10):459–473,1996. [6]P.Chan and R.Lee.The Java Class Libraries,Second Edition,Volume2.Addison-Wesley,1997.[7]J.Nordlander.Reactive Objects and Functional Programming.PhD thesis,Department of Computer Science,Chalmers Uni-versity of Technology,G¨o teborg,Sweden,May1999.[8]J.Waldo,G.Wyant,A.Wollrath,and S.Kendall.A Noteon Distributed Computing.Technical Report SMLI TR-94-29, Sun Microsystems Laboratories,Inc.,Nov.1994.[9]J.Zukowski.New I/O Functionality for Java2Stan-dard Edition 1.4./developer/ technicalArticles/releases/nio/,October2001.。