Buy used: $64.51

FREE delivery Tuesday, January 16

Select delivery location

Used: Like New | Details

Sold by From AMZN Warehouse

Fulfilled by Amazon

Access codes and supplements are not guaranteed with used items.

Follow the author

Ian Horrocks

Follow

Constructing the User Interface with Statecharts First Edition

by Ian Horrocks (Author)

3.3 4 ratings

See all formats and editions

Behind most non-trivial user interface screens lie complex webs of code that many practitioners in the software industry find difficult to control. Despite the obvious power and sophistication of user interface development tools, the majority of user interface software is difficult to understand because it is coded without an overall design. In this book, Ian Horrocks presents a proven technique for designing event-driven software using the UCM architecture and the statechart notation. The statechart approach to constructing user interface software results in code that can be:

* written quickly and easily,
* tested using white box techniques,
* repeatedly enhanced over the lifetime of a system,
* modified with a minimal risk of introducing unwanted side-effects,
* regression tested without the need for full re-tests.

This book provides a practical guide to constructing real user interfaces for real projects. It is primarily written for practising software engineers, but will also be invaluable to students wishing to gain an insight into user interface construction.

From the Back Cover

written quickly and easily,
tested using white box techniques,
repeatedly enhanced over the lifetime of a system, * modified with a minimal risk of introducing unwanted side-effects,
regression tested without the need for full re-tests.
This book provides a practical guide to constructing real user interfaces for real projects. It is primarily written for practicing software engineers, but will also be invaluable to students wishing to gain an insight into user interface construction.

0201342782B04062001

About the Author

Ian Horrocks is a professional software engineer working for BT, where he heads a team of developers designing user interface software.

0201342782AB04062001

ISBN-10

0201342782
ISBN-13

978-0201342789
Edition

First Edition
Publisher

Addison-Wesley
Publication date

January 17, 1999
Language

English
Dimensions

7 x 0.75 x 9.5 inches
Print length

253 pages
See all details

Product details

Publisher ‏ : ‎ Addison-Wesley; First Edition (January 17, 1999)
Language ‏ : ‎ English
Paperback ‏ : ‎ 253 pages
ISBN-10 ‏ : ‎ 0201342782
ISBN-13 ‏ : ‎ 978-0201342789
Item Weight ‏ : ‎ 13.8 ounces
Dimensions ‏ : ‎ 7 x 0.75 x 9.5 inches

Best Sellers Rank: #3,038,605 in Books (See Top 100 in Books)
- #889 in Software Design & Engineering
- #3,959 in Software Development (Books)
- #11,110 in Computer Software (Books)

Customer Reviews:
3.3 4 ratings

Important information

To report an issue with this product or seller, click here.

About the author

Follow authors to get new release updates, plus improved recommendations.

Ian Horrocks

Brief content visible, double tap to read full content.

Full content visible, double tap to read brief content.

Discover more of the author’s books, see similar authors, read author blogs and more

Customer reviews

3.3 out of 5

4 global ratings

3 star

0%

2 star

0%

1 star

33%

How customer reviews and ratings work

Sort reviews by

Top reviews from the United States

There was a problem filtering reviews right now. Please try again later.

Amazon Customer

Difficoult to read and apply

Reviewed in the United States on November 13, 2001

I don't know if the other reviewers have read the books carefully or not because the books have been over-rated. First of all, the book is filled with reference stuff to state theory. The useful stuffs are to help people HOW to get a gui done. In these aspects, the book did not do a very good job.
In conclusion, the book should be trimmed down in half and emphasizes more the practical writing of guis. A few lines of code make to little to understand if this tecnique is useful for REAL DEVELOPMENT.

Helpful

Jingleberry

Great introduction and motivation to statecharts

Reviewed in the United States on August 22, 2002

I really learned quite a lot from this book about statecharts, enough even to write my own book using the concepts to build device simulations (Flash MX for Interactive Simulation)!
The author gives compelling arguments for adapting the design methodology, and walks the reader through progressively more complex examples. The author's writing style is easy to read yet not fluffy or wordy.
If it were not for two points, I would have given this book 5 stars. First, I think he does not tie in the idea of the UCM (User interface, Control object, and Model layer) into the statecharts enough to show how they might fit together, or maybe I'm just a little dense. Second, his nod to coding statecharts should have been left out of the book -- it really didn't help me figure out how to code the charts by any means. In my book, I explore these areas pretty thoroughly.
All in all, though, a very worthwhile read that I recommend to all my colleagues who want to learn about the power of statecharts.

7 people found this helpful

Helpful

RA Botha

Note the CONSTRUCTING and not Designing

Reviewed in the United States on August 8, 2001

It is important to realize that this book is not about designing user interfaces. It states that quite clearly in the beginning and with a title like this it is not suppose to be. The book assumes that you know some user interface design principles and are applying them in the general screen designs.
Although it is fine that the book assumes you have the design skills, it is unfortunate that it in its examples does not use better design skills. Some of the screens/forms that are constructed in the book could also serve as good examples of how not to apply design knowledge - although there probably are worse. The author makes it clear that the book is not about the design of screens, but using well-designed screens as examples wouldn't hurt. It is however not big enough of a problem to degrade the star rating.
From a practical point of view the approach suggested in this book is very usable. Although one may design a complete system in this way, it will also serve useful in sub-systems and even individual screens. In essence this book deals with the problem that programmers started to face when event-driven programming became the norm. Before event-driven programming could predict the order in which pieces of program code are going to run. With event-driven program the events may happen in any unpredictable order. For the user interface designer this presents challenging problems regarding the currency and consistency of the user interface. This is the main problem addressed in this book.
The approach is based on splitting the presentation issues in two layers: user interface objects and control objects that manages the behavior of the user interface objects. In essence the modeling of the control objects are done using state charts.
A clear description of the approach is given. The handling of state charts is pretty much inline with state charts in UML although certain "customisations" are being introduced to cater for specific requirements. These are, however, fundamentally sound. The nicest aspect I suppose is that the book doesn't get stuck on the semantic aspects of state charts but provides very practical examples of how it can be used to model the behavioural dynamics of systems.
I found the book easy to read, especially as far as the basics are concerned. It is divided into four parts. Part 1, represented by chapters 1 - 5 (57 pages) deals with motivating the need for such an approach. Chapters 6 - 9 (Part 2) introduces the notational aspects of the approach in a reasonably condensed 50 pages. Part 3 consist of three chapters that provides the state chart designs for three case studies. Part 4 (Chapters 13 - 15) deals with how to take this from state chart notation to physical code - in my opinion the crux of the problem. Several appendices are used to give more detail on the case studies presented in the book - a fact that certainly helps with the readability of the book.
I managed to convert the "code examples" given with reasonable ease to a product such as Visual Basic. I believe that it is written in such a way that the technique could easily be applied to any event-driven programming environment.
The book certainly fills a gap in the body of literature surrounding user interfaces and event-driven programming. It is one of those books that I believe is worthwhile reading just because of the ideas behind it. To which extent you will want to apply the techniques depends on circumstances, in particular the complexity of the user interface, but the book will make you think about formalizing the user interface construction process. If you are constructing complex user interfaces regularly this book is a must read.

17 people found this helpful

Helpful

Eric Fruttero

A Quantum ahead...

Reviewed in the United States on September 4, 2001

I have lost this book, and re-order it.
What is in there is simple and very effective. Few computer books have this kind of impact. The code examples are not elegant, use a SateChart engine instead (built your own, or use something like xjCharts...).
Way of the future (but don't forget to provide your SateCharts diagrams with your code :-)
Great little book !

4 people found this helpful

Helpful