SHF: Small: Foundations for User Interface Programming
- View All
More than one-third of all program code exists to implement user interfaces and this code contains an even larger portion of all defects. This is no surprise; user interface code is seldom reusable and current event-handling-based approaches to user interface programming require programmers to manage a large number of details; too many to consistently produce correct and rich user interface behaviors. The impact is experienced by all computer users: user interfaces get stuck, behave illogically, lose information, lack crucial or useful functionality, or are simply confusing. The result is user frustration and wasted effort, a very significant cost when aggregated over all users, and significant even to one user when aggregated over all of his or her computer use. This project seeks advances in user interface programming, studying a declarative approach where many behaviors of user interfaces can be expressed as reusable algorithms encoded in software libraries. This drastically reduces the details that an application programmer needs to be concerned with; application-specific "event handling" code is not necessary at all. The goal is to significantly reduce the cost of producing high quality user interfaces, and, indirectly through better user interfaces, to make our interactions with computers less frustrating and more productive.The proposed declarative programming approach is based on multi-way data-flow constraint systems, which are applied to model the data directly manipulated by user interfaces and the dependencies within that data. The project seeks to show that once an application programmer specifies such a constraint system and connects it to the visual elements of a user interface, a large class of the interface''s behavior can be derived from reusable algorithms parametrized over the constraint system. Examples of such behaviors include updating values of elements based on user interaction on other user interface elements, enabling and disabling user interface elements, keeping the user interface maximally responsive by concurrently executing computations triggered by users'' interactions, managing changes in the structure of the user interface, and correctly orchestrating all of the above.