Coding Style Research Articles

Sartorial excess in Mary Sibande's ‘Sophie’

Mary Sibande has evolved the Sophie character that has defined her art practice – the domestic worker-cum-Victorian garment associated with her has grown in scale, becoming excessive. These exaggerated style codes or adaptations work at liberating the domestic worker from her lowly position in society. Empowerment, or the fantasy of what that may entail, is therefore enacted through dress and the ‘excess’ attached to it that visualises a desire for social mobility. This article presents a critical analysis of the notion of ‘sartorial excess’, employing dandyism as a theoretical tool to access the mechanics of dress as an art form that feeds off and challenges fashion and consumerism. Drawing from fashion theories advanced by Thorstein Veblen and Jean Baudrillard, the article demonstrates how democratising forces allowed fashion to become a tool of mobility – and the illusion of it. This will contribute towards a multifarious definition of sartorial excess that is both inherent to fashion, but as in Sibande's practice, is also a form of asserting difference and dislocating from the status quo.

Security monitor inlining and certification for multithreaded Java

Security monitor inlining is a technique for security policy enforcement whereby monitor functionality is injected into application code in the style of aspect-oriented programming. The intention is that the injected code enforces compliance with the policy (security), and otherwise interferes with the application as little as possible (conservativity and transparency). Such inliners are said to be correct. For sequential Java-like languages, inlining is well understood, and several provably correct inliners have been proposed. For multithreaded Java one difficulty is the need to maintain a shared monitor state. We show that this problem introduces fundamental limitations in the type of security policies that can be correctly enforced by inlining. A class of race-free policies is identified that precisely characterizes the inlineable policies by showing that inlining of a policy outside this class is either not secure or not transparent, and by exhibiting a concrete inliner for policies inside the class which is secure, conservative and transparent. The inliner is implemented for Java and applied to a number of practical application security policies. Finally, we discuss how certification in the style of proof-carrying code could be supported for inlined programs by using annotations to reduce a potentially complex verification problem for multithreaded Java bytecode to sequential verification of just the inlined code snippets.

How does family intervention improve the outcome of people with schizophrenia?

There is strong evidence of the efficacy of family psychosocial interventions for schizophrenia, but evidence of the role played by the attitudes of relatives in the therapeutic process is lacking. To study the effect of a family intervention on family attitudes and to analyse their mediating role in the therapeutic process 50 patients with schizophrenia and their key relatives undergoing a trial on the efficacy of a family psychosocial intervention were studied by means of the Affective Style Coding System, the Scale of Empathy, and the Relational Control Coding System. Specific statistical methods were used to determine the nature of the relationship of the relatives' attitudes to the outcome of family intervention. Family psychosocial intervention was associated with a reduction in relatives' guilt induction and dominance and an improvement in empathy. Empathy and lack of dominance were identified as independent mediators of the effect of family psychosocial intervention. The change in empathy and dominance during the first 9months of the intervention predicted the outcome in the following 15months. Relatives' empathy and lack of dominance are mediators of the beneficial effect of family psychosocial intervention on patient's outcome.

A Study of Different Coding Styles Affecting Code Readability

During software programming, code readability is very important because it affects the understanding of the code context, facilitates communication and collaboration between team members, and it avoids problematic software maintenance. In this study, our research hypothesis was that the coding style affects the code readability. Developers who do not comply with coding conventions and guidelines may be more likely to produce code with a low level of readability. To test this hypothesis, we investigated coding rule violations in the source code files of five open source projects and correlated the observed violations with the scores rated by a readability estimation function. We tested whether significant violations of coding conventions affected the readability of developed codes and identified the violations that were related specifically to low readability quality. We consider that our findings will improve the understanding of programmers so they can take appropriate action to generate better quality code.

Haskell before Haskell: an alternative lesson in practical logics of the ENIAC

This article expands on Curry's work on how to implement the problem of inverse interpolation on the ENIAC (1946) and his subsequent work on developing a theory of program composition (1948-1950). It is shown that Curry's hands-on experience with the ENIAC on the one side and his acquaintance with systems of formal logic on the other, were conductive to conceive a compact notation for program construction which in turn would be instrumental to a mechanical synthesis of programs. Since Curry's systematic programming technique pronounces a critique of the Goldstine-von Neumann style of coding, his calculus of program composition not only anticipates automatic programming but also proposes explicit hardware optimisations largely unperceived by computer history until Backus' famous ACM Turing Award lecture (1977). The cohesion of these findings asks for an integrative historiographical approach. An appendix gives, for the first time, a full description of Curry's arithmetic compiler.

Synchronization views for event-loop actors

The actor model has already proven itself as an interesting concurrency model that avoids issues such as deadlocks and race conditions by construction, and thus facilitates concurrent programming. The tradeoff is that it sacrifices expressiveness and efficiency especially with respect to data parallelism. However, many standard solutions to computationally expensive problems employ data parallel algorithms for better performance on parallel systems. We identified three problems that inhibit the use of data-parallel algorithms within the actor model. Firstly, one of the main properties of the actor model, the fact that no data is shared, is one of the most severe performance bottlenecks. Especially the fact that shared state can not be read truly in parallel. Secondly, the actor model on its own does not provide a mechanism to specify extra synchronization conditions on batches of messages which leads to event-level data-races. And lastly, programmers are forced to write code in a continuation-passing style (CPS) to handle typical request-response situations. However, CPS breaks the sequential flow of the code and is often hard to understand, which increases complexity and lowers maintainability. We proposes synchronization views to solve these three issues without compromising the semantic properties of the actor model. Thus, the resulting concurrency model maintains deadlock-freedom, avoids low-level race conditions, and keeps the semantics of macro-step execution.

JavaMarker: A Marking System for Java Programs

ABSTRACT In this paper a marking system for Java programming is presented which has been developed as a plug-in for a widely used editor, Eclipse. This system runs student submitted programs against previously defined test cases. Depending on the percentage of correct running code, a proper mark is awarded. Since this program was implemented in order to be used in a principles of programming course, we require students to practice coding with a correct style. Therefore, this system checks the style of the code and produces messages when a better style is expected. In some cases penalty marks are considered for improper code style. For this system to play an educational role, we allow students to submit more than once. With this we aim to help them learn from their mistakes. The number of submissions differs from one exercise to another and is defined dynamically by our system administration. We call this system JavaMarker. General Terms Design, Experimentation, Languages.

ElytS edoC

This paper presents a elytS edoC - a software used in writing source codes. The code's style encompasses formatting, things like indentation and spacing, commenting, program element order and identifier names. Although most style choices won't affect the compiled code or the program's run time behavior, style is a key aspect of the code's maintainability. And be cause we write code once, but over its life, we read it many times, it pays to keep the code in style that's easy to analyze, compehend, review, test and change.

Simulation and Analysis of Chaotic Direct Sequence Spread Spectrum TT&C System Tracking Performance

In the high dynamic environment of TT&C signals, taking the chaotic code instead of tradition code in the direct sequence spread spectrum tracking system, the effect that mapping parameters to the tracking system performance is simulated and analyzed. Comparing to the m code, the effect that code style to the tracking error is pointed in the different bandwidth and Carrier to noise ratio(CNR).

웹기반 프로그래밍 언어 강의 지원 시스템의 설계 및 구현

In this paper, we propose a web-based programming class support system to help a lecturer to teach a programming language to students effectively. The proposed system is composed of a error analysis step and a verification step. The error analysis step checks whether there are compile time errors or run time errors in each student`s submitted program. Given some errors, the system provides helpful feedback for the student to fix the errors. On the contrary, the system provides quick feedback after checking the source code style, comments, and plagiarism in the submitted program. As soon as the student submits the program, the student can see the check results. According to the result of utilizing the proposed system in a C programming language class, students tend to submit program assignments actively.

Lagrangian assessment of simulated surface current dispersion in the coastal ocean

A purely Lagrangian assessment of dispersion from modeled surface current trajectories in the coastal ocean is presented. Modeled trajectories come from ROMS simulations for the Southern California Bight during the 1996 through 1999 period. Data are from surface current trajectories collected primarily in the Santa Barbara Channel with CODE style drifters. Distributions of particle positions from trajectories emanating from launch locations within 10 kilometers of the coast throughout the Santa Barbara Channel that advect for one through four days (Lagrangian PDFs) are evaluated descriptively and quantitatively. The two dimensional Kolmogorov‐Smirnov (K‐S) statistical test for comparing discrete sampled data with a known probability distribution is the quantitative basis. In general, dispersion distributions from observations are similar to Lagrangian PDFs computed from modeled trajectories and the K‐S statistic quantifies this accordingly. A few specific regions of poor model‐data agreement are indicated and discussed. The purely Lagrangian assessment, elucidates an improved understanding of model performance and ocean circulation beyond that offered in a Eulerian sense, and is necessary when modeled trajectories are utilized for applied oceanographic and marine ecology problems.

Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform

We describe the implementation of first-class polymorphic delimited continuations in the programming language Scala. We use Scala's pluggable typing architecture to implement a simple type and effect system, which discriminates expressions with control effects from those without and accurately tracks answer type modification incurred by control effects. To tackle the problem of implementing first-class continuations under the adverse conditions brought upon by the Java VM, we employ a selective CPS transform, which is driven entirely by effect-annotated types and leaves pure code in direct style. Benchmarks indicate that this high-level approach performs competitively.

The meaning of style? Style reflexivity among Danish high school youths

Abstract In much of the cultural theory literature on youth, style has been said to have started as an expression of subcultural class and transformed into individualized identity projects in neo‐tribal sociality. This article discusses young, Danish consumers' discourses on style and style practice. The key characteristic of their style practice is the reflexivity they bring to bear on their negotiation of global style expression in local identity projects. This style reflexivity manifests itself in two themes: style switching and style code reflexivity. The article shows that consumers' reflexivity of style consumption constitutes not only a ‘folk theory’ of consumption that reflects the academic and popular vernacular of style, but also postmodern consumer research scholarship's mode of expression about style. How individual consumers handle style in a reflexive manner through folk theories of the market is unexplored in previous research on the consumption of style. Copyright © 2009 John Wiley & Sons, Ltd.

A pointer logic and certifying compiler

Proof-Carrying Code brings two big challenges to the research field of programming languages. One is to seek more expressive logics or type systems to specify or reason about the properties of low-level or high-level programs. The other is to study the technology of certifying compilation in which the compiler generates proofs for programs with annotations. This paper presents our progress in the above two aspects. A pointer logic was designed for PointerC (a C-like programming language) in our research. As an extension of Hoare logic, our pointer logic expresses the change of pointer information for each statement in its inference rules to support program verification. Meanwhile, based on the ideas from CAP (Certified Assembly Programming) and SCAP (Stack-based Certified Assembly Programming), a reasoning framework was built to verify the properties of object code in a Hoare style. And a certifying compiler prototype for PointerC was implemented based on this framework. The main contribution of this paper is the design of the pointer logic and the implementation of the certifying compiler prototype. In our certifying compiler, the source language contains rich pointer types and operations and also supports dynamic storage allocation and deallocation.

High-fidelity C/C++ code transformation

As software systems become increasingly massive, the advantages of automated transformation tools are clearly evident. These tools allow the machine to both reason about and manipulate high-level source code. They enable off-loading of mundane and laborious programming tasks from human developer to machine, thereby reducing cost and development time frames. Although there has been much work in software transformation, there still exist many hurdles in realizing this technology in a commercial domain. From our own experience, there are two significant problems that must be addressed before transformation technology can be usefully applied in a commercial setting. These are: (1) Avoiding disruption of the style (i.e., layout and commenting) of source code and the introduction of any undesired modifications that can occur as a side effect of the transformation process. (2) Correct automated handling of C preprocessing and the presentation of a semantically correct view of the program during transformation. Many existing automated transformation tools require source to be manually modified so that preprocessing constructs can be parsed. The real semantic of the program remains obscured resulting in the need for complicated analysis during transformation. Many systems also resort to pretty printing to generate transformed programs, which inherently disrupts coding style. In this paper we describe our own C/C++ transformation system, Proteus, that addresses both these issues. It has been tested on millions of lines of commercial C/C++ code and has been shown to meet the stringent criteria laid out by Lucent’s own software developers.

Approximate Structural Context Matching: An Approach to Recommend Relevant Examples

When coding to an application programming interface (API), developers often encounter difficulties, unsure of which class to subclass, which objects to instantiate, and which methods to call. Example source code that demonstrates the use of the API can help developers make progress on their task. This paper describes an approach to provide such examples in which the structure of the source code that the developer is writing is matched heuristically to a repository of source code that uses the API. The structural context needed to query the repository is extracted automatically from the code, freeing the developer from learning a query language or from writing their code in a particular style. The repository is generated automatically from existing applications, avoiding the need for handcrafted examples. We demonstrate that the approach is effective, efficient, and more reliable than traditional alternatives through four empirical studies

Concise and consistent naming

Approximately 70% of the source code of a software system consists of identifiers. Hence, the names chosen as identifiers are of paramount importance for the readability of computer programs and therewith their comprehensibility. However, virtually every programming language allows programmers to use almost arbitrary sequences of characters as identifiers which far too often results in more or less meaningless or even misleading naming. Coding style guides somehow address this problem but are usually limited to general and hard to enforce rules like "identifiers should be self-describing". This paper renders adequate identifier naming far more precisely. A formal model, based on bijective mappings between concepts and names, provides a solid foundation for the definition of precise rules for concise and consistent naming. The enforcement of these rules is supported by a tool that incrementally builds and maintains a complete identifier dictionary while the system is being developed. The identifier dictionary explains the language used in the software system, aids in consistent naming, and supports programmers by proposing suitable names depending on the current context.

Bug busters

One way to deal with bugs is to avoid them entirely. The approach would be wasteful because we'd be underutilizing the many automated tools and techniques that can catch bugs for us. Most tools for eliminating bugs work by tightening the specifications of what we build. At the program code level, tighter specifications affect the operations allowed on various data types, our program's behavior, and our code's style. Furthermore, we can use many different approaches to verify that our code is on track: the programming language, its compiler, specialized tools, libraries, and embedded tests are our most obvious friends. We can delegate bug busting to code. Many libraries come with hooks or specialized builds that can catch questionable argument values, resource leaks, and wrong ordering of function calls. Bugs many be a fact of life, but they're not inevitable. We have some powerful tools to find them before they mess with our programs, and the good news is that these tools get better every year.

Trustworthy systems through quantitative software engineering

Trustworthy systems through quantitative software engineering

Dandyism and Homosexuality in the Novels of Christian Kracht

Christian Kracht's best-selling novel Faserland (1995) was one of the most successful and controversial literary debuts of the 1990s. This text, which describes the journey of rich young man through late twentieth-century Germany as series of parties and drug experiences, has been regarded by many as novel of Affirmation statt Kritik (Freund 12), exalting self-indulgent contemporary consumer lifestyle. Kracht, the son of senior executive in the Axel Springer Verlag and, at the time of the book's publication, writer for the lifestyle magazine Tempo, was accused of producing the literary equivalent of the contents of Hochglanz-Magazin (Piepgras). Such was the offence caused by the novel, one reviewer reports, that some salespeople even refused to market it to bookshops (Gross, Aus dem Leben). In the few intervening years, both reviewers and academic critics have ventured to correct this initial reception of das am meisten misverstandene Buch der neunziger Jahre (Ein taumelt), pointing out that the novel is, in fact, an example of Rollenprosa, in which the reader is invited to adopt critical distance to the perspective of the first-person narrator (Biendarra 115). These reappraisals of Kracht's novel do not, however, address the prominent theme of homosexuality in the text. This seems surprising, given that the narrator's fears of homosexual men and of being perceived as homosexual man are sometimes explicitly and, at other moments, implicitly the main forces driving his journey across Germany and thus the plot of the novel itself. Indeed, as the critic Moritz Basler has observed, the novel can be consistently read as Problemstudie uber ein verpastes Coming-out (113). On the other hand, reviewers and critics have recognized that one of the chief thematic concerns of the novel is the disorientation and loss of identity experienced by narrator whose primary means of identity construction is through style, that is to say through his particular mode of consumption in consumer society. In this respect, the narrator is referred to as Dandy with haltlose Subjektivitat (Gross, Gesellenstuck; see also Hutelin), who demonstrates a fetishist idolatry of status symbols and the continuous scanning of style codes, attitudes and taste in order to help [...] establish aesthetic distinction (Liesegang 264). However, the question of how the narrator's frequent encounters with gay men