Does choice of programming language affect student understanding of programming concepts in a first year engineering course?

Most undergraduate engineering curricula include computer programming to some degree,introducing a structured language such as C, or a computational system such as MATLAB, or both. Many of these curricula include programming in first year engineering courses, integrating the solution of simple engineering problems with an introduction to programming concepts. In line with this practice, Roger Williams University has included an introduction to programming as a part of the first year engineering curriculum for many years. However, recent industry and pedagogical trends have motivated the switch from a structured language (VBA) to a computational system (MATLAB). As a part of the pilot run of this change,the course instructors felt that it would be worthwhile to verify that changing the programming language did not negatively affect students’ ability to understand key programming concepts. In particular it was appropriate to explore students’ ability to translate word problems into computer programs containing inputs, decision statements, computational processes, and outputs. To test the hypothesis that programming language does not affect students’ ability to understand programming concepts, students from consecutive years were given the same homework assignment, with the first cohort using VBA and the second using MATLAB to solve the assignment. A rubric was developed which allowed the investigators to rate assignments independent of programming language. Results from this study indicate that there is not a significant impact of the change in programming language. These results suggest that the choice of programming language likely does not matter for student understanding of programming concepts. Course instructors should feel free to select programming language based on other factors, such as market demand, cost, or the availability of pedagogical resources

Structured Tools and Condiitonal Logic: an Empirical Investigation

An important outcome of recent work on the psychology of programming has been the recognition that we have a poor understanding of how various programming practices-indenting, commenting, naming, etc.-facilitate or inhibit the programming process. After a fairly extensive series of studies, many results obtained are contradictory and counterintuitive. The major probem seems to be that we have poor theoretical bases to drive the empirical research. In particular, we have little knowledge of the psychological constructs that programmers bring to bear when they perform various programming tasks, and we have little knowledge of what is natural for programmers. This research tested the propositon that the effectiveness of a programming practice is a function of the extent to which it provides a close cognitive fit with a programmers\u27 problem solving strategy when he or she performs a programming task. The proposition was tested in the context of two psychological processes that appear to be used by programmers when they design and code conditional logic: (a) taxonomizing-identifying the conditions that evoke particular actions; and (b) sequencing-converting the taxa to a linear sequence of program code. Three structured tools-structured English, decision tables, and decision trees-were investigated in a laboratory setting to determine how they facilitated these two processes. It was hypothesized that decision tables and decision trees would facilitate the taxonomising process because they allow conditions and actions to be easily identified, and that structurd English would facilitate the sequencing process because it provides a linear representation of logic that can be mapped easily into programming code. To test the hypotheses, 124 volunteer information systems and computer science students undertook three experiments. In the first experiment they were given a narrative description of some conditional logic and asked to represent the logic using one of the three types of structured tools. In the second experiment they were given conditional logic already represented via one of the tools and asked to convert it into COBOL code. In the third experiment they were given a narrative description of some conditional logic and asked to convert it into COBOL code after having first represented the logic using one of the three types of structured tools. Their perfomance was assessed in terms of the number of syntactic errors they made, the number of semantic errors they made, and the time taken to perform the experimental tasks. In general, the results confirmed the propostions investigated. When the taxonomizing task had to be undertaken, decision trees outperformed strutured English, although surprisingly structured English outperformed decision tables. When the sequencing task had to be undertaken, structured English outperformed decision tables, but decision trees evoked the same level of performance as structured English. Across all tasks, decision tables evoked relatively poor levels of perfomance. On the other hand, decision trees evoked high levels of performance across all tasks. It appears that the graphical tree structure allows taxon information to be represented poignantly. At the same time it appears relatively easy to trace a branch to its leaf node to perform the sequencing task. The superiority of decision trees seems to confirm the desirablity of graphically revealing the structure inherent in processes rather than using symbolic languages. Moreover, the results suggest that the syntax of current programming languages may be unnecessarily restrictive. Perhaps programming languages should provide decision trees as part of their syntax instead of providing only unidimensional, linear syntax to represent conditional logic

Language Constructs for Distributed Real-Time Consistency

In this paper, we present a model and language constructs for a distributed real-time system with the goal of allowing the structured specification of functional and timing constraints, along with explicit, early error recovery from timing faults. To do this, we draw on ideas from (non-distributed) real-time programming and distributed transaction-based systems [81]. A complete language is not specified; the constructs described are assumed to be embedded in a block-structured procedural host programming language such as C [9] or C++ [10] (our current preliminary implementation is in C). The model consists of resources, processes, and a global scheduler. Resources are abstractions that export operations to processes, and specify acceptable concurrency of operations to the scheduler. Processes manipulate resources using the exported operations, and specify synchronization and restrictions on concurrency (at the exported operation level) to the scheduler. Examples of the types of information given to the scheduler are that a set of operations should be performed simultaneously , or that a sequence of operations should be performed without interference by another process. The global scheduler embodies the entity or entities that schedule the CPU, memory, devices and other resources in the system. It performs preemptive scheduling of all resources based on dynamic priorities associated with the processes, preserves restrictions on concurrency stated by resources and processes, and is capable of giving guarantees to processes that they will receive resources during a specified future time interval. The remainder of the paper is structured as follows. In the next section, we present language constructs for an expression of timing constraints called temporal scopes, and described resources and processes. Section 3 describes what is required of the global scheduler to support these constructs, and what is entailed in guaranteeing functional consistency.\u27 We conclude in Section 4

Instructional strategies and tactics for the design of introductory computer programming courses in high school

This article offers an examination of instructional strategies and tactics for the design of introductory computer programming courses in high school. We distinguish the Expert, Spiral and Reading approach as groups of instructional strategies that mainly differ in their general design plan to control students' processing load. In order, they emphasize topdown program design, incremental learning, and program modification and amplification. In contrast, tactics are specific design plans that prescribe methods to reach desired learning outcomes under given circumstances. Based on ACT* (Anderson, 1983) and relevant research, we distinguish between declarative and procedural instruction and present six tactics which can be used both to design courses and to evaluate strategies. Three tactics for declarative instruction involve concrete computer models, programming plans and design diagrams; three tactics for procedural instruction involve worked-out examples, practice of basic cognitive skills and task variation. In our evaluation of groups of instructional strategies, the Reading approach has been found to be superior to the Expert and Spiral approaches

Systematic composition of distributed objects: Processes and sessions

We consider a system with the infrastructure for the creation and interconnection of large numbers of distributed persistent objects. This system is exemplified by the Internet: potentially, every appliance and document on the Internet has both persistent state and the ability to interact with large numbers of other appliances and documents on the Internet. This paper elucidates the characteristics of such a system, and proposes the compositional requirements of its corresponding infrastructure. We explore the problems of specifying, composing, reasoning about and implementing applications in such a system. A specific concern of our research is developing the infrastructure to support structuring distributed applications by using sequential, choice and parallel composition, in the anarchic environment where application compositions may be unforeseeable and interactions may be unknown prior to actually occurring. The structuring concepts discussed are relevant to a wide range of distributed applications; our implementation is illustrated with collaborative Java processes interacting over the Internet, but the methodology provided can be applied independent of specific platforms

Towards a Unified Framework for Declarative Structured Communications

We present a unified framework for the declarative analysis of structured communications. By relying on a (timed) concurrent constraint programming language, we show that in addition to the usual operational techniques from process calculi, the analysis of structured communications can elegantly exploit logic-based reasoning techniques. We introduce a declarative interpretation of the language for structured communications proposed by Honda, Vasconcelos, and Kubo. Distinguishing features of our approach are: the possibility of including partial information (constraints) in the session model; the use of explicit time for reasoning about session duration and expiration; a tight correspondence with logic, which formally relates session execution and linear-time temporal logic formulas

Communicating Java Threads

The incorporation of multithreading in Java may be considered a significant part of the Java language, because it provides udimentary facilities for concurrent programming. However, we belief that the use of channels is a fundamental concept for concurrent programming. The channel approach as described in this paper is a realization of a systematic design method for concurrent programming in Java based on the CSP paradigm. CSP requires the availability of a Channel class and the addition of composition constructs for sequential, parallel and alternative processes. The Channel class and the constructs have been implemented in Java in compliance with the definitions in CSP. As a result, implementing communication between processes is facilitated, enabling the programmer to avoid deadlock more easily, and freeing the programmer from synchronization and scheduling constructs. The use of the Channel class and the additional constructs is illustrated in a simple application