| |
Journal of Experimental Social Psychology, Vol. 44, No. 3. (May 2008), pp. 800-807.
Abstract
People evidence significant inaccuracies when predicting their response to many emotional life events. One unanswered question is whether such affective forecasting errors are due to participants’ poor estimation of their initial emotional reactions (an initial intensity bias ), poor estimation of the rate at which these emotional reactions diminish over time (a decay bias ), or both. The present research used intensive longitudinal procedures to explore this question in the wake of an upsetting life event: the dissolution of ...
|
| |
No. RJ 5118. (April 1986)
|
| |
Psychological Review, No. 104. (1997)
|
| |
Commun. ACM, Vol. 53, No. 2. (01 February 2010), pp. 66-75.
Abstract
How Coverity built a bug-finding tool, and a business, around the unlimited supply of bugs in software systems. ...
|
| |
In ICSE '09: Proceedings of the 2009 IEEE 31st International Conference on Software Engineering (2009), pp. 232-242.
Abstract
As software systems continue to grow and evolve, locating code for maintenance and reuse tasks becomes increasingly difficult. Existing static code search techniques using natural language queries provide little support to help developers determine whether search results are relevant, and few recommend alternative words to help developers reformulate poor queries. In this paper, we present a novel approach that automatically extracts natural language phrases from source code identifiers and categorizes the phrases and search results in a hierarchy. Our contextual search ...
|
| |
In RSSE '08: Proceedings of the 2008 international workshop on Recommendation systems for software engineering (2008), pp. 11-15.
Abstract
By surveying recommendation systems in software development, we found that existing approaches have been focusing on "you might like what similar developers like" scenarios. However structured artifacts and semantically well-defined development activities bear large potentials for further recommendation scenarios. We introduce a novel "landscape" of software development recommendation systems and line out several scenarios for knowledge sharing and collaboration. Basic challenges are improving context-awareness and particularly addressing information providers. ...
|
| |
(23 September 1993)
Abstract
An authoritative text by one of the premier researchers in usability engineering in the 1990s, Jakob Nielsen's <I>Usability Engineering</I> provides a landmark guide to software design that has helped bring this area of research into the mainstream of computing. "Usability" is the measurement of how easy or difficult it is to be productive with a piece of software. It often looks at the user interface--what elements appear onscreen and how efficient, confusing, and/or intuitive they are for beginning, intermediate, and advanced ...
|
| |
In RSSE '08: Proceedings of the 2008 international workshop on Recommendation systems for software engineering (2008), pp. 16-20.
Abstract
To ease framework understanding, tools have been developed that analyze existing framework instantiations to extract API usage patterns and present them to the user. However, detailed quantitative evaluations of such recommender systems are lacking. In this paper we present an automated evaluation process which extracts queries and expected results from existing code bases. This enables the validation of recommendation systems with large test beds in an objective manner by means of precision and recall measures. We demonstrate the applicability of our ...
|
| |
In RSSE '08: Proceedings of the 2008 international workshop on Recommendation systems for software engineering (2008), pp. 33-35.
Abstract
Large open source software repositories are polluted with incomplete or inadequately functioning projects having scarce or poor descriptions. Developers often search these repositories to find sample applications containing implementations of relevant features. While relying on software search engines that retrieve germane applications based on direct matches between user queries and words in the descriptions (or source code files), it is difficult to warrant that retrieved applications contain functionality described by their authors in project summaries. ...
|
| |
In ICPC '07: Proceedings of the 15th IEEE International Conference on Program Comprehension (2007), pp. 37-48.
Abstract
The paper addresses the problem of concept location in source code by presenting an approach which combines Formal Concept Analysis (FCA) and Latent Semantic Indexing (LSI). In the proposed approach, LSI is used to map the concepts expressed in queries written by the programmer to relevant parts of the source code, presented as a ranked list of search results. Given the ranked list of source code elements, our approach selects most relevant attributes from these documents and organizes the results in ...
|
| |
In ACE '08: Proceedings of the tenth conference on Australasian computing education (2008), pp. 3-17.
Abstract
In just thirty years, we have gone from punched cards to Second Life. But, as the American National Science Foundation (NSF) recently noted, "undergraduate computing education today often looks much as it did several decades ago" (NSF, 2006). Consequently, today's "Nintendo Generation" have voted with their feet. We bore them. The contrast between the changes wrought via computer research over the last 30 years, and the failure of computing education to adapt to those changes, is because computing academics ...
|
| |
Signal Processing Magazine, IEEE In Signal Processing Magazine, IEEE, Vol. 26, No. 3. (17 April 2009), pp. 37-47.
Abstract
What should we do to raise the quality of signal processing publications to an even higher level? We believe it to be crucial to maintain the precision in describing our work in publications, ensured through a high-quality reviewing process. We also believe that if the experiments are performed on a large data set, the algorithm is compared to the state-of-the-art methods, the code and/or data are well documented and available online, we will all benefit and make it easier to build ...
|
| |
Commun. ACM, Vol. 40, No. 5. (May 1997), pp. 80-91.
Abstract
Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references. ...
|
| |
New Computational Paradigms (2005), pp. 152-168.
Abstract
According to the interactive view of computation, communication happens during the computation, not before or after it. This approach, distinct from concurrency theory and the theory of computation, represents a paradigm shift that changes our understanding of what is computation and how it is modeled. Interaction machines extend Turing machines with interaction to capture the behavior of concurrent systems, promising to bridge these two fields. This promise is hindered by the widespread belief, incorrectly known as the Church-Turing thesis, that no ...
|
| |
In UIST '09: Proceedings of the 22nd annual ACM symposium on User interface software and technology (2009), pp. 183-192.
Abstract
We present Sikuli, a visual approach to search and automation of graphical user interfaces using screenshots. Sikuli allows users to take a screenshot of a GUI element (such as a toolbar button, icon, or dialog box) and query a help system using the screenshot instead of the element's name. Sikuli also provides a visual scripting API for automating GUI interactions, using screenshot patterns to direct mouse and keyboard events. We report a web-based user study showing that searching by screenshot is ...
|
| |
Molecular Cell, Vol. 35, No. 6. (24 September 2009), pp. 726-728.
Abstract
Choosing good problems is essential for being a good scientist. But what is a good problem, and how do you choose one? The subject is not usually discussed explicitly within our profession. Scientists are expected to be smart enough to figure it out on their own and through the observation of their teachers. This lack of explicit discussion leaves a vacuum that can lead to approaches such as choosing problems that can give results that merit publication in valued journals, resulting ...
|
| |
(29 April 2003)
Abstract
How is the human brain like the AIDS epidemic? Ask physicist Albert-LászlóBarabási and he'll explain them both in terms of networks of individual nodesconnected via complex but understandable relationships. _Linked: The NewScience of Networks_ is his bright, accessible guide to the fundamentalsunderlying neurology, epidemiology, Internet traffic, and many other fieldsunited by complexity.Barabási's gift for concrete, nonmathematical explanations and penchant foreccentric humor would make the book thoroughly enjoyable even if the contentweren't engaging. But the results of Barabási's research into the behavior ...
|
| |
Software Engineering - Companion Volume, 2009. ICSE-Companion 2009. 31st International Conference on (24 May 2009), pp. 263-266.
Abstract
Social networking systems help people maintain connections to their friends, enabling awareness, communication, and collaboration, especially at a distance. In many studies of coordination in software engineering, the work artifacts, e.g. code, bugs, specifications, are themselves the objects that link engineers together. In this paper, we introduce Codebook, a social networking Web service in which people can be ldquofriendsrdquo not only with other people but with the work artifacts they share with them. Providing a Web interface to the graph of ...
|
| |
Software: Practice and Experience, Vol. 38, No. 6. (2008), pp. 557-573.
Abstract
Regular expressions are a powerful tool for analyzing and manipulating text. Their theoretical background lies within automata theory and formal languages. The FIRE/J (fast implementation of regular expressions for Java) regular expression library is designed to provide maximum execution speed while remaining portable across different machine architectures. To achieve that, FIRE/J transforms each regular expression into a tailor-made class file, which is compiled directly to Java virtual machine (JVM) bytecodes. The library is compatible with the POSIX standard. Copyright © 2007 ...
|
| |
In SOFSEM 2010: Theory and Practice of Computer Science , Vol. 5901 (2010), pp. 77-95.
Abstract
The biggest challenge facing software developers today is how to gracefully evolve complex software systems in the face of changing requirements. We clearly need software systems to be more dynamic, compositional and model-centric, but instead we continue to build systems that are static, baroque and inflexible. How can we better build change-enabled systems in the future? To answer this question, we propose to look back to one of the most successful systems to support change, namely Smalltalk. We briefly introduce Smalltalk ...
|
| |
IEEE Transactions on Software Engineering, Vol. 35, No. 6. (15 December 2009), pp. 756-779.
Abstract
Visual notations form an integral part of the language of software engineering (SE). Yet historically, SE researchers and notation designers have ignored or undervalued issues of visual representation. In evaluating and comparing notations, details of visual syntax are rarely discussed. In designing notations, the majority of effort is spent on semantics, with graphical conventions largely an afterthought. Typically, no design rationale, scientific or otherwise, is provided for visual representation choices. While SE has developed mature methods for evaluating and designing semantics, ...
|
| |
In OOPSLA '89: Conference proceedings on Object-oriented programming systems, languages and applications (1989), pp. 71-75.
Abstract
Object-oriented programming languages support encapsulation, thereby improving the ability of software to be reused, refined, tested, maintained, and extended. The full benefit of this support can only be realized if encapsulation is maximized during the design process. We argue that design practices which take a data-driven approach fail to maximize encapsulation because they focus too quickly on the implementation of objects. We propose an alternative object-oriented design method which takes a responsibility-driven approach. We show how such an approach ...
|
| |
In CHI '07: Proceedings of the SIGCHI conference on Human factors in computing systems (2007), pp. 557-566.
Abstract
Software developers are rooted in the written form of their code, yet they often draw diagrams representing their code. Unfortunately, we still know little about how and why they create these diagrams, and so there is little research to inform the design of visual tools to support developers' work. This paper presents findings from semi-structured interviews that have been validated with a structured survey. Results show that most of the diagrams had a transient nature because of ...
|
| |
Visual Languages and Human-Centric Computing, 2007. VL/HCC 2007. IEEE Symposium on In Visual Languages and Human-Centric Computing, 2007. VL/HCC 2007. IEEE Symposium on (2007), pp. 157-162.
Abstract
This paper presents the creation, deployment, and evaluation of a large-scale, spatially-stable, paper-based visualization of a software system. The visualization was created for a single team, who were involved systematically in its initial design and subsequent design iterations. The evaluation indicates that the visualization supported the "onboarding" scenario but otherwise failed to realize the research team's expectations. We present several lessons learned, and cautions to future research into large-scale, spatially-stable visualizations of software systems. ...
|
| |
|
| |
SIGPLAN Not., Vol. 23, No. 10. (October 1988), pp. 85-92.
Abstract
Using Smalltalk-80, programmers can produce prototypes much faster than with C or Pascal. What techniques do Smalltalk-80 programmers use to produce these prototypes? What is special about Smalltalk-80 that enables them to uses these techniques? Can these techniques be used with conventional languages such as C? In an attempt to answer these questions we interviewed experienced Smalltalk programmers and asked how they approach programming in Smalltalk. Such introspective interviews that are conducted after completion of a project are known to be ...
|
| |
Information Visualization, 2005. INFOVIS 2005. IEEE Symposium on In IEEE Symposium on Information Visualization (INFOVIS '05) (25 October 2005), pp. 219-224.
Abstract
Cartographers have long used flow maps to show the movement of objects from one location to another, such as the number of people in a migration, the amount of goods being traded, or the number of packets in a network. The advantage of flow maps is that they reduce visual clutter by merging edges. Most flow maps are drawn by hand and there are few computer algorithms available. We present a method for generating flow maps using hierarchical clustering given a ...
|
| |
Automated Software Engineering, 2008. ASE 2008. 23rd IEEE/ACM International Conference on In ASE '08: Proceedings of the 2008 23rd IEEE/ACM International Conference on Automated Software Engineering (2008), pp. 317-326.
Abstract
Code completion is a widely used productivity tool. It takes away the burden of remembering and typing the exact names of methods or classes: As a developer starts typing a name, it provides a progressively refined list of candidates matching the name. However, the candidate list always comes in alphabetic order, i.e., the environment is only second-guessing the name based on pattern matching. Finding the correct candidate can be cumbersome or slower than typing the full name. We present an approach ...
|
| |
|
| |
(9 Jan 2008)
Abstract
Prime Numbers clearly accumulate on defined spiral graphs,which run through the Square Root Spiral. These spiral graphs can be assigned to different spiral-systems, in which all spiral-graphs have the same direction of rotation and the same -second difference- between the numbers, which lie on these spiral-graphs. A mathematical analysis shows, that these spiral graphs are caused exclusively by quadratic polynomials. For example the well known Euler Polynomial x2+x+41 appears on the Square Root Spiral in the form of three spiral-graphs, which are defined by three different quadratic polynomials. ...
|
| |
The American Mathematical Monthly, Vol. 74, No. 1. (1967), pp. 43-44.
|
| |
The American Mathematical Monthly, Vol. 71, No. 5. (1964), pp. 516-520.
|
| |
Computer, Vol. 10, No. 8. (0 August 1977), pp. 70-71.
|
| |
Frontiers in Education, 2005. FIE '05. Proceedings 35th Annual Conference (22 October 2005), pp. S1J-11.
Abstract
Novice programmers often have difficulty understanding the interactions between the objects in their programs. Many studies have shown that visual representations of computer memory can aid students' comprehension. One such representation, developed by Gries and Gries, divides computer memory into three areas: one for the call stack, one for static objects allocated on the heap ("static space"), and one for normal heap objects ("object space"). Memview, an extension to the DrJava IDE developed at Rice University, is a dynamic, interactive display ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 3-14.
Abstract
Traditional treatment of scoping in programming languages considers two opposite semantics: static scoping, where the scope of a binding is a block of program text, and dynamic scoping, where a binding is in effect during the whole reduction of an expression to a value. Static scoping and dynamic scoping are however but two points in the design space of scoping mechanisms. As a result, most proposed language mechanisms that rely on some notion of scoping, such as variable bindings of course, ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 15-26.
Abstract
We show how package templates, a modularization mechanism originally developed for statically typed languages like Java and C#, can be applied to and implemented in a dynamic language like Groovy, by using the language's capabilities for meta-programming. We then consider a set of examples and discuss dynamic PT from the viewpoints of code modularization and reuse, and dynamic adaption of classes at runtime. ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 27-38.
Abstract
Behavioral software contracts express properties concerning the flow of values across component (modules, classes, etc) interfaces. These properties are often beyond the reach of theorem provers and are therefore monitored at run-time. When the monitor discovers a contract violation, it raises an exception that simultaneously pinpoints the contract violator and explains the nature of the violation. ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 39-48.
Abstract
Mython is an extensible variant of the Python programming language. Mython achieves extensibility by adding a quotation mechanism that accepts an additional parameter as well as the code being quoted. The additional quotation parameter takes the form of a Mython expression. Unlike other user code, Mython evaluates the quotation parameter at compile-time. The result of the compile-time expression is a function that is used to both parse the quoted code, and extend the compile-time environment. By explicitly passing the compilation environment ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 49-58.
Abstract
JavaScript programmers make extensive use of event-driven programming to help build responsive web applications. However, standard approaches to sequencing events are messy, and often lead to code that is difficult to understand and maintain. We have found that arrows , a generalization of monads , are an elegant solution to this problem. Arrows allow us to easily write asynchronous programs in small, modular units of code, and flexibly compose them in many different ways, while nicely abstracting the details ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 69-78.
Abstract
Type inference and type reconstruction derive static types for program elements that have no static type associated with them. They have a wide range of usage, such as helping to eliminate the burden of manually specifying types, verifying whether a program is type-safe, helping to produce more optimized code or helping to understand programs. While type inference and type reconstruction is an active field of research, most existing techniques are interested foremost in the precision of their approaches, at the expense ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 79-88.
Abstract
Creating an interpreter is a simple and fast way to implement a dynamic programming language. With this ease also come major drawbacks. Interpreters are significantly slower than compiled machine code because they have a high dispatch overhead and cannot perform optimizations. To overcome these limitations, interpreters are commonly combined with just-in-time compilers to improve the overall performance. However, this means that a just-in-time compiler has to be implemented for each language. ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 89-98.
Abstract
Ruby is a popular, dynamic scripting language that aims to "feel natural to programmers" and give users the "freedom to choose" among many different ways of doing the same thing. While this arguably makes programming in Ruby easier, it makes it hard to build analysis and transformation tools that operate on Ruby source code. In this paper, we present the Ruby Intermediate Language (RIL), a Ruby front-end and intermediate representation that addresses these. RIL includes an extensible GLR parser for Ruby, ...
|
| |
In DLS '09: Proceedings of the 5th symposium on Dynamic languages (2009), pp. 99-110.
Abstract
In order to construct a test-bed for investigating new programming paradigms for future "manycore" systems (i.e. those with at least a thousand cores), we are building a Smalltalk virtual machine that attempts to efficiently use a collection of 56-on-chip caches of 64KB each to host a multi-megabyte object heap. In addition to the cost of inter-core communication, two hardware characteristics influenced our design: the absence of hardware-provided cache-coherence, and the inability to move a single object from one core's cache to ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-1.
Abstract
The Sun Labs Lively Kernel is a new approach to Web programming. It provides a complete platform for Web applications, including dynamic graphics, network access, and development tools, and requires nothing more than available web browsers. We call the system "lively" for three reasons. It comes live off a web page. There is no installation. The entire system is written in JavaScript, and it becomes active as soon as the page is loaded by a browser. It can change itself and ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-12.
Abstract
This paper considers the difficulties linked to the static scheduling strategy of AspectJ and shows how to overcome them by turning to a more dynamic strategy, making it possible to order, cancel, and deploy aspects at runtime. We show that this more dynamic strategy can be obtained by a minor update of the semantics of AspectJ introducing the notion of current aspect group , that is, the aspects scheduled for the current join point. We show how to reflect this ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-12.
Abstract
Static and dynamic type systems have well-known strengths and weaknesses. Gradual typing provides the benefits of both in a single language by giving the programmer control over which portions of the program are statically checked based on the presence or absence of type annotations. This paper studies the combination of gradual typing and unification-based type inference with the goal of developing a system that helps programmers increase the amount of static checking in their program. The key question in ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-9.
Abstract
Typical implementations of dynamically typed languages treat floating-point numbers, or flonums , in a "boxed" form, since those numbers don't fit in a natural machine word if a few bits in the word are reserved for type tags. The naïve implementations allocate every instance of flonums in the heap, thus incur large overhead on numerically intensive computations. Compile-time type inference could eliminate boxing of some flonums, but it would be costly for highly dynamic scripting languages, in which a compiler ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-1.
Abstract
Programming languages are the medium used to express our wishes to a computer. Unlike human languages, we can alter, destroy, and create them at will. Despite this, mainstream programming languages are surprisingly homogeneous with the differences between them often amounting to little more than surface syntax issues. New ideas rarely get a toe-hold in the marketplace and those that do have typically been used for decades by a sizeable minority (e.g. dynamic typing). In this talk the speaker will suggest reasons ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-10.
Abstract
Predicate dispatching is a generalized form of dynamic dispatch, which has strong limitations when arbitrary predicates of the underlying base language are used. Unlike classes, which enforce subset relationships between their sets of instances, arbitrary predicates generally do not designate subsets of each other, so methods whose applicability is based on predicates cannot be ordered according to their specificity in the general case. This paper introduces a decidable but expressive alternative mechanism called filtered dispatch that adds a simple preprocessing step ...
|
| |
In DLS '08: Proceedings of the 2008 symposium on Dynamic languages (2008), pp. 1-10.
Abstract
Context-oriented programming proposes to treat execution context explicitly and to provide means for context-dependent adaptation at runtime. There are many mechanisms that can be used to make either variable bindings or application code adapt dynamically, like dynamically-scoped variables, dynamic layer activation, and contextual dispatch. There are no means however, to make actual values be context-dependent. This means that side effects engendered by dynamically-activated adaptations are potentially global. We propose contextual values : values that actually depend on the ...
|