Functional Programming in Computer Science

The pedagogical desirability of functional programming is effectively swamped by an overwhelmingly imperative‐language‐oriented culture. Because a meaningful subset of the functional paradigm is accessible within imperative languages, it is possible to identify a subset of Modula‐2 that characterizes the functional paradigm subset. A series of list‐processing problems and their solutions in the Modula‐2 subset provides students with ample exposure to the practice and theory of functional programming. Extension to the full functional paradigm and migration to specialized functional languages are managed, in the worst case by initial pseudo‐Modula‐2 programming involving hypothetical extensions supporting higher‐order functions and polymorphism. More powerful solutions to this problem are foreshadowed, in the form of preprocessor implementations of Modula‐2‐ and Ada‐derivative functional languages.

Philosophy enriches and dynamizes a science in its development. The choice of a good philosophical system becomes an unproductive debate but is essential in gaining an understanding of the importance of developing a coherent and comprehensive framework of thought to understand social phenomena. This research is a scientific reflection on the question of the best choice of philosophical systems and the belief in the existence of absolute and relativistic philosophy. This scientific reflection uses a qualitative narrative method in a literature review to answer the research question. Based on the research results, the author sees that a philosophical system has a specificity in contributing to the field of life and science independently. The author also provides a review of answers to the choice of a philosophical system that is suitable for the Doctoral program in Computer Science, namely Information Systems. The answer to the existence of a coherent philosophical system that underlies human wisdom is presented by the author in this paper. This scientific reflection is expected to contribute to the science of knowledge, especially the philosophy of science and the application of research stages in the field of Computer Science. Further research needs to be done to obtain the accuracy of a philosophical system that is suitable for the research topic and other fields of science.

Aim/Purpose: The purpose of this study is to identify how Advanced level Mathematics and Mathematics course units offered at university level do impact on the academic performance of theoretical Computer Science course units. Background: In Sri Lankan state universities, students have been enrolled only from the Physical Science stream to do a degree program in Computer Science. In addition to that, universities have been offering some course units in Mathematics to provide the required mathematical maturity to Computer Science undergraduates. Despite of this it is observed that the failure rates in fundamental theoretical Computer Science course units are much higher than other course units offered in the general degree program every year. Methodology : Academic records comprised of all 459 undergraduates from three consecutive batches admitted to the degree program in Computer Science from a university were considered for this study. Contribution: This study helps academics in identifying suitable curricula for Mathematics course units to improve students’ performance in theoretical Computer Science courses. Findings: Advanced level Mathematics does not have any significant effect on the academic performance of theoretical Computer Science course units. Even though all Mathematics course units offered were significantly correlated with academic performance of every theoretical Computer Science course unit, only the Discrete Mathematics course unit highly impacted on the academic performance of all three theoretical Computer Science course units. Further this study indicates that the academic performance of female undergraduates is better than males in all theoretical Computer Science and Mathematics course units. Future Research: Identifying other critical success factors contributing to the students’ academic performance of the theoretical Computer Science through empirical studies

Introduction The computing sciences are complex fields that combine both theoretical and practical components. Students successfully completing an undergraduate computer science program should have instruction in both the mathematical and theoretical foundations of computing as well as the more practical aspects of how to effectively use computers to solve problems. Software engineering, as its name implies, is more directed toward the practical aspects of how to successfully develop complex systems that meet user requirements and are reliable, usable, and maintainable. Computing Curricula 2005 recognizes the need for more extensive education to produce professional engineers than what can be reasonably provided in a typical computer science program (ACM, 2005). As such, they propose engineering be treated as a totally separate discipline within computer science education. However, while there has been some debate about the exact role engineering should have in a computer science program (Curran, 2003), the ACM Curricula has maintained the importance of engineering to all computer science students and has kept it as a core element in computer science education (ACM, 2008). For purposes of this paper, we will focus on the teaching of engineering within the computer science discipline. Unlike other topics in the computer science major, the techniques and principles taught in engineering are often first developed and refined in industry before arriving in the classroom. As commercial development techniques and tools evolve, so pedagogical methodologies change. Computer science educators have taken different approaches to teaching engineering over the years, both as a result of changing methodologies as well as individual beliefs about what teaching methods work best in a particular academic environment. This paper is a case study in applying current productivity tools (specifically Redmine) in a engineering course at our institution. The objectives of the study are to investigate how to integrate the tools into the existing structure and evaluate their impact. We describe our experience in recently changing our approach to teaching engineering to be more aligned with current tools and how to effectively use them in an academic environment. The paper begins with an overview of engineering teaching methods, then describes our traditional approach and motivation for changing, how the new approach was integrated into the course, our experience with the change, and, finally, our plans for the future Software Engineering Education Background Software Engineering is defined as the application of a systematic, disciplined, quantifiable approach to the development, operation and maintenance of software (Petkovic, Thompson, & Todtenhoefer, 2006, p. 294). The need to teach engineering in colleges has been identified for decades. Stiller & LeBlanc (2002) point out as far back as the early 1990's, ACM Computing Curricula suggested that the at least one engineering course should be required in accredited computer science programs. They point out that the number of large projects in industry demand this and suggest that the proof of the success of these accredited computer science programs should be seen in the reduction of failure in the design and operation of large computer programs. Software engineering programs can be thought of as a replacement for the old apprenticeship programs which taught the trades to workman (Stroulia, Bauer, Craig, Reid, & Wilson, 2011). The issue, however, is how to bring this effect into the classroom. Many educators feel that current practices of teaching engineering are not adequately preparing students for the real world of development. Nurkkala & Brandle (2011) summarize the problems with current teaching approaches: * No product--students are creating projects, not commercial grade products * Short duration--single semester, or two-semester, courses impose an artificial time constraint * High turnover--new students each semester means the talent pool remains shallow and student skills are not developing based on previous experience * Low complexity--by necessity given time constraints and skill sets * No maintenance--as a result of short duration, students do not experience a key aspect of development, the maintenance phase * No customer--most engineering projects do not interface with a real customer To address these shortcomings, different approaches to teaching engineering have emerged and been proposed in the literature. …

Proceedings of the 13th ACM SIGPLAN international conference on Functional programming

Lifelong learning is an important part in the career of an engineer in computer sciences. In this paper the characteristics of life long learning in Computer Sciences are worked out. In 2007 the European Commission launched a lifelong learning programme to enables people at all stages of their lives to take part in stimulating learning experiences. A network of seven European universities started within this programme a project designing a Master program in Computer Science that appeals to non-traditional students who may wish to study on a part-time and/or intermittent basis, in an international framework. (EMaCS means European Master Program in Computer Science) This paper describes how the EMaCS project approaches to the life long learning problems in Computer Science.

One of the important objectives of computer science (programming) education is to develop fundamental proficiency in the area of computer programming. Knowledge of programming is so important that almost all computer science programs include it in their curriculum. This important subject is widely reported as being challenging for novices especially in the very beginning early lessons. Study on bilingual language instructions shows that use of native language instructions help students to understand the subject better and use of secondary language instructions increase their social context of choice. When a learner learns through a language other than the mother tongue, learner faces problems because his task becomes two-fold. The first is that the learner has to make sense of the instructional tasks, which are presented in the second language or an interactive manner, and the second is Learner has to get linguistic competence that is required for effective learning to take place.

Good morning. Let me welcome you to WIA '96, the first international workshop on implementing automata. This is the first of what I hope will be a continuing series of workshops investigating software for formal language theory. I would like to take a few minutes to explain the origins of this workshop, and to tell you some of my ideas about its philosophy. Whence WIA? Why the need for a workshop of this type? As there are already many (perhaps too many) computer science conferences and workshops, any new meeting faces a rather stiff need to justify its existence. WIA came about primarily because there is no other good forum for systems that support symbolic computation with automata. Systems that we know about include Howard Johnson's INR, Bruce Watson's Fire Lite, Susan Rodger's FLAP and JFLAP, Champarnand's AUTOMATE (which has spun off several related projects), AMORE, several different systems called AUTOMATA, Gertjan van Noord's FSA Utilities, our own Grail project, Kartunnen's work at Xerox, Guenthner's work at CIS in Munich, and many others. In addition to the systems I have named, there is a vast amount of applied work, most of it undocumented, using automata for practicM applications such as protocol analysis, IC design and testing, telephony, and other situations where automata software is useful. This is good and interesting work, and it needs a place to be exhibited and discussed. Existing journals and conferences, however, seem to have a difficult time in finding a place for what we do. Theoretical arenas sometimes treat this work as 'mere' implementation, a simple working-out of the algorithms, theorems, and proofs that are the 'real' contribution to the field. Systems-oriented venues, on the other hand, sometimes find this kind of work suspect because it appears to be aimed at theoreticians. It is tricky navigating between the Scylla of the too-abstract and the Charybdis of the too-practical. Providing a forum for this work is a useful goal, and a sufficient one for WIA. But I think WIA is part of something more fundamental, and a process I want to encourage: the re-appraisM of the value of programming in computer science. Let me briefly describe what I have in mind.

Providing stimulating and real-life experiences is a key component in teaching software project management in Computer Science or Software Engineering programs. The diversity of topics that need to be addressed and restrictions that should be considered in university courses make a challenging task of it. This paper presents a serious game, called “White Crow PM” whose objective is to make students aware of the risks they might face during software development projects. The paper describes the game design steps and provides results of its validation in Computer Science programs in two Mexican universities. The collected data showed that the participants had fun playing the game and its content is relevant for software project management courses. Although the game needs to be validated in other settings with more participants, we conclude that it fulfills the goal of motivating discussion and increasing awareness of project management concerns among students.

This paper proves correctness of Nöcker's method of strictness analysis, implemented in the Clean compiler, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work Clark, Hankin and Hunt did on the correctness of the abstract reduction rules in two aspects. Our correctness proof is based on a functional core language and a contextual semantics, thus proving a wider range of strictness-based optimizations as correct, and our method fully considers the cycle detection rules, which contribute to the strength of Nöcker's strictness analysis. Our algorithm SAL is a reformulation of Nöcker's strictness analysis algorithm in a functional core language LR. This is a higher order call-by-need lambda calculus with case , constructors, letrec , and seq , which is extended during strictness analysis by set constants like Top or Inf , denoting sets of expressions, which indicate different evaluation demands. It is also possible to define new set constants by recursive equations with a greatest fixpoint semantics. The operational semantics of LR is a small-step semantics. Equality of expressions is defined by a contextual semantics that observes termination of expressions. Basically, SAL is a nontermination checker. The proof of its correctness and hence of Nöcker's strictness analysis is based mainly on an exact analysis of the lengths of evaluations, i.e., normal-order reduction sequences to WHNF. The main measure being the number of “essential” reductions in evaluations. Our tools and results provide new insights into call-by-need lambda calculi, the role of sharing in functional programming languages, and into strictness analysis in general. The correctness result provides a foundation for Nöcker's strictness analysis in Clean, and also for its use in Haskell.

Bisimilarity as a Theory of Functional Programming

Codes for computational science and downstream analysis (visualization and/or statistical modelling) have historically been dominated by imperative thinking, but this situation is evolving, both through adoption of higher-level tools such as Matlab, and through some adoption of functional ideas in the next generation of toolkits being driven by the vision of extreme-scale computing. However, this is still a long way from seeing a functional language like Haskell used in a live application. This paper makes three contributions to functional programming in computational science. First, we describe how use of Haskell was interleaved in the development of the first practical approach to multifield topology, and its application to the analysis of data from nuclear simulations that has led to new insight into fission. Second, we report subsequent developments of the functional code (i) improving sequential performance to approach that of an imperative implementation, and (ii) the introduction of parallelism through four skeletons exhibiting good scaling and different time/space trade-offs. Finally we consider the broader question of how, where, and why functional programming may - or may not - find further use in computational science.

The problem of disproportional representation of women in the computer science (CS) field in post-secondary education has become a major concern (AAUW, 2000; Camp, 2002; Carver, 2000; Varma, 2003). Currently, universities are increasing their focus on retaining women into CS programs. However, the number of women in that field remains low in proportion to males, and many women who are recruited often drop out or switch majors before completing their degree in CS (National Science Board, 2004, pp. 2-6, 3-17). In order to promote retention, it is important to compare possible differences in learning motivation between males and females in CS, examine changes in motivations across the span of CS study, and assess whether recruitment messages and program structures are matched (or mismatched) to the motivations of females. This article investigates the motivations for women to enter into, remain in, and continue the study of CS at the post-secondary level.

As a female computer science educator, I've watched with growing alarm the drop in enrollment in our Computer Science programs from a ratio of 1:1 of males and females in 1983, to a current ratio of 5:1. The lack of interest of female students in Computer Science is still a very serious problem. As educators we should all be watching our own campus and addressing this problem. The panelists assembled from various institutions will address the issues of gender imbalance and relate their experiences in implementing solutions to counter this problem. Two of the panelist will discuss utilization of the World Wide Web addressing reasons for creating both Web sites. As long as this gender imbalance exists in our schools we need to continue our dialog to share and develop new ideas to encourage female participation in Computer Science Programs. The audience will be welcomed to participate in a larger group discussion.

We present a breadth-first, lecture-and lab-based approach to introducing Computer Science that uses functional programming.Functional programming provides a lowoverhead introduction to programming (no types, few constructs, and little syntax), enabling students to write, in their first semester, programs sophisticated enough to exemplify important concepts of Computer Science.It also encourages good programming style (modular design and testing, e.g.) and serves as an introduction to an important problem-solving paradigm.The course gives the students a broad overview of Computer Science and helps them gauge their interest in the field.