Software for use : a practical guide to the models and methods of usage-centered design

cover image

Where to find it

Information & Library Science Library

Call Number
QA76.76.A65 C665 1999
Status
Available

Summary

In this text, the authors focus on the models and methods that will help programmers deliver more usable software - software that will allow users to accomplish their own tasks with greater ease and efficiency. They provide concrete tools and techniques that programmers can employ, and guide the readers through a systematic software development process. This process, called usage-centre design, weaves together two major threads in software development methods: cases and essential models. With numerous examples and case studies of both conventional and specialized software applications, the authors illustrate what has been shown in practice to work and what has proved to be of greatest practical value. The authors also make freely available a number of software tools and related materials on the Web.

Contents

  • Preface p. xv
  • Acknowledgments p. xix
  • 1 Introducing the Microsoft Visual Development Environment p. 1
  • 1.1 Visual Development Environment Windows p. 2
  • 1.2 Building an Existing Visual Fortran Project (Celsius) p. 4
  • 1.3 Editing CELSIUS.FOR p. 5
  • 2 Building Programs and Libraries p. 7
  • 2.1 Overview of Building Projects p. 8
  • 2.2 Types of Projects p. 11
  • 2.3 Defining Your Project p. 20
  • 2.4 Errors during the Build Process p. 34
  • 2.5 Compiler Limits p. 36
  • 2.6 Running Fortran Applications p. 37
  • 2.7 Porting Projects between x86 and Alpha Platforms p. 39
  • 2.8 Visual Fortran Samples p. 41
  • 3 Using the Compiler and Linker from the Command Line p. 43
  • 3.1 The Format of the DF Command p. 44
  • 3.2 Examples of the DF Command Format p. 48
  • 3.3 Input and Output Files p. 49
  • 3.4 Environment Variables Used with the DF Command p. 51
  • 3.5 Specifying Project Types with DF Command Options p. 52
  • 3.6 Redirecting Command-Line Output to Files p. 53
  • 3.7 Using the DF Command to Compile and Link p. 54
  • 3.8 DF Indirect Command File Use p. 60
  • 3.9 Compiler and Linker Messages p. 60
  • 4 Compiler and Linker Options p. 63
  • 4.1 Compiler Options p. 64
  • 4.2 Linker Options and Related Information p. 144
  • 4.3 Microsoft Fortran PowerStation Command-Line Compatibility p. 178
  • 5 Debugging Fortran Programs p. 185
  • 5.1 Preparing Your Program for Debugging p. 185
  • 5.2 Debugging the Squares Example Program p. 188
  • 5.3 Viewing Fortran Data Types in the Debugger p. 199
  • 5.4 Using the Array Viewer in the Debugger p. 202
  • 5.5 Locating Run-Time Errors in the Debugger p. 205
  • 6 Performance: Making Programs Run Faster p. 209
  • 6.1 Software Environment and Efficient Compilation p. 210
  • 6.2 Analyze Program Performance p. 216
  • 6.3 Data Alignment Considerations p. 222
  • 6.4 Use Arrays Efficiently p. 232
  • 6.5 Improve Overall I/O Performance p. 237
  • 6.6 Additional Source Code Guidelines for Run-Time Efficiency p. 242
  • 6.7 Optimization Levels: the /optimize Option p. 245
  • 6.8 Other Options Related to Optimization p. 262
  • 7 Using QuickWin p. 269
  • 7.1 Capabilities of QuickWin p. 270
  • 7.2 Comparing QuickWin with Windows-Based Applications p. 271
  • 7.3 Using Win32 with QuickWin p. 271
  • 7.4 Types of QuickWin Programs p. 272
  • 7.5 The QuickWin User Interface p. 274
  • 7.6 USE Statement Needed for QuickWin Applications p. 277
  • 7.7 Creating QuickWin Windows p. 277
  • 7.8 Using Graphics and Character-Font Routines p. 283
  • 7.9 Defining Graphics Characteristics p. 283
  • 7.10 Displaying Graphics Output p. 287
  • 7.11 Working with Screen Images p. 291
  • 7.12 Enhancing QuickWin Applications p. 294
  • 7.13 Customizing QuickWin Applications p. 295
  • 7.14 QuickWin Programming Precautions p. 306
  • 7.15 Simulating Nonblocking I/O p. 308
  • 8 Creating Fortran DLLs p. 309
  • 8.1 Coding Requirements for Sharing Procedures in DLLs p. 310
  • 8.2 Coding Requirements for Sharing Data in DLLs p. 312
  • 8.3 Building and Using Dynamic-Link Libraries p. 314
  • 9 Creating Windows Applications p. 321
  • 9.1 Coding Requirements for Fortran Windows Applications p. 322
  • 9.2 The Visual Fortran Windows Module p. 324
  • 9.3 Sample Fortran Windows Applications p. 326
  • 9.4 Getting Help with Windows Programming p. 326
  • 10 Portability and Design Considerations p. 327
  • 10.1 Portability p. 327
  • 10.2 Choosing Your Development Environment p. 337
  • 10.3 Selecting a Program Type p. 338
  • 10.4 Structuring Your Program p. 339
  • 10.5 Special Design Considerations p. 342
  • 10.6 Using the Special Features of Microsoft Windows p. 345
  • 11 Using Dialogs p. 349
  • 11.1 Using the Resource Editor to Design a Dialog p. 350
  • 11.2 Writing a Dialog Application p. 355
  • 11.3 Dialog Functions p. 362
  • 11.4 Dialog Controls p. 364
  • 11.5 Using Dialog Controls p. 371
  • 12 Drawing Graphics Elements p. 385
  • 12.1 Working with Graphics Modes p. 386
  • 12.2 Adding Color p. 395
  • 12.3 Understanding Coordinate Systems p. 399
  • 12.4 Advanced Graphics Using OpenGL p. 410
  • 13 Using Fonts from the Graphics Library p. 413
  • 13.1 Available Typefaces p. 414
  • 13.2 Using Fonts p. 414
  • 13.3 SHOWFONT.F90 Example p. 416
  • 14 Using National Language Support Routines p. 419
  • 14.1 Single and Multibyte Character Sets p. 421
  • 14.2 National Language Support Library Routines p. 421
  • 15 Portability Library p. 431
  • 15.1 Using the Portability Library p. 432
  • 15.2 Routines for Information Retrieval p. 432
  • 15.3 Process Control Routines p. 434
  • 15.4 Numeric Routines p. 435
  • 15.5 Input and Output with Portability Routines p. 436
  • 15.6 Date and Time Routines p. 437
  • 15.7 Error Handling Routines p. 439
  • 15.8 Miscellaneous String and Sorting Routines p. 439
  • 15.9 Other Compatibility Routines p. 440
  • 16 Files, Devices, and I/O Hardware p. 443
  • 16.1 Devices and Files p. 443
  • 16.2 I/O Hardware p. 462
  • 17 Using COM and Automation Objects p. 465
  • 17.1 The Role of the Module Wizard p. 465
  • 17.2 Using the Module Wizard to Generate Code p. 466
  • 17.3 Calling the Routines Generated by the Module Wizard p. 470
  • 17.4 Additional Information about COM and Automation Objects p. 477
  • 18 Programming with Mixed Languages p. 481
  • 18.1 Overview of Mixed-Language Issues p. 482
  • 18.2 Exchanging and Accessing Data in Mixed-Language Programming p. 499
  • 18.3 Handling Data Types in Mixed-Language Programming p. 508
  • 18.4 Visual Fortran/Visual C++ Mixed-Language Programs p. 522
  • 18.5 Fortran/Visual Basic Mixed-Language Programs p. 525
  • 18.6 Fortran/MASM Mixed-Language Programs p. 532
  • 19 Creating Multithread Applications p. 537
  • 19.1 Basic Concepts of Multithreading p. 538
  • 19.2 Writing a Multithread Program p. 539
  • 19.3 Compiling and Linking Multithread Programs p. 551
  • 19.4 Other Sources of Information p. 553
  • 20 Data Representation p. 555
  • 20.1 Integer Data Representations p. 557
  • 20.2 Logical Data Representations p. 559
  • 20.3 Native IEEE Floating-Point Representations p. 560
  • 20.4 Character Representation p. 563
  • 20.5 Hollerith Representation p. 563
  • 21 Handling Run-Time Errors p. 565
  • 21.1 Default Run-Time Error Processing p. 566
  • 21.2 Methods of Handling Errors p. 569
  • 21.3 Locating Run-Time Errors p. 572
  • 21.4 Using Traceback Information p. 573
  • 21.5 Run-Time Environment Variables p. 598
  • 22 The Floating-Point Environment p. 601
  • 22.1 Representing Numbers p. 602
  • 22.2 Loss of Precision Errors: Rounding, Special Values, Underflow, and Overflow p. 609
  • 22.3 Setting and Retrieving Floating-Point Status and Control Words (x86 Only) p. 613
  • 22.4 Handling Arithmetic Exceptions p. 618
  • 22.5 Intel Pentium Floating-Point Flaw (x86 Only) p. 622
  • 23 Converting Unformatted Numeric Data p. 625
  • 23.1 Supported Native and Nonnative Numeric Formats p. 625
  • 23.2 Limitations of Numeric Conversion p. 628
  • 23.3 Methods of Specifying the Data Format p. 629
  • 23.4 Additional Notes on Nonnative Data p. 633
  • 24 Using the IMSL Mathematical and Statistical Libraries p. 635
  • 24.1 Using the Libraries from Visual Fortran p. 636
  • 24.2 Library Naming Conventions p. 638
  • 24.3 Using IMSL Libraries in a Mixed-Language Environment p. 639
  • 25 Using Visual Fortran Tools p. 643
  • 25.1 Overview of Visual Fortran Tools p. 644
  • 25.2 Using Tools from the Command Line p. 647
  • 25.3 Setting Up the Command Console p. 648
  • 25.4 Fortran Compiler and Linker p. 650
  • 25.5 MS-DOS Editor p. 651
  • 25.6 Building Projects with NMAKE p. 651
  • 25.7 Resource Compiler Options p. 676
  • 25.8 Managing Libraries with LIB p. 680
  • 25.9 Editing Files with EDITBIN p. 689
  • 25.10 Examining Files with DUMPBIN p. 696
  • 25.11 Editing Format Descriptors with the Format Editor p. 698
  • 25.12 Profiling Code from the Command Line p. 700
  • 25.13 Fortran Tools: FSPLIT and FPR p. 718
  • A Hexadecimal-Binary-Octal-Decimal Conversions p. 721
  • B Compatibility Information p. 723
  • B.1 Compatibility with Microsoft Fortran PowerStation p. 723
  • B.2 Compatibility with Digital Fortran on Other Platforms p. 728

Sample chapter

Software for Use is a book for professionals under pressure, for those who work under the dual demands for high-quality software-based systems on the one hand and faster delivery with fewer resources on the other. This book shows how to use streamlined techniques to make software-based systems significantly more usable and useful regardless of whether these systems are installed on desktop computers, ensconced on large mainframe servers, embedded in industrial electronics, or accessed via the World Wide Web. It is written primarily for computer software and applications developers--the analysts, designers, engineers, and programmers who are responsible for producing software systems. In concept, perhaps, usability ought to be the bailiwick of usability specialists. In practice, however, developers of various stripes make the vast majority of the myriad decisions that shape and determine the ultimate usability of software-based products; it is for these frontline troops of the industry that this book was conceived. Usage-centered design, the approach taken in this book, originated with our own frustrating experiences as users of software and our recurring dissatisfaction with software that was unnecessarily awkward and difficult to use. The wealth of established knowledge about human-computer interaction was somehow not being fully translated into more usable products. As we studied how software-based products were being developed, we began to understand where things were going wrong and what needed to be changed in order to deliver better systems. Usage-centered design is a streamlined but systematic approach for devising software closely fitted to the genuine needs of users--software that is not only more useful and easier to use but also simpler and easier to construct. Usage-centered design is tailored to the high-pressure realities of modern software development. Using a few simple but powerful models, it provides a scheme for quickly understanding users in relation to systems, their working intentions in carrying out tasks, and the support they need from the system to perform those tasks. Its methods and models can be applied within almost any software development life cycle (SDLC) model and incorporated into almost any modern development practices, including various object-oriented (OO) approaches such as the Unified Modeling Language (UML). Usage-centered design is not partial to any one language or platform, being equally effective with rapid iterative development using the latest integrated visual development environments or with character-based control systems running on specialized hardware. A major part of our message to designers and developers of every ilk is simple: Usability is not rocket science. It is often hard work and invariably requires great attention to detail, but, given a few basic conceptual tools, you, too, can learn how to recognize problems in usability and how to improve the usability of the systems you develop. Professor Woody Flowers of the Massachusetts Institute of Technology has given cameras to middle-school students, who then must photograph hard-to-use things and explain the problems. If untrained teenagers can manage the basics of usability, competent adults ought to be able to master the essentials. Quite honestly, we think the model-driven approaches explained in this book can be of value to almost any professional with responsibility for product design and development, and that includes a full range of design specialists, from user interface and interaction designers to ergonomicists and human factors engineers, from graphic artists and industrial designers to human-computer interaction specialists and usability testers. In our experience, the most important prerequisite is not a particular academic degree or level of applied experience, but the willingness and ability to approach the material with an open mind. In our own design work and teaching, our emphasis has always been on simple, powerful techniques that can be quickly learned and applied. For example, a free-lance designer specializing in Web-based applications learned about usage-centered design techniques in a short conference presentation and was able to apply them immediately in her work. After attending a one-hour lecture, a project leader at a computer peripherals company taught his group how to improve the user interfaces of their software through use case models. Around the world are companies successfully applying these techniques to problems as diverse as banking applications, industrial automation controls, and commercial software development tools. We should not give the impression that usage-centered design is for everyone or for all problems. We use models as a kind of vaulting pole, to gain leverage and height in hurdling the problems of user interface design. In our experience, using simple models to understand a problem and potential solutions speeds up the process, but some newcomers to such techniques will find it difficult not to just skip up to the bar and leap before they look. Although we both have backgrounds heavy in the human sciences, we draw a sharp distinction between interesting research issues and the realities of everyday decision making. Among academics and professionals are those who seem to believe that human-machine interaction can be understood only through cognitive and perceptual psychology, that a thorough grounding in the academic literature is a prerequisite for doing effective interaction design. Our own views are that many of the complexities and subtleties that loom so large for researchers and research laboratories are of lesser consequence in everyday decision making. We consider the creative urge a vital force in good design, but we base it on a platform of sound engineering. Some professionals who think of user interfaces as a form of theater or consider design to be based primarily on artistic inspiration have had to struggle with the methodical nature of usage-centered design. On the other hand, the enthusiastic converts to our model-driven approach include designers and artists who have found that abstract models can inspire greater creativity. In organizing the book, we have striven to live up to our subtitle, creating a practical guide that is more than an introduction even if perhaps less than a handbook. To this end, the book is organized into distinct sections. Of course, they are written with the expectation that most readers who want to understand the material thoroughly will take them in sequence. In particular, most of the later chapters depend to a substantial degree on the conceptual foundation laid in the first six chapters. In fact, if all you seek is a general understanding of usage-centered design, Sections I and II cover the core material. In Sections III and IV, we shift to the sundry and sometimes messy details of practical application. This is likely to be of particularly keen interest to developers, especially those with limited background in user interface design, but we would not recommend beginning with these sections. In keeping with the practical, applied focus of the book, numerous small specific examples are used throughout the text. In addition, we have included two completely worked-out applications of usage-centered design. One, introduced in Chapter 4, is used for illustration throughout the middle chapters and concludes in Chapter 10; the other forms the whole of Chapter 15. If you are one of those "get-down-and-dirty" detail-oriented developers who cannot resist seeing how it all works out in the end, you might begin with the applied example in Chapter 15 before going back to build the necessary background by working through Chapters 4 through 14. Because we see on-line documentation to be an integral feature of the user interface and a major factor in usability, we have devoted an entire chapter to help systems. Once familiar with the basics in Chapters 2 and 3 plus Section II, technical writers and documentation specialists should find much of interest in Chapter 11. Professionals who already have a thorough background in human-computer interaction and user interface design and who are most interested in what makes usage-centered design unique may want to skip directly to the core material on the models and modeling techniques in Section II. Other material that has proved to be of particular interest to such professionals can be found in Chapter 12 on the progressive usage model and in Chapter 17 on usability metrics. Managers, project leaders, and others who might be more interested in the management and organizational implications of usage-centered design than in its technical details might start with the first two chapters, then skim Section V on assessment and improvement, and finish off with Section VI on organizing and managing the process. Despite its long gestation period, the material herein is still a work in progress. Just as it has been enhanced and extended through the contributions of our many students and clients, we anticipate it will also be advanced by you, our readers. As we tell every class we have ever taught, we want to hear from you. So, please tell us about your experiences in putting usage-centered design into practice, and we will keep improving on the usability of the process. 0201924781P04062001 Excerpted from Software for Use: A Practical Guide to the Models and Methods of Usage-Centered Design by Larry L. Constantine, Lucy A. D. Lockwood, Eonstantine - Acm Press Staff All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.

Other details