Objective: Translating clinical evidence to daily practice remains a challenge and may improve with clinical pathways. We assessed interest in and usability of clinical pathways by primary care professionals. Methods: An online survey was created. Interest in pathways for patient care and learning was assessed at start and finish. Participants completed baseline questions then pathway-associated question sets related to management of 2 chronic diseases. Perceived pathway usability was assessed using the system usability scale. Accuracy and confidence of answers was compared for baseline and pathway-assisted questions. Results: Of 115 participants, 17.4% had used clinical pathways, the lowest of decision support tool types surveyed. Accuracy and confidence in answers significantly improved for all pathways. Interest in using pathways daily or weekly was above 75% for the respondents. Conclusion: There is low utilization of, but high interest in, clinical pathways by primary care clinicians. Pathways improve accuracy and confidence in answering written clinical questions.

article Free Access Share on Cliché-based program editors Author: Richard C. Waters Mitsubishi Electric Labs, Cambridge, MA Mitsubishi Electric Labs, Cambridge, MAView Profile Authors Info & Claims ACM Transactions on Programming Languages and SystemsVolume 16Issue 1Jan. 1994 pp 102–150https://doi.org/10.1145/174625.174628Online:01 January 1994Publication History 4citation475DownloadsMetricsTotal Citations4Total Downloads475Last 12 Months7Last 6 weeks1 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my Alerts New Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Lexicalized context-free grammar (LCFG) is an attractive compromise between the parsing efficiency of context-free grammar (CFC) and the elegance and lexical sensitivity of lexicalized treeadjoining grammar (LTAG).LCFC is a restricted form of LTAG that can only generate contextfree languages and can be parsed in cubic time.However, LCF(I supports much of the elegance of LTAG's analysis of English and shares with LTAG the ability to lexicalize CF(I;s without changing the trees generated. MotivationContext-free grammar (CFG) has been a well accepted framework for computational linguistics for a long time.While it has drawbacks, including the inability to express some linguistic constructions, it has the virtue of being computationally efficient, O(n3)-time in the worst case.Recently there has been a gain in interest in the so-called 'mildly' context-sensitive formalisms (Vijay-Shanker, 1987;Weir, 1988;Joshi, Vijay-Shanker, and Weir, 1991; Vijay-Shanker and Weir, 1993a) that generate only a small superset of context-free languages.One such formalism is lexicalized tree-adjoining grammar (LTAG) (Schabes, Abeill~, and Joshi, 1988; Abeillfi et al., 1990;Joshi and Schabes, 1992), which provides a number of attractive properties at the cost of decreased efficiency, O(n6)-time in the worst case (Vijay-Shanker, 1987;Schabes, 1991;Lang, 1990;Vijay-Shanker and Weir, 1993b).

Most software engineering tools use a shallow representation of software objects and manipulate this representation using procedural methods. This approach allows one to get off to a fast start and quickly provides a tool that delivers benefits. However, a point will be reached where more knowledge-intensive approaches will be needed to achieve significantly higher levels of capability. The authors suggest that the software engineering tools of the future will have to rely on: deep representation to capture a sufficiently large part of knowledge about programming in general and particular programs; inspection methods to deal with complexity; and intelligent assistance.>

The benefits of programming in a functional style are well known. In particular, algorithms that are expressed as compositions of functions operating on sequences/vectors/streams of data elements are easier to understand and modify than equivalent algorithms expressed as loops. Unfortunately, this kind of expression is not used anywhere near as often as it could be, for at least three reasons: (1) most programmers are less familiar with this kind of expression than with loops; (2) most programming languages provide poor support for this kind of expression; and (3) when support is provided, it is seldom effcient. In any programming language, the second and third problems can be largely solved by introducing a data type called series , a comprehensive set of procedures operating on series, and a preprocessor (or compiler extension) that automatically converts most series expressions into efficient loops. A set of restrictions specifies which series expressions can be optimized. If programmers stay within the limits imposed, they are guaranteed of high efficiency at all times. A common Lisp macro package supporting series has been in use for some time. A prototype demonnstrates that series can be straightforwardly supported in Pascal.

An automated tool called the Requirements Apprentice (RA) which assists a human analyst in the creation and modification of software requirements is presented. Unlike most other requirements analysis tools, which start from a formal description language, the focus of the RA is on the transition between informal and formal specifications. The RA supports the earliest phases of creating a requirement, in which ambiguity, contradiction, and incompleteness are inevitable. From an artificial intelligence perspective, the central problem the RA faces is one of knowledge acquisition. The RA develops a coherent internal representation of a requirement from an initial set of disorganized imprecise statements. To do so, the RA relies on a variety of techniques, including dependency-directed reasoning, hybrid knowledge representations and the reuse of common forms (cliches). An annotated transcript showing an interaction with a working version of the RA is given.>

Abstract A number of software management tasks (consistent system construction, system installation, etc.) can be performed by automatic tools. Given a particular software system, such a tool requires a task model that describes how the task is to be applied to the system. For example, a system construction tool needs to know which operations (compilation, linking, etc.) must be applied to which modules. Unfortunately, although task models are convenient for an automatic software management tool, they are inconvenient for users for two reasons. First, users have to create and maintain multiple, partially redundant models. Secondly, task models are often quite awkward to deal with‐a primary source of difficulty being the need to specify low‐level, task‐specific details. In recognition of these problems, recent software management tools have been moving away from task models towards structural models (e.g. who calls who) as a user interface. Structural models are easy to deal with, because they contain high‐level, task‐independent relationships, rather than task‐dependent details. A prototype tool has been implemented that makes this change complete. The tool automatically performs a variety of software management tasks using a single structural model for a system. The tasks themselves are described separately using system‐independent task descriptions.

An abstraction-and-reimplementation paradigm is presented in which the source program is first analyzed in order to obtain a programming-language-independent abstract understanding of the computation performed by the program as a whole. The program is then reimplemented in the target language based on this understanding. The key to this approach is the abstract understanding obtained. It allows the translator to benefit from an appreciation of the global features of the source program without being distracted by what are considered irrelevant details. Knowledge-based translation via abstraction and reimplementation is described as one of the goals of the Programmer's Apprentice project. A translator which translates Cobol programs into Hibol (a very-high-level business data processing language) has been constructed. A computer which generates extremely efficient PDP-11 object code for Pascal programs has been designed.>

The benefits of programming in a functional style are well known. For example, algorithms which are expressed as compositions of functions operating on series/vectors/streams of data elements are much easier to understand and modify than equivalent algorithms expressed as loops. Unfortunately, many programmers hesitate to use series expressions because they are typically implemented very inefficiently-the prime source of inefficiency being the creation of intermediate series objects.A restricted class of series expressions, obviously synchronizable series expressions, is defined which can be evaluated very efficiently because they do not require the creation of any intermediate series objects. A Common Lisp macro package has been implemented which supports obviously synchronizable series expressions. Using this macro package, programmers can obtain the advantages of expressing computations as series expressions without incurring any runtime overhead. Obviously synchronizable series expressions could be straightforwardly supported in any programming language.

The Knowledge-Based Editor in Emacs (KBEmacs) is the current demonstration system implemented as part of the Programmer's Apprentice project. KBEmacs is capable of acting as a semiexpert assistant to a person who is writing a program-taking over some parts of the programming task. Using KBEmacs, it is possible to construct a program by issuing a series of high level comnmands. This series of commands can be as much as an order of magnitude shorter than the program it describes.

This paper proposes an expressional loop notation (XLoop) based on the ideas described in [16,17] which makes it practical to express loops as compositions of functions. The primary benefit of XLoop is that it brings the powerful metaphor of expressions and decomposability to bear on the domain of loops. Wherever this metaphor can be applied, it makes algorithms much easier to construct, understand, and modify.

A LISP prettyprinter is presented that makes it easy for a user to control the format of the output produced.The printer can be used as a general mechanism for printing data structures as well as programs.It is divided into two parts: a set of formatting functions and an output routine.The user specifies how a particular type of object should be formatted by creating a formatting function for the type.When an object of that type is passed to it, the formatting function creates a sequence of directions that specify how the object should be printed if it can fit on one line and how it should be printed if it must be broken up across multiple lines.A simple template language makes it easy to specify these directions.Based on the line length available, the output routine decides what structures have to be broken up across multiple lines and produces the actual output following the directions created by the formatting functions.The paper concludes with a discussion of how the prettyprinting method presented could be applied to languages other than LISP.

An initial implementation of an interactive programming assistant system called the programmer's apprentice (PA) is described. The PA is designed to be midway between an improved programming methodology and an automatic programming system. The intention is that the programmer will do the hard parts of design and implementation while the PA will assist him wherever possible. One of the major underpinnings of the PA is a representation (called a plan) for programs which abstracts away from the inessential features of a program, and represents the basic logical properties of the algorithm explicitly.

This paper presents a method for automatically analyzing loops, and discusses why it is a useful way to look at loops. The method is based on the idea that there are four basic ways in which the logical structure of a loop is built up. An experiment is presented which shows that this accounts for the structure of a large class of loops. The paper discusses how the method can be used to automatically analyze the structure of a loop, and how the resulting analysis can be used to guide a proof of correctness for the loop. An automatic system is described which performs this type of analysis. The paper discusses the relationship between the structure building methods presented and programming language constructs. A system is described which is designed to assist a person who is writing a program. The intent is that the system will cooperate with a programmer throughout aUl phases of work on a program and be able to communicate with the programmer about it.