Functional Language

A student learning how to program learns best when the programming language and programming environment cater to her specific needs. These needs are different from the requirements of a professional programmer. Consequently, the design of teaching languages poses challenges different from the design of "professional" languages. Using a functional language by itself gives advantages over more popular, professional languages, but fully exploiting these advantages requires careful adaptation to the needs of the studentsas-is, these languages do not support the students nearly as well as they could. This paper describes our experience adopting the didactic approach of How to Design Programs, focussing on the design process for our own set of teaching languages. We have observed students as they try to program as part of our introductory course, and used these observations to significantly improve the design of these languages. This paper describes the changes we have made, and the journey we took to get there. 1 We were wrong about the course on other aspects as well .

This paper presents a programming language which includes paradigms that are usually associated with declarative languages, such as sets, rules and search, into an imperative (functional) language. Although these paradigms are separately well known and are available under various programming environments, the originality of the CLAIRE language comes from the tight integration, which yields interesting run-time performances, and from the

Many studies have investigated sex differences in language lateralization. Despite the large number of investigations, controversy about the presence of sex differences in lateralization remains. This study aims to provide a complete overview of sex differences in several reflections of language lateralization: handedness, asymmetry of the Planum Temporale (PT) and functional lateralization of language, measured by asymmetric performance on dichotic listening tests (Right Ear Advantage) and asymmetry of language activation as measured with functional imaging techniques. Meta-analysis of studies that assessed handedness in males and females yielded more left-handedness in males (mean weighted odds ratio: 1.25, p b 0.001).

Interprocedural analyses enable optimizing compilers to more precisely model the effects of non-inlined procedure calls, potentially resulting in substantial increases in application performance. Applying interprocedural analysis to programs written in object-oriented or functional languages is complicated by the difficulty of constructing an accurate program call graph. This paper presents a parameterized algorithmic framework for call graph construction in the presence of message sends and/or firstclass functions. We use this framework to describe and to implement a number of well-known and new algorithms. We then empirically assess these algorithms by applying them to a suite of medium-sized programs written in Cecil and Java, reporting on the relative cost of the analyses, the relative precision of the constructed call graphs, and the impact of this precision on the effectiveness of a number of interprocedural optimizations.

We describe and document our experience from developing an AMD64 backend for the HiPE (High Performance Erlang) native code compiler. We consider implementation alternatives and critically examine design choices for obtaining an efficient AMD64 backend. In particular, we consider in detail how other functional language implementors can migrate their existing x86 backends to the AMD64 architecture, a platform which is becoming increasingly important these days. We mention backend components that can be shared between x86 and AMD64, and those that better be different for achieving high performance on AMD64. Finally, we measure the performance of several different alternatives in the hope that this information can save development effort for others who intend to engage in a similar feat.

We introduce a direct encoding of the typed λ-calculus into Java: for any Java types A, B we introduce the type A → B together with function application and λ-abstraction. The latter makes use of anonymous inner classes. We show that λ-terms are evaluated by call-by-value. We then look at how to model domain equations in Java and as an example consider the untyped lambda calculus. Then we investigate the use of function parameters in order to control overriding and in order to dynamically update methods, which can substitute certain applications of the state pattern. Further we introduce a foreach-loop in collection classes. Finally we introduce algebraic types. Elements of the resulting type are given by their elimination rules. Algebraic types with infinitely many arguments like Kleene's O and simultaneous algebraic types are already contained in that notion. Further we introduce an operation selfupdate, which allows to modify for instance a subtree of a tree, without making a copy of the original tree. All the above constructions are direct and can be done by hand.

We describe XLambda, a functional language with XML syntax, and its processor which is implemented fully and completely in XSLT. XLambda has all the basic features of a functional language, such as defining named functions, operations on numbers, passing functions as parameters, constructing arbitrary data structures etc. What sets XLambda apart from the rest of the functional languages is not its feature set though, but rather its syntax and processor which is implemented as an XSLT stylesheet. Since most Web browsers have XSLT processors already built in, XLambda has the potential to be used as a scripting language in Browsers, much in the same way as JavaScript, among other possibilities.

This article, based on a 34,000-word corpus of spoken discourse, argues for a discourse approach to teaching communicative functions or speech acts in spoken English. Starting with the premise that spoken corpora can provide valuable insights into the way speakers 'do' things through talk, I analyze the performance of speech acts in a corpus of workplace conversations. First a number of devices used to perform direct speech acts are analyzed in the corpus as a whole, and then the transcripts of two workplace conversations are examined in order to ascertain how the performance of two particular speech acts-giving advice and giving directives-is accomplished. These analyses show that speech acts are not usually performed directly and that it is necessary to look beyond the individual utterance to see how particular communicative acts unfold within a conversational sequence. The final section of the article discusses relevance of these findings for the teaching of functional language. #

In engineering design, all products and artifacts have some intended reason behind their existence: the product or artifact function. Functional modeling provides an abstract, yet direct, method for understanding and representing an overall product or artifact function. Functional modeling also strategically guides design activities such as problem decomposition, physical modeling, product architecting, concept generation, and team organization. A formal function representation is needed to support functional modeling, and a standardized set of function-related terminology leads to repeatable and meaningful results from such a representation. We refer to this representation as a functional basis; in this paper, we seek to reconcile and integrate two independent research efforts into a significantly evolved functional basis. These efforts include research from the National Institute of Standards and Technology and two US universities, and their industrial partners. The overall approach for integrating the functional representations and the final results are presented. This approach also provides a mechanism for evaluating whether future revisions are needed to the functional basis and, if so, how to proceed. The integration process is discussed relative to differences, similarities, insights into the representations, and product validation. Based on the results, a more versatile and comprehensive design vocabulary emerges. This vocabulary will greatly enhance and expand the frontiers of research in design repositories, product architecture, design synthesis, and general product modeling.

A three-year study collected information bearing on the question of whether studying mathematics improves programming skills. An analysis of the data revealed significant differences in the programming effectiveness of two populations of students: (1) those who studied discrete mathematics through examples focused on reasoning about software and (2) those who studied the same mathematical topics illustrated with more traditional examples. Functional programming played a central role in the study because it provides a straightforward framework for the presentation of concepts such as predicate logic and proof by induction. Such topics can be covered in depth, staying almost entirely within the context of reasoning about software. The intricate complexities in logic that mutable variables carry with them need not arise, early on, to confuse novices struggling to understand new ideas. In addition, because functional languages provide useful and compact ways to express mathematical concepts, and because the choice of notation in mathematics courses is often at the discretion of the instructor (in contrast to the notational restrictions often fiercely guarded by the faculty in programming courses), discrete mathematics courses, as they are found in most computer science programs, provide an easy opportunity to enhance the education of students by exposing them to functional programming concepts.

This paper summarizes experiences from an open source project that builds a free Haskell IDE based on Eclipse (an open source IDE platform). Eclipse is extensible and has proved to be a good basis for IDEs for several programming languages. Difficulties arise mainly because it is written in Java and requires extensions to be written in Java. This made it hard to reuse existing development tools implemented in Haskell, and turned out to be a considerable obstacle to finding contributors. Several approaches to resolve these issues are described and their advantages and disadvantages discussed.

an NSF Graduate Research Fellowship and NSF and Darpa grants to the Fugu and Raw projects. While provided a vital support network. Most of all, I have relied on my wife, Kathleen Shannon, and my children, Karissa and Anya. Their love has carried me through this period. Without them none of this would have been possible, or worth doing.

We investigate the claim that functional languages o er low-cost parallelism in the context of symbolic programs on modest parallel architectures. We base our investigation on several large programs that we have written or parallelised in Glasgow Parallel Haskell (GpH). The programs cover a range of application areas, use several parallel programming paradigms, and are measured on two very di erent parallel architectures.

The neuropsychological effects of Parkinson's disease have gained wide recognition in recent literature. Effects have been documented in almost all areas of cognitive functioning, including general intellectual functioning, visual-spatial functioning, executive functions, attention and memory functions, language functions, and affective processes. Visual-spatial functions, memory functions, and executive functions have received particular interest. This review of the literature is an attempt to tie together the large number of studies in these cognitive areas and to present a suggestion for a comprehensive neuropsychological battery tailored to the patient with Parkinson's disease. Throughout the review, factors relevant to Parkinson's disease, e.g., dementia, motor symptoms, and hemiparkinsonism, are considered.

In previous work we have proposed a Dependent Hoare Type Theory (HTT) as a framework for development and reasoning about higher-order functional programs with effects of state, aliasing and nontermination. The main feature of HTT is the type of Hoare triples {P }x:A{Q} specifying computations with precondition P and postcondition Q, that return a result of type A.

We examine the addition of Lambda expressions to Forth. We briefly review the Lambda calculus and introduce a postfix version of Lambda notation to guide our approach to a Forth implementation. The resulting implementation provides the basic facilities of an early binding functional language, allowing the treatment of functions as first-class objects, manipulation of anonymous functions, and closures.

Parallel (lazy) functional programs must describe both computation and coordination, i.e., what to compute and how to arrange the computation in parallel. The formal manipulation of the behaviours of such programs requires a semantics which accurately captures lazy evaluation, and the dependence of execution on the availability of (physical) resources. In this paper we present a lockstep semantics as a

When distributed systems first appeared, they were programmed in traditional sequential languages, usually with the addition of a few library procedures for sending and receiving messages. As distributed applications became more commonplace and more sophisticated, this ad hoc approach became less satisfactory. Researchers all over the world began designing new programming languages specifically for implementing distributed applications. These languages and their history, their underlying principles, their design, and their use are the subject of this paper. We begin by giving our view of what a distributed system is, illustrating with examples to avoid confusion on this important and controversial point. We then describe the three main characteristics that distinguish distributed programming languages from traditional sequential languages, namely, how they deal with parallelism, communication, and partial failures. Finally, we discuss 15 representative distributed languages to give ...

QuickCheck is a tool which aids the Haskell programmer in formulating and testing properties of programs. Properties are described as Haskell functions, and can be automatically tested on random input, but it is also possible to dene custom test data generators. We present a number of case studies, in which the tool was successfully used, and also point out some pitfalls to avoid. Random testing is especially suitable for functional programs because properties can be stated at a ne grain. When a function is built from separately tested components, then random testing su ces to obtain good coverage of the de nition under test.

Datatype-generic programming is defining functions that depend on the structure, or "shape", of datatypes. It has been around for more than 10 years, and a lot of progress has been made, in particular in the lazy functional programming language Haskell. There are more than 10 proposals for generic programming libraries or language extensions for Haskell. To compare and characterize the many generic programming libraries in a typed functional language, we introduce a set of criteria and develop a generic programming benchmark: a set of characteristic examples testing various facets of datatype-generic programming. We have implemented the benchmark for nine existing Haskell generic programming libraries and present the evaluation of the libraries. The comparison is useful for reaching a common standard for generic programming, but also for a programmer who has to choose a particular approach for datatype-generic programming.

A challenge for grid computing is finding abstractions that separate concerns about what a grid application must achieve from the specific resources on which it might be deployed. One approach, taken by a range of toolkits and APIs, is to add further layers of abstraction above the raw machine and network, allowing explicit interaction with grid services. The developers ’ view, however, remains that of a stateful von Neumann machine, and the interleaving of grid services with domain computations adds complexity to systems. An alternative is to replace this tower of abstraction with a new kind of programming structure, one that abstracts away from complexities of control and location while at the same time adapting to local resources. This paper reports early results from a project exploring the use of functional language technologies for computationally demanding problems in data visualization over the grid. Advances in functional language technology mean that pure languages such as...

The interface with the outside world has always been one of the weakest points of functional languages. It is not easy to incorporate I/O without being allowed to do side-effects. Furthermore, functional languages allow redexes to be evaluated in any order while I/O generally has to be performed in a very specific order.

Functional programming languages are shown to be useful in the teaching of the concepts of recursion and iteration. The functional language approach presented in this paper has advantages over imperative languages in the area of analysis of recursive and iterative algorithms. Examples using the J and Scheme programming languages, with emphasis on the use of functional programming notation in exposition are given. 1

This paper presents the implementation of a web services proxy generator for the Haskell functional language. Its purpose is to free Haskell programmers from low-level implementation details when building applications that consume services offered through the Web. The generator architecture, as well as implementation experiences resulting from the specific web services access/proffer model, is detailed. The final purpose is to show that Haskell and functional languages in general can be effectively used to implement distributed components and applications, interacting with services implemented in different languages and/or platforms.

The problem of designing a domain-specific language (DSL) can be split into two subproblems: a) defining the language constructs starting from an appropriate set of abstractions in the domain, and b) choosing a syntax that resembles the standard notation, or is otherwise as intuitive as possible from a domain expert standpoint. We propose as a solution a minimal functional language which can be extended syntactically and semantically as needed. The extension process is performed from within the language itself, using a set of reflective facilities, and such process is dynamic (i.e. performed at run-time), thus enabling the programmer to try new constructs as soon as they are defined. We believe this kind of frameworks have not been yet fully exploited in the field of DSL design and implementation.

Dynamic binding, which traditionally has always been associated with Lisp, is still semantically obscure to many. Even though most programming languages favour lexical scope, not only does dynamic binding remain an interesting and expressive programming technique in specialised circumstances, but also it is a key notion in formal semantics. This article presents a syntactic theory that enables the programmer to perform equational reasoning on programs using dynamic binding. The theory is proved to be sound and complete with respect to derivations allowed on programs in "dynamic-environment passing style". From this theory, we derive a sequential evaluation function in a context-rewriting system. Then, we further refine the evaluation function in two popular implementation strategies: deep binding and shallow binding with value cells. Afterwards, following the saying that deep binding is suitable for parallel evaluation, we present the parallel evaluation function of a future-based functional language extended with constructs for dynamic binding. Finally, we exhibit the power and usefulness of dynamic binding in two different ways. First, we prove that dynamic binding adds expressiveness to a purely functional language. Second, we show that dynamic binding is an essential notion in semantics that can be used to define exceptions.

This paper presents a practical evaluation and comparison of three state-of-the-art parallel functional languages. The evaluation is based on implementations of three typical symbolic computation programs, with performance measured on a Beowulf-class parallel architecture.

The presence of non-determinism in the parallel-functional language Eden creates some problems. Several non-determinism analyses have been developed to determine when an Eden expression is sure to be deterministic, and when it may be non-deterministic. The correctness of these analyses had not been proved yet. In this paper we define a "maximal" denotational semantics for Eden in the sense that the set of possible values produced by an expression is bigger than the actual one. This semantics is enough to prove the correctness of the analyses. We provide the abstraction and concretisation functions relating the concrete and abstract values so that the determinism property is adequately captured. Finally we prove the correctness of the analyses with respect to the previously defined semantics.

In this paper, some experiences of using the concurrent functional language Erlang to implement a classical vertical application, a risk management information system, are presented. Due to the complex nature of the business logic and the interactions involved in the client/server architecture deployed, traditional development techniques are unsatisfactory. First, the nature of the problem suggests an iterative design approach. The use of abstractions (functional patterns) and compositionality (both functional and ...

Ane size-change analysis has been used for termination analysis of eager functional programming languages. The same style of analysis is also capable of compactly recording and calculating other properties of programs, including their runtime, maximum stack depth, and (relative) path time costs. In this paper we show how precise poly- nomial bounds on such costs may be calculated on programs,

We introduce a direct encoding of the typed λ-calculus into Java: for any Java types A, B we introduce the type A → B together with function application and λ-abstraction. The latter makes use of anonymous inner classes. We show that λ-terms are evaluated by call-by-value. We then look at how to model domain equations in Java and as an example consider the untyped lambda calculus. Then we investigate the use of function parameters in order to control overriding and in order to dynamically update methods, which can substitute certain applications of the state pattern. Further we introduce a foreach-loop in collection classes. Finally we introduce algebraic types. Elements of the resulting type are given by their elimination rules. Algebraic types with infinitely many arguments like Kleene's O and simultaneous algebraic types are already contained in that notion. Further we introduce an operation selfupdate, which allows to modify for instance a subtree of a tree, without making a copy of the original tree. All the above constructions are direct and can be done by hand.

We consider the problem of functional programming with data in external memory, in particular as it appears in sublinear space computation. Writing programs with sublinear space usage often requires one to use special implementation techniques for otherwise easy tasks, e.g. one cannot compose functions directly for lack of space for the intermediate result, but must instead compute and recompute small parts of the intermediate result on demand. In this paper, we study how the implementation of such techniques can be supported by functional programming languages. Our approach is based on modelling computation by interaction using the Int construction of Joyal, Street & Verity. We derive functional programming constructs from the structure obtained by applying the Int construction to a term model of a given functional language. The thus derived functional language is formulated by means of a type system inspired Baillot & Terui's Dual Light Affine Logic. We assess its expressiveness by showing that it captures LOGSPACE.

URL do documento original: <http://urlib.net/xx/yy> INPE São José dos Campos 2012 Dados Internacionais de Catalogação na Publicação Copyright © 2012 do MCT/INPE. Nenhuma parte desta publicação pode ser reproduzida, armazenada em um sistema de recuperação, ou transmitida sob qualquer forma ou por qualquer meio, eletrônico, mecânico, fotográfico, reprográfico, de microfilmagem ou outros, sem a permissão escrita do INPE, com exceção de qualquer material fornecido especificamente no propósito de ser entrado e executado num sistema computacional, para o uso exclusivo do leitor da obra. Copyright © 2012 by MCT/INPE. No part of this publication may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, microfilming or otherwise, without written permission from the INPE, with the exception of any material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use of the reader of the work. ___________________________________________________________________ Costa, Sérgio Souza. 6 AGRADECIMENTOS Neste curto espaço, quero deixar o meu MUITO OBRIGADO a todos que participaram desta jornada. Aos meus orientadores: Gilberto Câmara, que desde o mestrado sempre confiou e acreditou em mim e a Ana Paula que sempre esteve ao meu lado nos momentos mais difíceis. A vocês o meu muito obrigado, jamais esquecerei o quanto vocês foram importantes para eu alcançar esta etapa. Não posso esquecer do Professor Paulo Lima e do Antônio Miguel, que me apresentaram e mostraram um horizonte que jamais teria sonhado. Agradeço ainda, ao Instituto Nacional de Pesquisas Espaciais -INPE, pela oportunidade de estudos e utilização de suas instalações. Também deixo meu muito obrigado aos professores da CAP pelos valiosos ensinamentos. Em especial ao querido e competente Professor Demísio (in memoriam), que muito contribuiu todas as vezes que tive a felicidade de tê-lo nas minhas bancas examinadoras. Além dos professores, agradeço também aos coordenadores e secretárias, por sua ajuda e compreensão. À Coordenação de Aperfeiçoamento de Pessoal de Nível Superior -CAPES, pela concessão de bolsa. Aos grandes amigos que fiz no INPE comoentre outros, que de uma forma ou de outra ajudaram na conclusão deste trabalho. 7 A meus pais, Antônio e Iracema, que me educaram, me apoiaram em todos momentos da vida e ainda por todo amor dado, um eterno obrigado. A meus irmãos, Gilberto Aparecido, Maria, Marli, Toninho, Fernando, Rinaldo, Vanda e Marcio, por todo apoio e amizade. E a meus queridos sobrinhos e cunhados. E a minha estimada vó, in memoriam, Marilis, pela grande mulher que foi e a quem eu devo a bela família que tenho. A minha esposa, Evaldinolia, que soube compreender e suportar os mais diversos desafios. Meu muitíssimo obrigado.

The Natural Language Paradigm (NLP) has proven effective in increasing spontaneous verbalizations for children with autism. This study investigated the use of NLP with older adults with cognitive impairments served at a leisure-based adult day program for seniors. Three individuals with limited spontaneous use of functional language participated in a multiple baseline design across participants. Data were collected on appropriate and inappropriate vocalizations with appropriate vocalizations coded as prompted or unprompted during baseline and treatment sessions. All participants experienced increases in appropriate speech during NLP with variable response patterns. Additionally, the two participants with substantial inappropriate vocalizations showed decreases in inappropriate speech. Implications for intervention in day programs are discussed.

This paper describes Hume: a novel domain-specific language whose purpose is to explore the expressibility/costability spectrum in resource-constrained systems, such as real-time embedded or control systems. Hume provides a number of high level features including higherorder functions, polymorphic types, arbitrary but sized user-defined data structures, asynchronous processes, lightweight exception handling, automatic memory management and domain-specific metaprogramming features, whilst seeking to guarantee strong space/time behaviour and maintaining overall determinacy.