Independent general principles for constructing responsive software systems
ACM Transactions on Computer Systems (TOCS)
Coding quality and tools in programming methods
ACM SIGSOFT Software Engineering Notes
SIGCSE '88 Proceedings of the nineteenth SIGCSE technical symposium on Computer science education
Applying Synthesis Principles to Create Responsive Software Systems
IEEE Transactions on Software Engineering
Designing menu display format to match input device format
ACM SIGCHI Bulletin
Efficient Delaunay triangulation using rational arithmetic
ACM Transactions on Graphics (TOG)
Algorithm 693: a FORTRAN package for floating-point multiple-precision arithmetic
ACM Transactions on Mathematical Software (TOMS)
Size and access inference for data-parallel programs
PLDI '91 Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation
A retargetable compiler for ANSI C
ACM SIGPLAN Notices
Foundations for the study of software architecture
ACM SIGSOFT Software Engineering Notes
A course on professionalism in the undergraduate CS curriculum
SIGCSE '93 Proceedings of the twenty-fourth SIGCSE technical symposium on Computer science education
Formally based profiling for higher-order functional languages
ACM Transactions on Programming Languages and Systems (TOPLAS)
Modeling program predictability
Proceedings of the 25th annual international symposium on Computer architecture
The concept of dynamic analysis
ESEC/FSE-7 Proceedings of the 7th European software engineering conference held jointly with the 7th ACM SIGSOFT international symposium on Foundations of software engineering
Using program transformations to derive line-drawing algorithms
ACM Transactions on Graphics (TOG)
Partial Evaluation of the Euclidean Algorithm, Revisited
Higher-Order and Symbolic Computation
Realizing the Performance Potential of Cobol
IEEE Software
Quality Improvement Using A Software Reuse Failure Modes Model
IEEE Transactions on Software Engineering
Symbolic Profiling for Multi-paradigm Declarative Languages
LOPSTR '01 Selected papers from the 11th International Workshop on Logic Based Program Synthesis and Transformation
Origins of Software Performance Engineering: Highlights and Outstanding Problems
Performance Engineering, State of the Art and Current Trends
Origins of Software Performance Engineering: Highlights and Outstanding Problems
Performance Engineering, State of the Art and Current Trends
Performance Prediction with Benchmaps
IPPS '96 Proceedings of the 10th International Parallel Processing Symposium
Efficiency issues for ray tracing
Journal of Graphics Tools
Program optimization for a pipelined machine a case study
SIGMETRICS '84 Proceedings of the 1984 ACM SIGMETRICS conference on Measurement and modeling of computer systems
Binomial coefficient computation: recursion or iteration?
ACM SIGCSE Bulletin
Optimizing loops in programs compiled with the IBM PL/I optimizing compiler
ACM SIGPLAN Notices
Reducing reverse-mode memory requirements by using profile-driven checkpointing
Future Generation Computer Systems
Efficiency issues for ray tracing
SIGGRAPH '05 ACM SIGGRAPH 2005 Courses
Quality emphasis at IBM's software engineering institute
IBM Systems Journal
Reducing reverse-mode memory requirements by using profile-driven checkpointing
Future Generation Computer Systems
Introduction to software performance engineering: origins and outstanding problems
SFM'07 Proceedings of the 7th international conference on Formal methods for performance evaluation
Textual authoring of interactive digital TV applications
Proceddings of the 9th international interactive conference on Interactive television
Cognitive model exploration and optimization: a new challenge for computational science
Computational & Mathematical Organization Theory
Verified heap theorem prover by paramodulation
Proceedings of the 17th ACM SIGPLAN international conference on Functional programming
Improving MPI applications with a new MPI_Info and the use of the memoization
Proceedings of the 20th European MPI Users' Group Meeting
| Hi-index | 0.00 |
The primary task of software engineers is the cost-effective development of maintainable and useful software. There are many secondary problems lurking in that definition. One such problem arises from the term "useful": to be useful in the application at hand, software must often be efficient (that is, use little time or space). The problem we will consider in this book is building efficient software systems. There are a number of levels at which we may confront the problem of efficiency. These are defined in Section 1.2 and include the overall system design, the program's algorithms and data structures, the translation to machine code, and the underlying system software and hardware; many books discuss efficiency. at each of those levels. In this book we will investigate efficiency at a design level that is practiced by many but discussed by few. This level is called "writing efficient code" and can be defined as follows: The activity of writing efficient code takes as input a high-level language program (which incorporates efficient algorithms and data structures) and produces as output a program in the same high-level language that is suitable for compilation into efficient machine code. The operations undertaken at this level are beneath most work on algorithms and data structures yet are too complex for most current and foreseeable compilers.