Elimination Of Code Research Articles

The Demise of the “Evil Specialists”: Class Warfare of Specialists vs Primary Care Physicians Fostered by Elimination of the Consultation Code

The Demise of the “Evil Specialists”: Class Warfare of Specialists vs Primary Care Physicians Fostered by Elimination of the Consultation Code

Often-Used CPT Codes Are Changing

Back to table of contents Previous article Next article Professional NewsFull AccessOften-Used CPT Codes Are ChangingMark MoranMark MoranSearch for more papers by this authorPublished Online:1 Jun 2012https://doi.org/10.1176/pn.47.11.psychnews_47_11_13-aAbstractBig changes are in the works for how psychiatrists code for their services, including deleting many familiar codes, revising some current codes, and creating new codes to more accurately reflect the way psychiatry is practiced today.After a review of codes in the psychiatry section of Current Procedural Terminology (CPT)—the handbook of codes used by all physicians to receive reimbursement for services—the AMA CPT Editorial Panel has approved a number of important changes, including the elimination of code 90862 for pharmacologic management (see table). Staff of APA’s Office of Healthcare Systems and Financing pointed out that general Evaluation and Management (E&M) codes can be used by psychiatrists to describe the work of this service now. Members are urged to familiarize themselves with the E&M codes by visiting APA’s online course on E/M coding at www.apaeducation.org.Ronald Burd, M.D., chair of APA’s Committee on RBRVS, Codes, and Reimbursement and a participant in the review process, said that in all likelihood a new coding structure will be instituted that will include—like the E&M codes available to all physicians (99xxx series codes)—levels of complexity that will make it possible to more accurately capture clinical work with psychiatric patients.APA is undertaking outreach to commercial and public payers to ensure that they are aware of the coming changes and will be prepared to reimburse appropriately under the new codes. The new coding framework is the product of an AMA-convened work group that included representatives from the AMA CPT panel, APA, American Academy of Child and Adolescent Psychiatry, American Nurses Association, American Psychiatric Nurses Association, American Psychological Association, and National Association of Social Workers. APA provided leadership in the shaping and development of the codes that will describe the work of psychiatrists, advanced-practice nurses, psychologists, and social workers.The AMA has released only general information about the code changes, and those who participated in the code review process are bound by a confidentiality agreement not to reveal any more information about the new coding until the 2013 CPT book is published by the AMA, which is anticipated in September or October.Although the changes have been accepted by the CPT Editorial Panel and recommended values for the new codes have been made to the Centers for Medicare and Medicaid Services (CMS) by the AMA’s Resource-Based Relative Value Update Committee (RUC), CMS has the ultimate say in accepting or modifying the RUC’s recommendations before valuation of the new codes is final in November. Look to APA’s Web site and Psychiatric News for coverage of these changes as they become public. ISSUES NewArchived

Assertion-based slicing and slice graphs

Abstract This paper revisits the idea of slicing programs based on their axiomatic semantics, rather than using criteria based on control/data dependencies. We show how the forward propagation of preconditions and the backward propagation of postconditions can be combined in a new slicing algorithm that is more precise than the existing specification-based algorithms. The algorithm is based on (a) a precise test for removable statements, and (b) the construction of a slice graph , a program control flow graph extended with semantic labels and additional edges that “short-circuit” removable commands. It improves on previous approaches in two aspects: it does not fail to identify removable commands; and it produces the smallest possible slice that can be obtained (in a sense that will be made precise). Iteration is handled through the use of loop invariants and variants to ensure termination. The paper also discusses in detail applications of these forms of slicing, including the elimination of (conditionally) unreachable and dead code, and compares them to other related notions.

“Slimming” a Java virtual machine by way of cold code removal and optimistic partial program loading

Embedded systems provide limited storage capacity. This limitation conflicts with the demands of modern virtual machine platforms, which require large amounts of library code to be present on each client device. These conflicting requirements are often resolved by providing specialized embedded versions of the standard libraries, but even these stripped down libraries consume significant resources. We present a solution for “always connected” mobile devices based on a zero footprint client paradigm. In our approach, all code resides on a remote server. Only those parts of applications and libraries that are likely to be needed are transferred to the mobile client device. Since it is difficult to predict statically which library parts will be needed at run time, we combine static analysis, opportunistic off-target linking and lazy code loading to transfer code with a high likelihood of execution ahead of time while the other code, such as exception code, remains on the server and is transferred only on demand. This allows us to perform not only dead code elimination, but also aggressive elimination of unused code. The granularity of our approach is flexible from class files all the way down to individual basic blocks. Our method achieves total code size reductions of up to 95%.

Precise interprocedural dependence analysis of parallel programs

It is known that interprocedural detection of copy constants and elimination of faint code in parallel programs are undecidable problems, if base statements are assumed to execute atomically. We show that these problems become decidable, if this assumption is abandoned. So, the (unrealistic) idealization from program verification “atomic execution of base statements” introduced in order to simplify matters, actually increases the difficulty of these problems from the point of view of program analysis: amazingly these problems become more tractable if we adopt a less idealized, more realistic model of execution. We introduce an effective abstract domain of antichains of dependence traces that allows us to perform a precise interprocedural dependence analysis in (non-atomically executing) parallel programs. The main idea is to trace sequences of dependences exhibited successively by program executions. We define operations on antichains of dependence traces and show that they precisely abstract the corresponding operations on sets of non-atomic program executions. Using these operations, we can analyze dependences by means of an abstract interpretation of constraint systems that characterize sets of program executions of interest. The result of the dependence analysis can in turn be used to detect all copy constants and to eliminate faint code. While the run-time of the algorithms is exponential in the number of program variables, it is polynomial in the program size. Hence, they are polynomial-time algorithms if the number of program variables is bounded. In order to justify their overall exponential run-time, we show that both detection of copy constants and elimination of faint code are intractable (NP-hard) even when the atomic execution idealization is abandoned. This holds already for parallel programs without loops or procedures.

A conjunctive type system for useless-code elimination

We investigate the use of conjunctive non-standard type inference for the elimination of useless code in higher-order typed functional programs. In particular, we present a non-standard type assignment system for detecting useless code together with a mapping that simplifies a program by removing the useless code detected using the system.

Using Java reflection to automate extension language parsing

An extension language is an interpreted programming language designed to be embedded in a domain-specific framework. The addition of domain-specific primitive operations to an embedded extension language transforms that vanilla extension language into a domain-specific language. The LUxWORKS processor simulator and debugger from Lucent uses Tcl as its extension language. After an overview of extension language embedding and LUxWORKS experience, this paper looks at using Java reflection and related mechanisms to solve three limitations in extension language - domain framework interaction. The three limitations are gradual accumulation of ad hoc interface code connecting an extension language to a domain framework, over-coupling of a domain framework to a specific extension language, and inefficient command interpretation. Java reflection consists of a set of programming interfaces through which a software module in a Java system can discover the structure of classes, methods and their associations in the system. Java reflection and a naming convention for primitive domain operations eliminate ad hoc interface code by supporting recursive inspection of a domain command interface and translation of extension language objects into domain objects. Java reflection, name-based dynamic class loading, and a language-neutral extension language abstraction eliminate language over-coupling by transforming the specific extension language into a runtime parameter. Java reflection and command objects eliminate inefficiency by bypassing the extension language interpreter for stereotyped commands. Overall, Java reflection helps to eliminate these limitations by supporting reorganization and elimination of handwritten code, and by streamlining interpretation.