An intonational inventory of Urdu for spontaneous conversational speech is determined based on the analysis of a hand-labelled data set of telephone conversations. An inventory of Urdu pitch accents and the basic Urdu intonation patterns observed in the data are summarised and presented using a simplified version of the Rhythm and Pitch (RaP) labelling system. The relation between pitch accents and parts of speech (PoS) is also explored. The data confirm the important role played by low pitch accents in Urdu spontaneous speech, in line with previous studies on Urdu/Hindi scripted speech. Typical pitch contours such as falling tone in statements and WH-questions, and rising tone for yes/no questions are also exhibited. Pitch accent distribution is quite free in Urdu, but the data indicate a stronger association of pitch accent with some PoS categories of content word (e.g. Nouns) when compared with function words and semantically lighter PoS categories (such as Light Verbs). Contrastive focus is realised by an L*+H accent with a relatively large pitch excursion for the +H tone, and longer duration of the stressed syllable. The data suggest that post-focus compression (PFC) is used in Urdu as a focus-marking strategy.

The ever increasing complexity of software and rapidly changing development environments continues to drive the evolution of new technologies, techniques, and tools. This special issue, Software Engineering in Practice, provides the software engineering community with a valuable collection of current high-quality research articles that explore topics driven by real problems in industry. The inspiration for this special issue has drawn upon the ICSE Software Engineering in Practice Track (ICSE SEIP 2019)1, part of the Industry Program at the 41st International Conference on Software Engineering2; it builds upon the success of the previous special issue with the same theme.1 The ICSE SEIP Track provides a premier venue for researchers and practitioners to discuss innovations and solutions to concrete software engineering problems. The guest coeditor team for this special issue is an international collaboration involving the co-organizers of the ICSE SEIP 2019 Track, Helen Sharp and Michael Whalen, and two editors of the Journal of Software: Practice and Experience3 (JSPE), Judith Bishop and Kendra M. L. Cooper. The Call for Papers was designed to encourage submissions that presented novel and innovative ideas that broadly spanned the software engineering discipline; ideas that provided rigorously validated solutions for real problems encountered by practitioners. In order to promote an inclusive environment, the call was broadly disseminated as an open call; it was advertised on the JSPE and the ICSE SEIP 2019 websites, established software engineering newsgroups (eg, SEWORLD) and conference announcement sites (eg, WikiCFP), in addition to numerous professional and social media platforms. The call required submissions be original manuscripts that had not been previously published and were also not under consideration for publication elsewhere. Submissions of research article, survey papers, short communication, and extended conference papers were welcome; extended conference papers were required to include at least 30% additional novel contributions. The response from the software engineering community was enthusiastic: the special issue received 25 manuscripts submitted by authors from 13 countries. Submissions featured international collaborations from researchers in academia and industry, cases studies from industry, and the use of open source data sets and systems provided by the broader community. The submissions were reviewed according to the JSPE standards, with a goal of publishing the online version of the articles in a timely fashion. Ultimately, six articles were selected for the special issue. Overviews of these accepted manuscripts are presented below, organized into two groups. Novel contributions in the area of intelligent code analysis are explored in several of the papers in the special issue. Kim et al present an automated code analysis approach based on machine learning to recommend an appropriate level for logging runtime events. Rong et al present an automated code analysis approach based on templates and rules to generate documentation in a timely manner within agile DevOps environments. In addition, Huang et al present an automated code analysis approach to identify the need for header comments with the goal of supporting the long-term evolution of the product. Several of the papers in the special issue are related to the broader topic of reuse, from different perspectives. Weir et al present an on-going lightweight security training program that has the potential to be reused by a wide range of development teams; the research has a grounded theory foundation. Koziolek et al present a reference architecture to further the standardization and automation of IoT integration. Hu et al present a data mining-based approach to search and filter existing code samples with the goal of establishing high quality software repositories. We would like to extend our warmest thanks to all the authors who submitted their manuscripts, the anonymous reviewers who provided timely, high-quality review comments in their generous service to the community, and the JSPE editorial board and personnel.

Software Practice and Experience would like to thank the following individuals for their outstanding contributions as referees. Our success as a journal depends on the quality of our referees. We are very grateful to you all. Diego Alonso Felix Gomez Marmol Roberto Erick Lopez-Herrejon Michael Seufert Wesley Klewerton Guez Assunção Rocio Gonzalez-Diaz Arno Luppold Hossain Shahriar George Balatsouras Arnaud Gotlieb Stefano Marrone Helen Sharp Marco Balduzzi Paul Grefen Jabier Martinez Michal Siedlaczek Sebastian Banescu Mahmoud Hammad Iberia Mederios Danilo Silva Walter Bartosz Shilin He Andre Menolli Kari Smolander Eric Bodden Helena Holmström Olsson Philippe Merle Balwinder Sodhi Rodrigo Calheiros Johannes Holvitie Marjan Mernik Jeongju Sohn Jian Cao Nigel Horspool Fabrizio Milazzo Jacopo Soldani Marcelo Cataldo Rubing Huang Josh Milthorpe Hasan Sozer Carlos Cetina Jaehyun Hwang Deepti Mishra Mark Stamp K. Chandrasekaran Erik Jagroep Adel Nadjaran Toosi Vlado Stankovski Chao Chen Devki Jha Vittoria Nardone Neeraj Suri Gong Cheng Timothy Jones Smita Naval Mark D. Syer Yunja Choi Alexander Jordan Antonio Nebro Patanamon Thongtanunam Edward Chuah Eleanor Judd James Noble Suresh Thummalapenta Elder Cirilo Pradeeban Kathiravelu Martín Ochoa Dennis Titze Robert Clarisó Stephen Kell Marc-Oliver Pahl Mamadou K. Traoré Sylvan Clebsch Uday Khedker Laura Panizo Eray Tuzun Kendra Cooper Barbara Kitchenham Chris Parnin Mark van den Brand Luís Cruz-Filipe Jacques Klein Rui Pereira Jan Martijn van der Werf Jennifer Davis Alex Kogan Euripides G. M. Petrakis Andreea Vescan Ewen Denney Raghavendra Kune Radu Prodan Andreas Vogelsang Yvonne Dittrich Daniel Lemire Rick Rabiser Philipp Wieder Dapeng Dong Li Li Maria Alejandra Rodriguez Sossa Xingbo Wu Qiang Duan Laercio Lima Pilla Atanas Rountev Ramin Yahyapour Juan Durillo Taweetham Limpanuparb Kazi Sakib Rongjie Yan Jutta Eckstein Mario Linares-Vasquez Giorgos Saloustros Jifu Zhang Henry Edison Jin Liu Kristian Sandahl Lingming Zhang Sukhpal Singh Gill Jonathan Lockhart Kurt Schneider Justin Zobel Note that this is not an exhaustive list of 2018 referees. These referees gave outstanding service to the journal based on the criteria of quality, timeliness, and volume of reviews.

The micro:bit (http://www.microbit.org) is a pocket-sized, programmable computing device, designed to engage people with computing technology. The micro:bit is visually appealing, fun, easy to code and inexpensive. It is widely available at schools in the United Kingdom and is now being rolled out world-wide. Key features of the micro:bit that make it a great device for physical computing include a display of 25 LEDs, two programmable input buttons, a USB connector, an edge connector, built-in sensors (e.g. accelerometer, compass and temperature sensor), Bluetooth and a battery pack connector. With these physical attributes, the micro:bit can be used to interact with the world in engaging ways such as a watch, a guitar or a moisture sensor. Multi-person games and apps are possible since micro:bits can communicate with each other. Programming the micro:bit can take place on almost any device (laptop, tablet, desktop) that has a modern browser and a USB connection. The micro:bit platform supports programming in a block-based language or a safe version of JavaScript, which provides a progression for learners of different ages and experience levels. This demo will appeal to computer education researchers specializing in K-12 as well as to instructors wanting a new way to introduce computing in CS101 with a "maker" flavor. In the demo we will show the platform and the hardware. Attendees will have the chance to create apps on real micro:bits. It will be helpful to bring a device with a browser.

There are many papers about projects that release their software as open source. Our panel looks at why open source is a good idea for education, and how it can best be leveraged. The panel represents industry and academia and its members have years of experience in the field. Specific questions that panelists will address, in addition to their position statements, are:

We present a summary of the 4th ICSE Workshop on Games and Software Engineering. The full day workshop is planned to include a keynote speaker, game-jam demonstration session, and paper presentations on game software engineering topics related to software engineering education, frameworks for game development and infrastructure, quality assurance, and model-based game development. The accepted papers are overviewed here.

Mastering a complex skill like programming takes many hours. In order to encourage students to put in these hours, we built Code Hunt, a game that enables players to program against the computer with clues provided as unit tests. The game has become very popular and we are now running worldwide contests where students have a fixed amount of time to solve a set of puzzles. This paper describes Code Hunt and the contest experience it offers. We then show some early results that demonstrate how Code Hunt can accurately discriminate between good and bad coders. The challenges of creating and selecting puzzles for contests are covered. We end up with a short description of our course experience, and some figures that show that Code Hunt is enjoyed by women and men alike.

Differing perceptions and expectations are obstaclesto collaboration between software engineering (SE) researchersand practitioners: Researchers often have a view thatpractitioners are reluctant to share real data. Practitionersbelieve that researchers are mostly working on topics which aredivorced from real industrial needs. Researchers believe thatpractitioners are looking for quick fixes. Practitioners have aview that case studies in research do not represent thecomplexities of real projects. Researchers may expect a few yearsto do research on a problem whereas practitioners expect a quicksolution that pays off immediately.Researchers and practitioners need to identify the gaps and todiscover the ways to collaborate to strengthen SE research andindustrial practice (IP). The main purpose of this workshop is tobring together researchers and practitioners to discuss thecurrent state of SE research and IP and to enhance collaborationbetween them. The SER&IP 2015 workshop provided a platformto share success stories of SE research-practice partnerships aswell as to discuss the challenges, through a day-long agenda ofkeynotes, paper presentations and round table discussions.

Pex is an automatic white-box test-generation tool for .NET. We have established that games can be built on top of Pex to open the tool to students and to the general public. In particular, we have released Pex4Fun (www.pexforfun.com) and its successor Code Hunt (www.codehunt.com) as web-based educational gaming environments for teaching and learning programming and software engineering. In Pex4Fun and Code Hunt, the main game type is a coding duel, where a player writes code in a method to achieve the same functionality as the secret method implementation, based on feedback provided by the underlying Pex tool. Players iteratively modify their code to match the functional behavior of the secret method. The scope of duels extends from the simplest one-line method to those including advanced concepts such as writing parameterized unit tests and code contracts. We have also used the game type for competitions with thousands of players, and have found that it differentiates well between beginners and top coders. This tool demonstration shows how coding duels in Pex4Fun and Code Hunt can be constructed and used in teaching and training programming and software engineering.

Code Hunt (http://www.codehunt.com/) is an educational coding game (that runs in a browser) for teaching and learning computer science at scale. The game consists of a series of worlds and levels, which get increasingly challenging. In each level, the player has to discover a secret code fragment and write code for it. The game has sounds and a leaderboard to keep the player engaged. Code Hunt targets teachers and students from introductory to advanced programming or software engineering courses. In addition, Code Hunt can be used by seasoned developers to hone their programming skills or by companies to evaluate job candidates. At the core of the game experience is an automated program analysis and grading engine based on dynamic symbolic execution. The engine detects any behavioral differences between the player's code and the secret code fragment. The game works in any modern browser, and currently supports C# or Java programs. Code Hunt is a dramatic evolution of our earlier Pex4Fun web platform, from which we have gathered considerable experience (including over 1.4 million programs submitted by users).

TOPI (http://se.inf.ethz.ch/events/topi2013/) is a workshop started in 2011 to address research questions involving plug-ins: software components designed and written to execute within an extensible platform. Most such software components are tools meant to be used within a development environment for constructing software. Other environments are middle-ware platforms and web browsers. Research on plug-ins encompasses the characteristics that differentiate them from other types of software, their interactions with each other, and the platforms they extend.

The term “Technical Debt” was coined over 20 years ago by Ward Cunningham in a 1992 OOPSL A experience report to de scribe the tr ade-offs between delivering the most appropriate — albeit likely immature — product, in the shortest time possible. Since then the repercussions of going into “technical debt” have become more visible, yet not necessarily more broadly understood. This panel will bring together practitioners to discuss and debate strategies for debt relief.

Massive Open Online Courses (MOOCs) have recently gained high popularity among various universities and even in global societies. A critical factor for their success in teaching and learning effectiveness is assignment grading. Traditional ways of assignment grading are not scalable and do not give timely or interactive feedback to students. To address these issues, we present an interactive-gaming-based teaching and learning platform called Pex4Fun. Pex4Fun is a browser-based teaching and learning environment targeting teachers and students for introductory to advanced programming or software engineering courses. At the core of the platform is an automated grading engine based on symbolic execution. In Pex4Fun, teachers can create virtual classrooms, customize existing courses, and publish new learning material including learning games. Pex4Fun was released to the public in June 2010 and since then the number of attempts made by users to solve games has reached over one million. Our work on Pex4Fun illustrates that a sophisticated software engineering technique-automated test generation-can be successfully used to underpin automatic grading in an online programming system that can scale to hundreds of thousands of users.

Pex4Fun (http://www.pex4fun.com/) is a web-based educational gaming environment for teaching and learning programming and software engineering. Pex4Fun can be used to teach and learn programming and software engineering at many levels, from high school all the way through graduate courses. With Pex4Fun, a student edits code in any browser - with Intellisense - and Pex4Fun executes it and analyzes it in the cloud. Pex4Fun connects teachers, curriculum authors, and students in a unique social experience, tracking and streaming progress updates in real time. In particular, Pex4Fun finds interesting and unexpected input values (with Pex, an advanced test-generation tool) that help students understand what their code is actually doing. The real fun starts with coding duels where a student writes code to implement a teacher's secret specification (in the form of sample-solution code not visible to the student). Pex4Fun finds any discrepancies in behavior between the student's code and the secret specification. Such discrepancies are given as feedback to the student to guide how to fix the student's code to match the behavior of the secret specification. This tool demonstration shows how Pex4Fun can be used in teaching and learning, such as solving coding duels, exploring course materials in feature courses, creating and teaching a course, creating and publishing coding duels, and learning advanced topics behind Pex4Fun.

SUMMARY Our knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre‐existing integrated development environment (IDE). This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers, and numerous other development and, often, runtime tools. Tools and environments to increase software quality and productivity have always been an important aspect of software engineering. A plug‐in is a modern way for incrementally adding new tools into existing environments. However, building tools as plug‐ins can be challenging. How do they interact with the core environment? How do they interact with one another ‐ especially since each developer may choose a different set of plug‐ins? How can we share tools across different, and future, core development environments?

Pex4Fun (http://www.pexforfun.com/) is a web-based serious gaming environment for teaching computer science. Pex4Fun can be used to teach and learn computer programming at many levels, from high school all the way through graduate courses.With Pex4Fun, a student edits code in any browser -- with Intellisense -- and Pex4Fun executes it and analyzes it in the cloud. Pex4Fun connects teachers, curriculum authors, and students in a unique social experience, tracking and streaming progress updates in real time. In particular, Pex4Fun finds interesting and unexpected input values that help students understand what their code is actually doing. The real fun starts with Coding Duels where students write code to implement a teacher's specification. Pex4Fun finds any discrepancies in behavior between the student's code and the specification. This tutorial instructs materials to equip participants with skills and knowledge of using Pex4Fun in teaching and learning, such as solving puzzles, solving Coding Duels, exploring course materials in feature courses, creating and teaching a course, creating and publishing Coding Duels, and learning advanced topics behind Pex4Fun.

From paper to computers, the way we have been writing down thoughts and performing symbolic computations has been constantly evolving. Teaching methods closely follow this trend, leveraging existing technology to make teaching more effective and preparing students for their later careers with available technologies. At present, we are in the middle of another technology shift: instead of using PCs and laptops, mobile devices are becoming more prevalent for most everyday computing tasks. We propose that computer programming, and thus the teaching of programming, can and should be done directly on the mobile devices themselves, without the need for a separate PC to write code. Programming on mobile devices engages students in new ways, allowing them to access and manipulate programmatically their most personal digital data such as pictures, videos, and music in an easy and intuitive way.

From paper to computers, the way that we have been writing down thoughts and performing symbolic computations has been constantly evolving. Teaching methods closely follow this trend, leveraging existing technology to make teaching more effective and preparing students for their later careers with the available technology. Right now, in 2012, we are in the middle of another technology shift: instead of using PCs and laptops, mobile devices are becoming more prevalent for most everyday computing tasks. In fact, never before in human history were incredibly powerful and versatile computing devices such as smartphones available and adopted so broadly. We propose that computer programming, and thus the teaching of programming, can and should be done directly on the mobile devices themselves, without the need for a separate PC or laptop to write code. Programming on smartphones that we carry around with us at all times means instant gratification for students, as they can show their games and applications to their friends, and it means that students can do their homework or additional practicing at all times. We describe TouchDevelop, a novel mobile programming environment, and call out challenges that need to be overcome and opportunities that it creates.

Pex4Fun (pexforfun.com) is a web-based serious gaming environment for teaching computing at many levels, from high school all the way through graduate courses. Unique to the Pex4Fun experience is a cloud-based program evaluation engine based on dynamic symbolic execution and SMT-solving, which provides customized feedback to the student and automated grading for the teacher. Thus, Pex4Fun connects teachers, curriculum authors, and students in a social experience, tracking and streaming progress updates in real time. In particular, Pex4Fun finds interesting and unexpected input values that help students understand what their code is actually doing. The real fun starts with coding duels where students write code to implement a teacher's specification. Pex4Fun finds any discrepancies in behavior between the student's code and the specification. Then based on the reported discrepancies, the student improves his or her code towards the specification. Pex4Fun can be used to develop interesting, engaging, and demanding class materials on mathematics, algorithms, programming languages, or problem solving in general. A teacher can use an integrated wiki to author these class materials for students to work through. This workshop involves creating and teaching course materials at Pex4Fun. Participants should bring a laptop computer. The intended audience includes all levels of CS educators who are interested in integrating educational technology in their teaching environments.

Our knowledge as to how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre-existing development environment that can provide integration with existing elements such as compilers, debuggers, profilers and visualizers. The first Workshop on Developing Tools as Plug-ins is a new forum in which to addresses research, ongoing work, ideas, concepts, and critical questions related to the engineering of software tools and plug-ins.

Multicore computers are now the norm. Taking advantage of these multiple cores entails parallel and concurrent programming. There is therefore a pressing need for courses that teach effective programming on multicore architectures. We believe that such courses should emphasize high-level abstractions for performance and correctness and be supported by tools. This paper presents a set of freely available course materials for parallel and concurrent programming, along with a testing tool for performance and correctness concerns called Alpaca (A Lovely Parallelism And Concurrency Analyzer). These course materials can be used for a comprehensive parallel and concurrent programming course, à la carte throughout an existing curriculum, or as starting points for graduate special topics courses. We also discuss tradeoffs we made in terms of what to include in course materials.

The world is focused on data as never before. Everything we do, from our professional, academic and social lives, relies on being able to receive, process, analyze and display vast amounts of intricately connected information, represented in many different ways. We show how we can draw on the experience of existing systems that process data and come up with success factors that enable software engineers to make data widely and easily available in different forms at many levels.

The popular view of software engineering focuses on managing teams of people to produce large systems. This paper addresses a different angle of software engineering, that of development for re-use and portability. We consider how an essential part of most software products - the user interface - can be successfully engineered so that it can be portable across multiple platforms and on multiple devices. Our research has identified the structure of the problem domain, and we have filled in some of the answers. We investigate promising solutions from the model-driven frameworks of the 1990s, to modern XML-based specification notations (Views, XUL, XIML, XAML), multi-platform toolkits (Qt and Gtk), and our new work, Mirrors which pioneers reflective libraries. The methodology on which Views and Mirrors is based enables existing GUI libraries to be transported to new operating systems. The paper also identifies cross-cutting challenges related to education, standardization and the impact of mobile and tangible devices on the future design of UIs. This paper seeks to position user interface construction as an important challenge in software engineering, worthy of ongoing research.

The design of software that is easy to port or deliberately targeted for multiple platforms is a neglected area of software engineering. A promising solution is to link components and toolkits through XML and reflection.

Sequential distributions of intonational pitch accents in a hand-labelled, read speech corpus of Tuscan Italian are analysed in relation to (1) the global frequencies of accents; (2) evidence of consistent patterns of association between accents. A subset of syntactically controlled nominal phrases are examined to determine whether the fact of their constituting a coherent syntactic unit has any effect on their patterns of sequential tone distribution, i.e. whether they are associated with a given tune. Some evidence is found for patterns of association between accents, and between sequences of accents and our chosen type of nominal phrase.

Abstract Java programmers cannot help but be aware of the advent of C#, the .NET network environment, and a host of new supporting technologies, such as Web services. Before taking the big step of moving all development to a new environment, programmers will want to know what are the advantages of C# as a language over Java, and whether the new and interesting features of C# and .NET can be incorporated into existing Java software. This paper surveys the advantages of C# and then presents and evaluates experience with connecting it to Java in a variety of ways. The first way provides evidence that Java can be linked to C# at the native code level, albeit through C++ wrappers. The second is a means for retaining the useful applet feature of Java in the server‐side architecture of Web services written in C#. The third is by providing a common XML‐based class for the development of graphical user interfaces (GUIs), which can be incorporated into Java or C#. An added advantage of this system, called Views, is that it can run independently of the resource‐intensive development environment that would otherwise be needed for using C#. A major advantage of the methods described in this paper is that in all cases the Java program is not affected by the fact that it is interfacing with C#. The paper concludes that there are many common shared technologies that bring Java and C# close together, and that innovative ways of using others can open up opportunities not hitherto imagined. Copyright © 2005 John Wiley & Sons, Ltd.

This paper proposes that GUI development is as important as other aspects of programming, such as a sound understanding of control structures and object orientation. Far less attention has been paid to the programming structures for GUIs and certainly there are few cross language principles to aid the programmer. We propose that principles of GUIs can be extracted and learnt, and that they do enhance good programming practice. These principles have been implemented in our Views system which features an XML-based GUI description notation coupled with an engine that shields the programmer from much of the intricate complexity associated with events, listeners and handlers. The system is programmed primarily in C# for .NET, but is available in various forms for Java and for other platforms which support .NET through the SSCLI.

The goal of this panel is to examine the following questions with the audience:

Scientific programmers have traditionally programmed in entirely sequential languages such as Fortran, C or Pascal and it could be argued that object-orientation is not a concept that they would need.Yet computer science departments that give courses to scientists and engineers would like to consider teaching them in Java, rather than in one of the older languages.This paper addresses the dual issues of how Java can best supply everything that the older languages do, and then what it can meaningfully give in added value, especially in the networking and parallel area.Experience with developing solutions in Java to some fifty typical numerical problems has led to a coherent objectoriented approach and a couple of essential support classes for teaching and production work.

No abstract available.

No abstract available.

Abstract The transputer is one of the most cost‐effective multicomputer components to buy, but still one of the hardest to program. Even if the parts of a program that are destined for individual transputers are programmed in a familiar high‐level language (Ada or Fortran or C), users are forced to be aware of occam when connecting transputers together with harnesses. Moreover, the design of parallel and distributed algorithms is in itself a challenging field. This paper describes experience with using the Alsys Ada compiler on single and multiple transputer configurations, and considers whether Ada makes it any easier to gain access to the power of multi‐transputers. Early performance figures indicate that Ada running on transputer arrays compares favourably with the speed of other languages. An assessment of the impact of the proposed Ada 9X support for distribution is made.

It is shown how loop algorithms can be encompassed in an iterator and then activated for any data type for which a generator can be defined. It takes the iterator-generator idea a step further than previous work in that it permits variations of the iterators to be defined dynamically through the use of selectors and actors, without loss of efficiency or clarity. It is further shown that selectors can be employed in the definition of a truly generic sorting routine. Guidelines for the decomposition of a system into generic data types, abstract data types, iterators, generators, and the programs that exercise them are given, and several complete programs show the implementation of the techniques in Ada.>

Abstract This paper tackles the practical aspects of obtaining a distributed version of an Ada program. It proposes the use of an adapter, which can be a methodology or an automatic translator. The adapter accepts source of a concurrent Ada program, adds communication and control tasks, and produces source for a single distributed Ada program, which can then be compiled and run on a multi‐processor computer. The original program can consist of packages and tasks, and both of these can be classed as virtual nodes. The process of adaption does not alter the contents of any package in the original program, so that the method is directly applicable to systems that make use of library and generic packages. The communication between virtual nodes, which would normally reside as one per processor, is via messages on a ring, but the protocols are kept as simple as possible, and the messages are fully checked Ada types, rather than byte strings. The method has been applied to programs of the client‐server model, and could be adapted for other rendezvous‐based languages such as occam.

Descriptors are a popular feature in the design of new computer architectures but little has been written about the principles and pitfalls involved. Experience with writing and investigating compilers for two structured architectures, the Burroughs B6700 and the ICL 2900, has shown that the terms used in relation to descriptors often have contradictory meanings. Descriptors as implemented on these machines are often not the blessing they were made out to be. This paper seeks to enumerate and explain the operational function of descriptors; to define there area of application; to give evidence of the unwieldy aspects in current implementations; and to suggest how these may be improved.

The maintenance of a block structured environment is discussed in the context of structured architectures. Four methods of calling procedures are presented in an updated and uniform notation which makes full use of a stack. Implementations of three of these, namely static and dynamic chaining (on the ICL1900), a full hardware display (on the Burroughs B6700) and a selective local display (on the ICL2900), are compared and it is shown that the ICL2900 does not compensate adequately for the lack of a display. A means of improving static linking on the ICL2900 is therefore suggested. Throughout, the problems likely to be encountered by compiler writers in realising these methods with and without displays and stacks are taken into account and solutions explained.

Abstract Having recently read several new Pascal textbooks, I was struck by the multitude of ways in which programs are represented in print. Some of these are more pleasing to the eye than others, and with a typesetting machine, anything is possible. However, several books are being produced these days from typewritten copy and there seems to be no accepted second‐best to the italics‐and‐bold favoured by most publishers. It would also be desirable if the style used by books could correspond more closely to that which is handwritten or computer‐produced. This note summarizes the possibilities and makes a call for stability, if not outright standardization.

Abstract Sale1 has proposed that strings be realized in Pascal using the existing sequence abstraction. This short note supports this proposal and shows how strings can be efficiently implemented in standard Pascal. The implementation is done in such a way as to leave existing programs undisturbed should strings be subsequently incorporated in the language and/or compiler.