Automatically generating personalized user interfaces with Supple

922
K.Z. Gajos et al. / Artificial Intelligence 174 (2010) 910–950
N
(
R
,
e
i
−
1
,
e
i
)
=
|
p
(
e
i
−
1
,
e
i
)
|−
2

k
=
1
⎧
⎨
⎩
N
(
sw
,
R
(
e
k
))
if child
(
e
k
,
e
k
−
1
)
∧
child
(
e
k
,
e
k
+
1
)
N
(
lv
,
R
(
e
k
))
if child
(
e
k
,
e
k
−
1
)
∧
child
(
e
k
+
1
,
e
k
)
N
(
ent
,
R
(
e
k
))
if child
(
e
k
−
1
,
e
k
)
(2)
where child
(
e
k
,
e
k
−
1
)
is true if e
k
−
1
is a child of e
k
. This formula iterates over the intermediate elements in the path,
distinguishing among the three kinds of transitions described in the previous section. If both e
k
−
1
and e
k
+
1
are children of
e
k
, then it is considered to be a sibling switch between the children of e
k
. If e
k
−
1
is a grandchild of e
k
+
1
, then the path is moving up the interface description hierarchy, and so it leaves e
k
. Finally, if the path is moving down the hierarchy, then it is entering e
k
The cost of navigation thus defined, it is easy to see that the total navigation-related part of the cost function is dependent on how many times individual interface elements are found to be on the path during the interactions recorded in the user trace. We thus define appropriate count functions #
sw
(
T ,
e
)
, #
ent
(
T ,
e
)
and #
lv
(
T ,
e
)
. Smoothing towards the uniform distribution (by adding a constant to each count) ensures that Supple avoids the pathological situations where some of the weights are Therefore, we may state the component cost of an interface element, R
(
e
)
, as:
$

R
(
e
),
T

=
#
sw
(
T
,
e
)
×
N

sw
,
R
(
e
)

+
#
ent
(
T
,
e
)
×
N

ent
,
R
(
e
)

+
#
lv
(
T
,
e
)
×
N

lv
,
R
(
e
)

+
#
(
T
,
e
)
×
M

R
(
e
)

(3)
The total cost of the rendering can be thus reformulated in terms of the component elements as
$

R
(
S
f
),
T

=

e
∈S
f
$

R
(
e
),
T

(4)
This cost can now be computed incrementally, element-by-element, as the rendering is constructed. Hence, this formulation of the cost function now satisfies the first two requirements listed at the beginning of this section it incorporates usage traces to emphasize some parts of the user interface over others, and it allows for incremental computation.
To address the third requirement, we introduce factor functions f
:
W × T →
. These functions, which take an assignment of a widget to a specification element and a usage trace as inputs, reflect the presence, absence or intensity of some property of the assigned widget. Because they take the usage trace as an input, they also reflect the expected importance of the underlying element. For example, the following factor
f
slider
_
for
_
number

R
(
e
),
T

=
#
(
T
,
e
)
×

1 if type of e
=
number
∧
R
(
e
)
=
slider
0 otherwise
(5)
will return the usage count for the element if it is of number type and is represented by a slider widget. In all other cases,
it will return 0. The following equation illustrates a more complex example:
f
list
_
undersize

R
(
e
),
T

=
#
(
T
,
e
)
×

number of choices list size if R
(
e
)
=
list
∧
number of choices
>
list size
0
otherwise
(6)
This factor favors larger list widgets in cases where a large number of discrete choices needs to be displayed to the user.
The design of this factor was motivated by the fact that the quantity number of choices list size is typically correlated with scrolling performance The factors can also be used to compute components of the navigation cost
N
, for example:
f
tab
_
switch

R
(
e
),
T

=
#
sw
(
T
,
e
)
×

1 if R
(
e
)
=
tab pane otherwise
(7)
This factor will return the number of switch transitions fora container element rendered as a tab pane.
By assigning a weight u
k
to each factor f
k
, and by creating factors for all the foreseeable concerns that might affect perception of interface quality, we can rewrite Eq. (3) as follows:
$

R
(
e
),
T

=
K

k
=
1
u
k
f
k

R
(
e
),
T

(8)
Now the particular style of user interfaces favored by the resulting cost function can be specified by an appropriate choice of weights. This satisfies the last of the three requirements posed for the cost function, namely that it be parametrized to allow for easy personalization of the user interface generation process. Combining Eqs. (4) and (8), the final formulation of the cost function used by Supple is as follows:
$

R
(
S
f
),
T

=

e
∈S
f
K

k
=
1
u
k
f
k

R
(
e
),
T

(9)

K.Z. Gajos et al. / Artificial Intelligence 174 (2010) 910–950
923

Download 5.78 Mb.

Share with your friends: