text:
@inproceedings{10.1145/3260866,
author = {Cousins, Steve},
title = {Session Details: Keynote Address},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260866},
doi = {10.1145/3260866},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449717,
author = {Olsen, Dan},
title = {Interactive Viscosity},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449717},
doi = {10.1145/1449715.1449717},
abstract = {When the Macintosh first made graphical user interfaces popular the notion of each person having their own computer was novel. Today's technology landscape is characterized by multiple computers per person many with far more capacity than that original Mac. The world of input devices, display devices and interactive techniques is far richer than those Macintosh days. Despite all of this diversity in possible interactions very few of these integrate well with each other. The monolithic isolated user interface architecture that characterized the Macintosh still dominates a great deal of today's personal computing. This talk will explore how possible ways to change that architecture so that information, interaction and communication flows more smoothly among our devices and those of our associates.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {1–2},
numpages = {2},
keywords = {future of user interfaces},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260867,
author = {Mackay, Wendy},
title = {Session Details: Interaction with Time and Space},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260867},
doi = {10.1145/3260867},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449719,
author = {Goldman, Dan B. and Gonterman, Chris and Curless, Brian and Salesin, David and Seitz, Steven M.},
title = {Video Object Annotation, Navigation, and Composition},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449719},
doi = {10.1145/1449715.1449719},
abstract = {We explore the use of tracked 2D object motion to enable novel approaches to interacting with video. These include moving annotations, video navigation by direct manipulation of objects, and creating an image composite from multiple video frames. Features in the video are automatically tracked and grouped in an off-line preprocess that enables later interactive manipulation. Examples of annotations include speech and thought balloons, video graffiti, path arrows, video hyperlinks, and schematic storyboards. We also demonstrate a direct-manipulation interface for random frame access using spatial constraints, and a drag-and-drop interface for assembling still images from videos. Taken together, our tools can be employed in a variety of applications including film and video editing, visual tagging, and authoring rich media such as hyperlinked video.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {3–12},
numpages = {10},
keywords = {direct manipulation, video annotation, video navigation, video interaction},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449720,
author = {Pongnumkul, Suporn and Wang, Jue and Cohen, Michael},
title = {Creating Map-Based Storyboards for Browsing Tour Videos},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449720},
doi = {10.1145/1449715.1449720},
abstract = {Watching a long unedited video is usually a boring experience. In this paper we examine a particular subset of videos, tour videos, in which the video is captured by walking about with a running camera with the goal of conveying the essence of some place. We present a system that makes the process of sharing and watching a long tour video easier, less boring, and more informative. To achieve this, we augment the tour video with a map-based storyboard, where the tour path is reconstructed, and coherent shots at different locations are directly visualized on the map. This allows the viewer to navigate the video in the joint location-time space. To create such a storyboard we employ an automatic pre-processing component to parse the video into coherent shots, and an authoring tool to enable the user to tie the shots with landmarks on the map. The browser-based viewing tool allows users to navigate the video in a variety of creative modes with a rich set of controls, giving each viewer a unique, personal viewing experience. Informal evaluation shows that our approach works well for tour videos compared with conventional media players.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {13–22},
numpages = {10},
keywords = {storyboard, video summarization, map, video browsing},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449721,
author = {Nakamura, Toshio and Igarashi, Takeo},
title = {An Application-Independent System for Visualizing User Operation History},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449721},
doi = {10.1145/1449715.1449721},
abstract = {A history-of-user-operations function helps make applications easier to use. For example, users may have access to an operation history list in an application to undo or redo a past operation. To provide an overview of a long operation history and help users find target interactions or application states quickly, visual representations of operation history have been proposed. However, most previous systems are tightly integrated with target applications and difficult to apply to new applications. We propose an application-independent method that can visualize the operation history of arbitrary GUI applications by monitoring the input and output GUI events from outside of the target application. We implemented a prototype system that visualizes operation sequences of generic Java Awt/Swing applications using an annotated comic strip metaphor. We tested the system with various applications and present results from a user study.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {23–32},
numpages = {10},
keywords = {program visualization, diagrams, storyboards, operation history, summarization},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449722,
author = {Luan, Qing and Drucker, Steven M. and Kopf, Johannes and Xu, Ying-Qing and Cohen, Michael F.},
title = {Annotating Gigapixel Images},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449722},
doi = {10.1145/1449715.1449722},
abstract = {Panning and zooming interfaces for exploring very large images containing billions of pixels (gigapixel images) have recently appeared on the internet. This paper addresses issues that arise when creating and rendering auditory and textual annotations for such images. In particular, we define a distance metric between each annotation and any view resulting from panning and zooming on the image. The distance then informs the rendering of audio annotations and text labels. We demonstrate the annotation system on a number of panoramic images.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {33–36},
numpages = {4},
keywords = {gigapixel images, image annotation},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260868,
author = {Baudisch, Patrick},
title = {Session Details: Gestures for Interaction},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260868},
doi = {10.1145/3260868},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449724,
author = {Bau, Olivier and Mackay, Wendy E.},
title = {OctoPocus: A Dynamic Guide for Learning Gesture-Based Command Sets},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449724},
doi = {10.1145/1449715.1449724},
abstract = {We describe OctoPocus, an example of a dynamic guide that combines on-screen feedforward and feedback to help users learn, execute and remember gesture sets. OctoPocus can be applied to a wide range of single-stroke gestures and recognition algorithms and helps users progress smoothly from novice to expert performance. We provide an analysis of the design space and describe the results of two experi-ments that show that OctoPocus is significantly faster and improves learning of arbitrary gestures, compared to con-ventional Help menus. It can also be adapted to a mark-based gesture set, significantly improving input time compared to a two-level, four-item Hierarchical Marking menu.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {37–46},
numpages = {10},
keywords = {octopocus, feedback, mouse input, dynamic guides, gesture recognition, pen input, feedforward},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449725,
author = {Fung, Richard and Lank, Edward and Terry, Michael and Latulipe, Celine},
title = {Kinematic Templates: End-User Tools for Content-Relative Cursor Manipulations},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449725},
doi = {10.1145/1449715.1449725},
abstract = {This paper introduces kinematic templates, an end-user tool for defining content-specific motor space manipulations in the context of editing 2D visual compositions. As an example, a user can choose the "sandpaper" template to define areas within a drawing where cursor movement should slow down. Our current implementation provides templates that amplify or dampen the cursor's speed, attenuate jitter in a user's movement, guide movement along paths, and add forces to the cursor. Multiple kinematic templates can be defined within a document, with overlapping templates resulting in a form of function composition. A template's strength can also be varied, enabling one to improve one's strokes without losing the human element. Since kinematic templates guide movements, rather than strictly prescribe them, they constitute a visual composition aid that lies between unaided freehand drawing and rigid drawing aids such as snapping guides, masks, and perfect geometric primitives.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {47–56},
numpages = {10},
keywords = {motor space manipulation, control/display ratio, soft constraints, sketching, relative pointing device, drawing},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449726,
author = {Sulaiman, Ahmed N. and Olivier, Patrick},
title = {Attribute Gates},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449726},
doi = {10.1145/1449715.1449726},
abstract = {Attribute gates are a new user interface element designed to address the problem of concurrently setting attributes and moving objects between territories on a digital tabletop. Motivated by the notion of task levels in activity theory, and crossing interfaces, attribute gates allow users to operationalize multiple subtasks in one smooth movement. We present two configurations of attribute gates; (1) grid gates which spatially distribute attribute values in a regular grid, and require users to draw trajectories through the attributes; (2) polar gates which distribute attribute values on segments of concentric rings, and require users to align segments when setting attribute combinations. The layout of both configurations was optimised based on targeting and steering laws derived from Fitts' Law. A study compared the use of attribute gates with traditional contextual menus. Users of attribute gates demonstrated both increased performance and higher mutual awareness.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {57–66},
numpages = {10},
keywords = {user interface components, pen-based input, tabletop territories, digital tabletops, large interactive displays, crossing interfaces},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260869,
author = {Booth, Kelly},
title = {Session Details: Touch and Pressure},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260869},
doi = {10.1145/3260869},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449728,
author = {Wilson, Andrew D. and Izadi, Shahram and Hilliges, Otmar and Garcia-Mendoza, Armando and Kirk, David},
title = {Bringing Physics to the Surface},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449728},
doi = {10.1145/1449715.1449728},
abstract = {This paper explores the intersection of emerging surface technologies, capable of sensing multiple contacts and of-ten shape information, and advanced games physics engines. We define a technique for modeling the data sensed from such surfaces as input within a physics simulation. This affords the user the ability to interact with digital objects in ways analogous to manipulation of real objects. Our technique is capable of modeling both multiple contact points and more sophisticated shape information, such as the entire hand or other physical objects, and of mapping this user input to contact forces due to friction and collisions within the physics simulation. This enables a variety of fine-grained and casual interactions, supporting finger-based, whole-hand, and tangible input. We demonstrate how our technique can be used to add real-world dynamics to interactive surfaces such as a vision-based tabletop, creating a fluid and natural experience. Our approach hides from application developers many of the complexities inherent in using physics engines, allowing the creation of applications without preprogrammed interaction behavior or gesture recognition.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {67–76},
numpages = {10},
keywords = {game physics engines, interactive surfaces},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449729,
author = {Benko, Hrvoje and Wilson, Andrew D. and Balakrishnan, Ravin},
title = {Sphere: Multi-Touch Interactions on a Spherical Display},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449729},
doi = {10.1145/1449715.1449729},
abstract = {Sphere is a multi-user, multi-touch-sensitive spherical display in which an infrared camera used for touch sensing shares the same optical path with the projector used for the display. This novel configuration permits: (1) the enclosure of both the projection and the sensing mechanism in the base of the device, and (2) easy 360-degree access for multiple users, with a high degree of interactivity without shadowing or occlusion. In addition to the hardware and software solution, we present a set of multi-touch interaction techniques and interface concepts that facilitate collaborative interactions around Sphere. We designed four spherical application concepts and report on several important observations of collaborative activity from our initial Sphere installation in three high-traffic locations.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {77–86},
numpages = {10},
keywords = {single-display groupware, spherical display, collaboration, surface computing, multi-touch},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449730,
author = {Davidson, Philip L. and Han, Jefferson Y.},
title = {Extending 2D Object Arrangement with Pressure-Sensitive Layering Cues},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449730},
doi = {10.1145/1449715.1449730},
abstract = {We demonstrate a pressure-sensitive depth sorting technique that extends standard two-dimensional (2D) manipulation techniques, particularly those used with multi-touch or multi-point controls. We combine this layering operation with a page-folding metaphor for more fluid interaction in applications requiring 2D sorting and layout.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {87–90},
numpages = {4},
keywords = {multi-touch, tilt, pressure, direct manipulation, sorting},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260870,
author = {Fogarty, James},
title = {Session Details: Tools and Infrastructures},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260870},
doi = {10.1145/3260870},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449732,
author = {Hartmann, Bj\"{o}rn and Yu, Loren and Allison, Abel and Yang, Yeonsoo and Klemmer, Scott R.},
title = {Design as Exploration: Creating Interface Alternatives through Parallel Authoring and Runtime Tuning},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449732},
doi = {10.1145/1449715.1449732},
abstract = {Creating multiple prototypes facilitates comparative reasoning, grounds team discussion, and enables situated exploration. However, current interface design tools focus on creating single artifacts. This paper introduces the Juxtapose code editor and runtime environment for designing multiple alternatives of both application logic and interface parameters. For rapidly comparing code alternatives, Juxtapose introduces selectively parallel source editing and execution. To explore parameter variations, Juxtapose automatically creates control interfaces for "tuning" application variables at runtime. This paper describes techniques to support design exploration for desktop, mobile, and physical interfaces, and situates this work in a larger design space of tools for explorative programming. A summative study of Juxtapose with 18 participants demonstrated that parallel editing and execution are accessible to interaction designers and that designers can leverage these techniques to survey more options, faster.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {91–100},
numpages = {10},
keywords = {prototyping, design tools, design alternatives},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@dataset{10.1145/review-1449715.1449732_R44313,
author = {Kiper, James Dennis},
title = {Review ID:R44313 for DOI: 10.1145/1449715.1449732},
publisher = {Association for Computing Machinery},
url = {https://doi.org/10.1145/review-1449715.1449732_R44313}
}

@inproceedings{10.1145/1449715.1449733,
author = {Pierce, Jeffrey S. and Nichols, Jeffrey},
title = {An Infrastructure for Extending Applications' User Experiences across Multiple Personal Devices},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449733},
doi = {10.1145/1449715.1449733},
abstract = {Users increasingly interact with a heterogeneous collection of computing devices. The applications that users employ on those devices, however, still largely provide user experiences that assume the use of a single computer. This failure is due in part to the difficulty of creating user experiences that span multiple devices, particularly the need to manage identifying, connecting to, and communicating with other devices. In this paper we present an infrastructure based on instant messaging that simplifies adding that additional functionality to applications. Our infrastructure elevates device ownership to a first class property, allowing developers to provide functionality that spans personal devices without writing code to manage users' devices or establish connections among them. It also provides simple mechanisms for applications to send information, events, or commands between a user's devices. We demonstrate the effectiveness of our infrastructure by presenting a set of sample applications built with it and a user study demonstrating that developers new to the infrastructure can implement all of the cross-device functionality for three applications in, on average, less than two and a half hours.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {101–110},
numpages = {10},
keywords = {application development, infrastructure, multi-device services, multi-device user experiences},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449734,
author = {Yeh, Ron B. and Paepcke, Andreas and Klemmer, Scott R.},
title = {Iterative Design and Evaluation of an Event Architecture for Pen-and-Paper Interfaces},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449734},
doi = {10.1145/1449715.1449734},
abstract = {This paper explores architectural support for interfaces combining pen, paper, and PC. We show how the event-based approach common to GUIs can apply to augmented paper, and describe additions to address paper's distinguishing characteristics. To understand the developer experience of this architecture, we deployed the toolkit to 17 student teams for six weeks. Analysis of the developers' code provided insight into the appropriateness of events for paper UIs. The usage patterns we distilled informed a second iteration of the toolkit, which introduces techniques for integrating interactive and batched input handling, coordinating interactions across devices, and debugging paper applications. The study also revealed that programmers created gesture handlers by composing simple ink measurements. This desire for informal interactions inspired us to include abstractions for recognition. This work has implications beyond paper - designers of graphical tools can examine API usage to inform iterative toolkit development.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {111–120},
numpages = {10},
keywords = {device ensembles, augmented paper, evaluation, toolkits},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260871,
author = {Olsen, Dan},
title = {Session Details: Text and Speech},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260871},
doi = {10.1145/3260871},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449736,
author = {Park, Taehyun and Lank, Edward and Poupart, Pascal and Terry, Michael},
title = {Is the Sky Pure Today? AwkChecker: An Assistive Tool for Detecting and Correcting Collocation Errors},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449736},
doi = {10.1145/1449715.1449736},
abstract = {Collocation preferences represent the commonly used expressions, idioms, and word pairings of a language. Because collocation preferences arise from consensus usage, rather than a set of well-defined rules, they must be learned on a case-by-case basis, making them particularly challenging for non-native speakers of a language. To assist non-native speakers with these parts of a language, we developed AwkChecker, the first end-user tool geared toward helping non-native speakers detect and correct collocation errors in their writing. As a user writes, AwkChecker automatically flags collocation errors and suggests replacement expressions that correspond more closely to consensus usage. These suggestions include example usage to help users choose the best candidate. We describe AwkChecker's interface, its novel methods for detecting collocation errors and suggesting alternatives, and an early study of its use by non-native English speakers at our institution. Collectively, these contributions advance the state of the art in writing aids for non-native speakers.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {121–130},
numpages = {10},
keywords = {writing aids, linguistic tools, non-native speakers, collocation errors},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449737,
author = {Miller, Robert C. and Chou, Victoria H. and Bernstein, Michael and Little, Greg and Van Kleek, Max and Karger, David and schraefel, mc},
title = {Inky: A Sloppy Command Line for the Web with Rich Visual Feedback},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449737},
doi = {10.1145/1449715.1449737},
abstract = {We present Inky, a command line for shortcut access to common web tasks. Inky aims to capture the efficiency benefits of typed commands while mitigating their usability problems. Inky commands have little or no new syntax to learn, and the system displays rich visual feedback while the user is typing, including missing parameters and contextual information automatically clipped from the target web site. Inky is an example of a new kind of hybrid between a command line and a GUI interface. We describe the design and implementation of two prototypes of this idea, and report the results of a preliminary user study.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {131–140},
numpages = {10},
keywords = {command languages, natural language processing, web automation},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449738,
author = {Paek, Tim and Thiesson, Bo and Ju, Yun-Cheng and Lee, Bongshin},
title = {Search Vox: Leveraging Multimodal Refinement and Partial Knowledge for Mobile Voice Search},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449738},
doi = {10.1145/1449715.1449738},
abstract = {Internet usage on mobile devices continues to grow as users seek anytime, anywhere access to information. Because users frequently search for businesses, directory assistance has been the focus of many voice search applications utilizing speech as the primary input modality. Unfortunately, mobile settings often contain noise which degrades performance. As such, we present Search Vox, a mobile search interface that not only facilitates touch and text refinement whenever speech fails, but also allows users to assist the recognizer via text hints. Search Vox can also take advantage of any partial knowledge users may have about the business listing by letting them express their uncertainty in an intuitive way using verbal wildcards. In simulation experiments conducted on real voice search data, leveraging multimodal refinement resulted in a 28% relative reduction in error rate. Providing text hints along with the spoken utterance resulted in even greater relative reduction, with dramatic gains in recovery for each additional character.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {141–150},
numpages = {10},
keywords = {speech recognition, multimodal, mobile search},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260872,
author = {Landay, James},
title = {Session Details: Sketching, Drawing and Painting},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260872},
doi = {10.1145/3260872},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449740,
author = {Bae, Seok-Hyung and Balakrishnan, Ravin and Singh, Karan},
title = {ILoveSketch: As-Natural-as-Possible Sketching System for Creating 3d Curve Models},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449740},
doi = {10.1145/1449715.1449740},
abstract = {We present ILoveSketch, a 3D curve sketching system that captures some of the affordances of pen and paper for professional designers, allowing them to iterate directly on concept 3D curve models. The system coherently integrates existing techniques of sketch-based interaction with a number of novel and enhanced features. Novel contributions of the system include automatic view rotation to improve curve sketchability, an axis widget for sketch surface selection, and implicitly inferred changes between sketching techniques. We also improve on a number of existing ideas such as a virtual sketchbook, simplified 2D and 3D view navigation, multi-stroke NURBS curve creation, and a cohesive gesture vocabulary. An evaluation by a professional designer shows the potential of our system for deployment within a real design process.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {151–160},
numpages = {10},
keywords = {implicit mode change, axis widget, 3d curve, product design, sketch-based modeling, sketchability},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449741,
author = {Zeleznik, Robert C. and Bragdon, Andrew and Liu, Chu-Chi and Forsberg, Andrew},
title = {Lineogrammer: Creating Diagrams by Drawing},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449741},
doi = {10.1145/1449715.1449741},
abstract = {We present the design of Lineogrammer, a diagram-drawing system motivated by the immediacy and fluidity of pencil-drawing. We attempted for Lineogrammer to feel like a modeless diagramming "medium" in which stylus input is immediately interpreted as a command, text label or a drawing element, and drawing elements snap to or sculpt from existing elements. An inferred dual representation allows geometric diagram elements, no matter how they were entered, to be manipulated at granularities ranging from vertices to lines to shapes. We also integrate lightweight tools, based on rulers and construction lines, for controlling higher-level diagram attributes, such as symmetry and alignment. We include preliminary usability observations to help identify areas of strength and weakness with this approach.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {161–170},
numpages = {10},
keywords = {pressure, disambiguation, gesture, snapping, pen-centric, handwriting, alignment, drawing, recognition, ruler, symmetry, sketching, beautification, pen, diagram},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449742,
author = {Olsen, Dan R. and Harris, Mitchell K.},
title = {Edge-Respecting Brushes},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449742},
doi = {10.1145/1449715.1449742},
abstract = {Digital paint is one of the more successful interactive applications of computing. Brushes that apply various effects to an image have been central to this success. Current painting techniques ignore the underlying image. By considering that image we can help the user paint more effectively. There are algorithms that assist in selecting regions to paint including flood fill, intelligent scissors and graph cut. Selected regions and the algorithms to create them introduce conceptual layers between the user and the painting task. We propose a series of "edge-respecting brushes" that spread paint or other effects according to the edges and texture of the image being modified. This restores the simple painting metaphor while providing assistance in working with the shapes already in the image. Our most successful fill brush algorithm uses competing least-cost-paths to identify what should be selected and what should not.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {171–180},
numpages = {10},
keywords = {min-graph-cut, flood-fill, intelligent scissors, least-cost painting, paint},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260873,
author = {Feiner, Steven},
title = {Session Details: Scratching, Tapping, Rubbing and Rolling},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260873},
doi = {10.1145/3260873},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449744,
author = {Li, Kevin A. and Baudisch, Patrick and Griswold, William G. and Hollan, James D.},
title = {Tapping and Rubbing: Exploring New Dimensions of Tactile Feedback with Voice Coil Motors},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449744},
doi = {10.1145/1449715.1449744},
abstract = {Tactile feedback allows devices to communicate with users when visual and auditory feedback are inappropriate. Unfortunately, current vibrotactile feedback is abstract and not related to the content of the message. This often clash-es with the nature of the message, for example, when sending a comforting message.We propose addressing this by extending the repertoire of haptic notifications. By moving an actuator perpendicular to the user's skin, our prototype device can tap the user. Moving the actuator parallel to the user's skin induces rub-bing. Unlike traditional vibrotactile feedback, tapping and rubbing convey a distinct emotional message, similar to those induced by human-human touch.To enable these techniques we built a device we call soundTouch. It translates audio wave files into lateral motion using a voice coil motor found in computer hard drives. SoundTouch can produce motion from below 1Hz to above 10kHz with high precision and fidelity.We present the results of two exploratory studies. We found that participants were able to distinguish a range of taps and rubs. Our findings also indicate that tapping and rubbing are perceived as being similar to touch interactions exchanged by humans.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {181–190},
numpages = {10},
keywords = {vibrotactile, voice coil motor, haptics, force feedback, user interfaces},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449745,
author = {Bi, Xiaojun and Moscovich, Tomer and Ramos, Gonzalo and Balakrishnan, Ravin and Hinckley, Ken},
title = {An Exploration of Pen Rolling for Pen-Based Interaction},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449745},
doi = {10.1145/1449715.1449745},
abstract = {Current pen input mainly utilizes the position of the pen tip, and occasionally, a button press. Other possible device parameters, such as rolling the pen around its longitudinal axis, are rarely used. We explore pen rolling as a supporting input modality for pen-based interaction. Through two studies, we are able to determine 1) the parameters that separate intentional pen rolling for the purpose of interaction from incidental pen rolling caused by regular writing and drawing, and 2) the parameter range within which accurate and timely intentional pen rolling interactions can occur. Building on our experimental results, we present an exploration of the design space of rolling-based interaction techniques, which showcase three scenarios where pen rolling interactions can be useful: enhanced stimulus-response compatibility in rotation tasks [7], multi-parameter input, and simplified mode selection.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {191–200},
numpages = {10},
keywords = {pen, input devices, multi degree of freedom input, rotation},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449746,
author = {Butler, Alex and Izadi, Shahram and Hodges, Steve},
title = {SideSight: Multi-"touch" Interaction around Small Devices},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449746},
doi = {10.1145/1449715.1449746},
abstract = {Interacting with mobile devices using touch can lead to fingers occluding valuable screen real estate. For the smallest devices, the idea of using a touch-enabled display is almost wholly impractical. In this paper we investigate sensing user touch around small screens like these. We describe a prototype device with infra-red (IR) proximity sensors embedded along each side and capable of detecting the presence and position of fingers in the adjacent regions. When this device is rested on a flat surface, such as a table or desk, the user can carry out single and multi-touch gestures using the space around the device. This gives a larger input space than would otherwise be possible which may be used in conjunction with or instead of on-display touch input. Following a detailed description of our prototype, we discuss some of the interactions it affords.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {201–204},
numpages = {4},
keywords = {novel hardware, multi-touch, proximity sensing, mobile device interaction},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449747,
author = {Harrison, Chris and Hudson, Scott E.},
title = {Scratch Input: Creating Large, Inexpensive, Unpowered and Mobile Finger Input Surfaces},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449747},
doi = {10.1145/1449715.1449747},
abstract = {We present Scratch Input, an acoustic-based input technique that relies on the unique sound produced when a fingernail is dragged over the surface of a textured material, such as wood, fabric, or wall paint. We employ a simple sensor that can be easily coupled with existing surfaces, such as walls and tables, turning them into large, unpowered and ad hoc finger input surfaces. Our sensor is sufficiently small that it could be incorporated into a mobile device, allowing any suitable surface on which it rests to be appropriated as a gestural input surface. Several example applications were developed to demonstrate possible interactions. We conclude with a study that shows users can perform six Scratch Input gestures at about 90% accuracy with less than five minutes of training and on wide variety of surfaces.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {205–208},
numpages = {4},
keywords = {surfaces, mobile devices, ad hoc interaction, gestures, acoustic sensing, finger input},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260874,
author = {Cousins, Steve},
title = {Session Details: Keynote Address},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260874},
doi = {10.1145/3260874},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449749,
author = {Breazeal, Cynthia},
title = {Living Better with Robots},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449749},
doi = {10.1145/1449715.1449749},
abstract = {The emerging field of Human-Robot Interaction is undergoing rapid growth, motivated by important societal challenges and new applications for personal robotic technologies for the general public. In this talk, I highlight several projects from my research group to illustrate recent research trends to develop socially interactive robots that work and learn with people as partners. An important goal of this work is to use interactive robots as a scientific tool to understand human behavior, to explore the role of physical embodiment in interactive technology, and to use these insights to design robotic technologies that can enhance human performance and quality of life. Throughout the talk I will highlight synergies with HCI and connect HRI research goals to specific applications in healthcare, education, and communication.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {209–210},
numpages = {2},
keywords = {human robot interaction, robots},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260875,
author = {Morris, Meredith Ringel},
title = {Session Details: Activity-Based Interaction},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260875},
doi = {10.1145/3260875},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449751,
author = {Voida, Stephen and Mynatt, Elizabeth D. and Edwards, W. Keith},
title = {Re-Framing the Desktop Interface around the Activities of Knowledge Work},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449751},
doi = {10.1145/1449715.1449751},
abstract = {The venerable desktop metaphor is beginning to show signs of strain in supporting modern knowledge work. In this paper, we examine how the desktop metaphor can be re-framed, shifting the focus away from a low-level (and increasingly obsolete) focus on documents and applications to an interface based upon the creation of and interaction with manually declared, semantically meaningful activities. We begin by unpacking some of the foundational assumptions of desktop interface design, describe an activity-based model for organizing the desktop interface based on theories of cognition and observations of real-world practice, and identify a series of high-level system requirements for interfaces that use activity as their primary organizing principle. Based on these requirements, we present the novel interface design of the Giornata system, a prototype activity-based desktop interface, and share initial findings from a longitudinal deployment of the Giornata system in a real-world setting.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {211–220},
numpages = {10},
keywords = {activity-based computing, context-aware computing, desktop computing, giornata, knowledge work},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449752,
author = {Congleton, Ben and Ackerman, Mark S. and Newman, Mark W.},
title = {The ProD Framework for Proactive Displays},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449752},
doi = {10.1145/1449715.1449752},
abstract = {A proactive display is an application that selects content to display based on the set of users who have been detected nearby. For example, the Ticket2Talk [17] proactive display application presented content for users so that other people would know something about them.It is our view that promising patterns for proactive display applications have been discovered, and now we face the need for frameworks to support the range of applications that are possible in this design space.In this paper, we present the Proactive Display (ProD) Framework, which allows for the easy construction of proactive display applications. It allows a range of proactive display applications, including ones already in the literature. ProD also enlarges the design space of proactive display systems by allowing a variety of new applications that incorporate different views of social life and community.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {221–230},
numpages = {10},
keywords = {proactive displays, awareness, audience-awareness, public displays, collaborative systems, software framework, cscw, ubiquitous computing, pervasive computing},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449753,
author = {Bernstein, Michael S. and Shrager, Jeff and Winograd, Terry},
title = {Taskpos\'{e}: Exploring Fluid Boundaries in an Associative Window Visualization},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449753},
doi = {10.1145/1449715.1449753},
abstract = {Window management research has aimed to leverage users' tasks to organize the growing number of open windows in a useful manner. This research has largely assumed task classifications to be binary -- either a window is in a task, or not -- and context-independent. We suggest that the continual evolution of tasks can invalidate this approach and instead propose a fuzzy association model in which windows are related to one another by varying degrees. Task groupings are an emergent property of our approach. To support the association model, we introduce the WindowRank algorithm and its use in determining window association. We then describe Taskpos\'{e}, a prototype window switch visualization embodying these ideas, and report on a week-long user study of the system.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {231–234},
numpages = {4},
keywords = {task management, window management},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449754,
author = {Wilson, Max L. and Andr\'{e}, Paul and schraefel, mc},
title = {Backward Highlighting: Enhancing Faceted Search},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449754},
doi = {10.1145/1449715.1449754},
abstract = {Directional faceted browsers, such as the popular column browser iTunes, let a person pick an instance from any column-facet to start their search for music. The expected effect is that any columns to the right are filtered. In keeping with this directional filtering from left to right, however, the unexpected effect is that the columns to the left of the click provide no information about the possible associations to the selected item. In iTunes, this means that any selection in the Album column on the right returns no information about either the Artists (immediate left) or Genres (leftmost) associated with the chosen album.Backward Highlighting (BH) is our solution to this problem, which allows users to see and utilize, during search, associations in columns to the left of a selection in a directional column browser like iTunes. Unlike other possible solutions, this technique allows such browsers to keep direction in their filtering, and so provides users with the best of both directional and non-directional styles. As well as describing BH in detail, this paper presents the results of a formative user study, showing benefits for both information discovery and subsequent retention in memory.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {235–238},
numpages = {4},
keywords = {columns, context, faceted, highlights, search},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260876,
author = {schraefel, mc},
title = {Session Details: Interacting with the Web},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260876},
doi = {10.1145/3260876},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449756,
author = {Adar, Eytan and Dontcheva, Mira and Fogarty, James and Weld, Daniel S.},
title = {Zoetrope: Interacting with the Ephemeral Web},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449756},
doi = {10.1145/1449715.1449756},
abstract = {The Web is ephemeral. Pages change frequently, and it is nearly impossible to find data or follow a link after the underlying page evolves. We present Zoetrope, a system that enables interaction with the historicalWeb (pages, links, and embedded data) that would otherwise be lost to time. Using a number of novel interactions, the temporal Web can be manipulated, queried, and analyzed from the context of familar pages. Zoetrope is based on a set of operators for manipulating content streams. We describe these primitives and the associated indexing strategies for handling temporal Web data. They form the basis of Zoetrope and enable our construction of new temporal interactions and visualizations.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {239–248},
numpages = {10},
keywords = {web, temporal informatics, web extraction},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449757,
author = {Nichols, Jeffrey and Hua, Zhigang and Barton, John},
title = {Highlight: A System for Creating and Deploying Mobile Web Applications},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449757},
doi = {10.1145/1449715.1449757},
abstract = {We present a new server-side architecture that enables rapid prototyping and deployment of mobile web applications created from existing web sites. Key to this architecture is a remote control metaphor in which the mobile device controls a fully functional browser that is embedded within a proxy server. Content is clipped from the proxy browser, transformed if necessary, and then sent to the mobile device as a typical web page. Users' interactions with that content on the mobile device control the next steps of the proxy browser. We have found this approach to work well for creating mobile sites from a variety of existing sites, including those that use dynamic HTML and AJAX technologies. We have conducted a small user study to evaluate our model and API with experienced web programmers.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {249–258},
numpages = {10},
keywords = {highlight, mobile web, proxy browser, dynamic html, javascript, proxy server},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449758,
author = {Tajima, Keishi and Ohnishi, Kaori},
title = {Browsing Large HTML Tables on Small Screens},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449758},
doi = {10.1145/1449715.1449758},
abstract = {We propose new interaction techniques that support better browsing of large HTML tables on small screen devices, such as mobile phones. We propose three modes for browsing tables: normal mode, record mode, and cell mode. Normal mode renders tables in the ordinary way, but provides various useful functions for browsing large tables, such as hiding unnecessary rows and columns. Record mode regards each row (or column) as the basic information unit and displays it in a record-like format with column (or row) headers, while cell mode regards each cell as the basic unit and displays each cell together with its corresponding row and column headers. For these table presentations, we need to identify row and column headers that explain the meaning of rows and columns. To provide users with both row and column headers even when the tables have attributes for only one of them, we introduce the concept of keys and develop a method of automatically discovering attributes and keys in tables. Another issue in these presentations is how to handle composite cells spanning multiple rows or columns. We determine the semantics of such composite cells and render them in appropriate ways in accordance with their semantics.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {259–268},
numpages = {10},
keywords = {key, attributes, pda, tabular, mobile phone, header},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/3260877,
author = {Klemmer, Scott},
title = {Session Details: Display and Input Technologies},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/3260877},
doi = {10.1145/3260877},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
numpages = {1},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449760,
author = {Izadi, Shahram and Hodges, Steve and Taylor, Stuart and Rosenfeld, Dan and Villar, Nicolas and Butler, Alex and Westhues, Jonathan},
title = {Going beyond the Display: A Surface Technology with an Electronically Switchable Diffuser},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449760},
doi = {10.1145/1449715.1449760},
abstract = {We introduce a new type of interactive surface technology based on a switchable projection screen which can be made diffuse or clear under electronic control. The screen can be continuously switched between these two states so quickly that the change is imperceptible to the human eye. It is then possible to rear-project what is perceived as a stable image onto the display surface, when the screen is in fact transparent for half the time. The clear periods may be used to project a second, different image through the display onto objects held above the surface. At the same time, a camera mounted behind the screen can see out into the environment. We explore some of the possibilities this type of screen technology affords, allowing surface computing interactions to extend 'beyond the display'. We present a single self-contained system that combines these off-screen interactions with more typical multi-touch and tangible surface interactions. We describe the technical challenges in realizing our system, with the aim of allowing others to experiment with these new forms of interactive surfaces.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {269–278},
numpages = {10},
keywords = {dual projection, projection-vision, switchable diffuser, surface technologies, hardware, optics},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449761,
author = {Harrison, Chris and Hudson, Scott E.},
title = {Lightweight Material Detection for Placement-Aware Mobile Computing},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449761},
doi = {10.1145/1449715.1449761},
abstract = {Numerous methods have been proposed that allow mobile devices to determine where they are located (e.g., home or office) and in some cases, predict what activity the user is currently engaged in (e.g., walking, sitting, or driving). While useful, this sensing currently only tells part of a much richer story. To allow devices to act most appropriately to the situation they are in, it would also be very helpful to know about their placement - for example whether they are sitting on a desk, hidden in a drawer, placed in a pocket, or held in one's hand - as different device behaviors may be called for in each of these situations. In this paper, we describe a simple, small, and inexpensive multispectral optical sensor for identifying materials in proximity to a device. This information can be used in concert with e.g., location information, to estimate, for example, that the device is "sitting on the desk at home", or "in the pocket at work". This paper discusses several potential uses of this technology, as well as results from a two-part study, which indicates that this technique can detect placement at 94.4% accuracy with real-world placement sets.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {279–282},
numpages = {4},
keywords = {material detection, context-aware, pdas, placement detection, location, sensors, situationally appropriate interaction, laptops, cell phones, mobile devices},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449762,
author = {Gallant, David T. and Seniuk, Andrew G. and Vertegaal, Roel},
title = {Towards More Paper-like Input: Flexible Input Devices for Foldable Interaction Styles},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449762},
doi = {10.1145/1449715.1449762},
abstract = {This paper presents Foldable User Interfaces (FUI), a combination of a 3D GUI with windows imbued with the physics of paper, and Foldable Input Devices (FIDs). FIDs are sheets of paper that allow realistic transformations of graphical sheets in the FUI. Foldable input devices are made out of construction paper augmented with IR reflectors, and tracked by computer vision. Window sheets can be picked up and flexed with simple movements and deformations of the FID. FIDs allow a diverse lexicon of one-handed and two-handed interaction techniques, including folding, bending, flipping and stacking. We show how these can be used to ease the creation of simple 3D models, but also for tasks such as page navigation.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {283–286},
numpages = {4},
keywords = {paper interface, foldable input device, organic user interface},
location = {Monterey, CA, USA},
series = {UIST '08}
}

@inproceedings{10.1145/1449715.1449763,
author = {Lee, Johnny C. and Hudson, Scott E. and Tse, Edward},
title = {Foldable Interactive Displays},
year = {2008},
isbn = {9781595939753},
publisher = {Association for Computing Machinery},
address = {New York, NY, USA},
url = {https://doi.org/10.1145/1449715.1449763},
doi = {10.1145/1449715.1449763},
abstract = {Modern computer displays tend to be in fixed size, rigid, and rectilinear rendering them insensitive to the visual area demands of an application or the desires of the user. Foldable displays offer the ability to reshape and resize the interactive surface at our convenience and even permit us to carry a very large display surface in a small volume. In this paper, we implement four interactive foldable display designs using image projection with low-cost tracking and explore display behaviors using orientation sensitivity.},
booktitle = {Proceedings of the 21st Annual ACM Symposium on User Interface Software and Technology},
pages = {287–290},
numpages = {4},
keywords = {foldable displays, privacy, projection, orientation sensitivity, augmented reality, mobile, interactive},
location = {Monterey, CA, USA},
series = {UIST '08}
}

license: Unlicense

repository: goyalkaraniit/acm-cr

repo_name: goyalkaraniit/acm-cr

branch_name: refs/heads/main

extension: bib


text:
/********************************************************************************
* File Name:
*   test_rf24phy_init.cpp
*
* Description:
*   Tests the initialization function of a RF24Phy::Phy object.
*
* 2019 | Brandon Braun | brandonbraun653@gmail.com
********************************************************************************/

/* Interface Under Test Includes */
#include <RF24Phy/RF24Phy.hpp>

/* Test Driver Includes */
#include <gtest/gtest.h>
#include <gmock/gmock.h>
//#include <Chimera/mock/spi.hpp>

#include <Chimera/spi.hpp>
#include <Chimera/gpio.hpp>

using ::testing::AtLeast;
using ::testing::Exactly;
using ::testing::_;
using ::testing::Mock;

TEST(RF24PhyTest_begin, normalOperation)
{
  /*------------------------------------------------
  Initialize test objects
  ------------------------------------------------*/
  Chimera::Mock::SPIMock spi;
  Chimera::Mock::GPIOMock gpio;

  RF24Phy::Phy radio(&spi, &gpio);

  /*------------------------------------------------
  Set up expectations
  ------------------------------------------------*/
  EXPECT_CALL(spi, setChipSelectControlMode(_))
    .Times(AtLeast(1));

  EXPECT_CALL(spi, setChipSelect(_))
    .Times(Exactly(2));

  EXPECT_CALL(gpio, setMode(_, _))
    .Times(Exactly(1));

  EXPECT_CALL(gpio, setState(_))
    .Times(AtLeast(1));

  /*------------------------------------------------
  Call FUT
  ------------------------------------------------*/
  bool result = radio.begin();

  EXPECT_EQ( result, true );
  EXPECT_EQ( result, radio.isInitialized() );
}

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: cpp


text:
DESCRIPTION = "Libretro Nintendo GameCube cores"

inherit retro-packagegroup

LIBRETRO_NGC_CORES ?= " \
    dolphin-libretro \
    dolphin-launcher-libretro \
"

RRECOMMENDS:${PN} = "${LIBRETRO_NGC_CORES}"

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
//
//  SmartPointers.h
//

#pragma once

#include "ReferenceCounter.h"

template<typename T> class WeakPtr;
template<typename T>
class SharedPtr
{
public:
    SharedPtr();
    SharedPtr(T* pointer);
    SharedPtr(T* pointer, ReferenceCounter* rc);
    SharedPtr(const SharedPtr<T>& p);
    SharedPtr(const WeakPtr<T>& p);
    ~SharedPtr();

    T& operator*()                                const;
    T* operator->()                               const;
    SharedPtr<T>& operator=(const SharedPtr<T>& p);
    bool operator==(const SharedPtr<T>& p)         const;
    bool operator!=(const SharedPtr<T>& p)         const;
    bool operator==(const T* const p)             const;
    bool operator!=(const T* const p)             const;
    bool operator!()                              const;

    T* Get()                 const { return m_object; }
    explicit operator bool() const { return m_object; }

    bool IsValid()           const { return m_object != nullptr; }
    void Reset();

    template<typename Y>
    SharedPtr<Y> As() const;

private:
    T* m_object;
    ReferenceCounter* m_rc;

    friend class WeakPtr<T>;
};

template<typename T>
SharedPtr<T>::SharedPtr() : m_object(nullptr), m_rc(nullptr)
{

}

template<typename T>
SharedPtr<T>::SharedPtr(T* pointer) : m_object(pointer), m_rc(nullptr)
{
    m_rc = new ReferenceCounter();
    m_rc->IncrementShared();
}

template<typename T>
SharedPtr<T>::SharedPtr(T* pointer, ReferenceCounter* rc) : m_object(pointer), m_rc(rc)
{
    if(m_rc)
    {
        m_rc->IncrementShared();
    }
}

template<typename T>
SharedPtr<T>::SharedPtr(const SharedPtr<T>& pointer) : m_object(pointer.m_object), m_rc(pointer.m_rc)
{
    if(m_rc)
    {
        m_rc->IncrementShared();
    }
}

template<typename T>
SharedPtr<T>::SharedPtr(const WeakPtr<T>& pointer) : m_object(pointer.m_object), m_rc(pointer.m_rc)
{
    if(!m_rc)
    {
        m_rc = new ReferenceCounter();
    }
    m_rc->IncrementShared();
}

template<typename T>
SharedPtr<T>::~SharedPtr()
{
    if(m_rc && m_rc->DecrementShared() == 0)
    {
        delete m_object;
        m_object = nullptr;
    }

    if(m_rc && m_rc->GetWeak() == 0)
    {
        delete m_rc;
        m_rc = nullptr;
    }
}

template<typename T>
T& SharedPtr<T>::operator*() const
{
    return *m_object;
}

template<typename T>
T* SharedPtr<T>::operator->() const
{
    return m_object;
}

template<typename T>
SharedPtr<T>& SharedPtr<T>::operator=(const SharedPtr<T>& other)
{
    if(*this != other)
    {
        if (m_rc && m_rc->DecrementShared() == 0)
        {
            delete m_object;
            m_object = nullptr;
        }

        if(m_rc && m_rc->GetWeak() == 0)
        {
            delete m_rc;
            m_rc = nullptr;
        }

        m_object = other.m_object;
        m_rc     = other.m_rc;

        m_rc->IncrementShared();
    }

    return *this;
}

template<typename T>
bool SharedPtr<T>::operator==(const SharedPtr<T>& other) const
{
    return m_object == other.m_object;
}

template<typename T>
bool SharedPtr<T>::operator!=(const SharedPtr<T>& other) const
{
    return m_object != other.m_object;
}

template<typename T>
bool SharedPtr<T>::operator==(const T* const other) const
{
    return m_object == other;
}

template<typename T>
bool SharedPtr<T>::operator!=(const T* const other) const
{
    return m_object != other;
}

template<typename T>
bool SharedPtr<T>::operator!() const
{
    return !m_object;
}

template<typename T>
void SharedPtr<T>::Reset()
{
    if (m_rc->DecrementShared() == 0)
    {
        delete m_object;
    }

    m_object = nullptr;
    m_rc     = nullptr;
}

template<typename T>
template<typename Y>
SharedPtr<Y> SharedPtr<T>::As() const
{
    if(std::is_base_of<T, Y>::value)
    {
        // Down cast - dynamic_cast required.
        Y* object = dynamic_cast<Y*>(m_object);
        return (object) ? SharedPtr<Y>(object, m_rc) : SharedPtr<Y>();
    }
    else
    {
        // Try static_cast if not.
        return SharedPtr<Y>(static_cast<Y*>(m_object), m_rc);
    }
}

repository: lmsierra/SmartPtrs

repo_name: lmsierra/SmartPtrs

extension: h


text:
//
// Created by Mark Plagge on 2019-03-04.
//

#ifndef NEMO2_CORE_LOGGER_H
#define NEMO2_CORE_LOGGER_H

#include <core/ross.h>
#include "../src/include/globals.h"
#include "../src/neuro/core.h"

#include "../src/neuro/TrueNorthCore.h"

//st_model_types test_trace[] =  {
//    {(ev_trace_f) core_ev_trace,
//    sizeof(nemo_message),
//    NULL,
//    NULL,
//    NULL,
//    NULL,
//    NULL},
//    {0},
//
//
//};
//
//struct membrane_pot_change{
//    int neuron_id;
//    long double old_value;
//    long double new_value;
//};
struct membrane_pot_log{
    tw_stime event_trigger_time;
//    std::vector<membrane_pot_change> membrane_pot_changes;
    std::vector<nemo_volt_type> original_membrane_pots;
    std::vector<nemo_volt_type> new_membrane_pots;
    bool changed;
    std::string to_string();

};
struct TrueNorthCoreLogger : TrueNorthCore{
    std::vector<nemo_message> messages;
    std::vector<membrane_pot_log> membrane_log;
    std::vector<nemo_volt_type> membrane_potential_v;

    void forward_event(tw_bf *bf, nemo_message *m, tw_lp *lp) override;

    TrueNorthCoreLogger(int coreLocalId);
    std::string mpot_to_string(bool only_changed);

};
#endif //NEMO2_CORE_LOGGER_H

repository: markplagge/NeMo-XE-Old

repo_name: markplagge/NeMo-XE-Old


text:
SUMMARY = "The calibrator and other useful utilities for TI wireless solution based on wl12xx driver"
LICENSE = "BSD-3-Clause"
LIC_FILES_CHKSUM = "file://COPYING;md5=4725015cb0be7be389cf06deeae3683d"

DEPENDS = "libnl"

PV = "0.1+gitr${SRCPV}"

SRCREV = "b03d9ce6362e6d22d6929f2736409af3b0fd3c88"
SRC_URI = "git://github.com/TI-OpenLink/ti-utils.git;branch=r5-jb"

S = "${WORKDIR}/git"

EXTRA_OEMAKE = 'CROSS_COMPILE=${TARGET_PREFIX} \
                CC="${TARGET_PREFIX}gcc ${TOOLCHAIN_OPTIONS}" \
                CFLAGS="${CFLAGS} -I${STAGING_INCDIR}/libnl3 -DCONFIG_LIBNL20" NLVER=3 \
                LDFLAGS="${LDFLAGS} ${TOOLCHAIN_OPTIONS}" \
'

#only install the calibrator utility, firmware is already within linux-firmware
do_install() {
    install -d ${D}${bindir}
    install -m 0755 calibrator ${D}${bindir}/
}

repository: astarche/meta-openembedded

repo_name: astarche/meta-openembedded

branch_name: refs/heads/nilrt/master/sumo


text:
/**
  题目地址：https://leetcode-cn.com/problems/power-of-three/

  解题：
	1.3的幂次方，一直除以3，直到结果是1 O(logn)
    2.计算许可范围内的最大3次方值，n如果是这个值得可除数，就是3的幂次方 O(1)
*/
package questionBank

func isPowerOfThree(n int) bool {
	if n <= 0 {
		return false
	}

	for n%3 == 0 {
		n = n / 3
	}

	return n == 1
}

repository: huaifufeng/leetcode-go

repo_name: huaifufeng/leetcode-go

extension: go


text:
#include <iostream>

class MyClass {
    public:
        MyClass() = default;
        MyClass(int value) : m_Value{ value } { }
        MyClass(int number1, int number2) : m_Value{ number1 + number2 } { }

        int GetValue() const { return m_Value; }

    private:
        int m_Value{ 0 };
};

template <typename T>
T Add(const T& a, const T& b) {
    return a + b;
}

template <>
MyClass Add(const MyClass& myClass1, const MyClass& myClass2) {
    return MyClass(myClass1.GetValue(), myClass2.GetValue());
}

template <typename T>
void Print(const T& value1, const T& value2, const T& result) {
    std::cout << "The result of adding " << value1 << " to " << value2
              << " is " << result << std::endl;
}

template <>
void Print(const MyClass& value1, const MyClass& value2, const MyClass& result) {
    std::cout << "The result of adding " << value1.GetValue()
              << " to " << value2.GetValue() << " is " << result.GetValue()
              << std::endl;
}

int main()
{
   const MyClass number1{ 1 };
   const MyClass number2{ 2 };
   const MyClass result{ Add(number1, number2) };
   Print(number1, number2, result);

   return 0;
}

repository: ordinary-developer/education

repo_name: ordinary-developer/education


text:
#include <gtkmm/window.h>
#include <gtkmm/image.h>
#include <gdkmm/pixbuf.h>
#include <gdk/gdkwayland.h>
#include <config.hpp>

#include <iostream>
#include <map>

#include <gtk-utils.hpp>
#include <wf-shell-app.hpp>

class WayfireBackground
{
    WayfireShellApp *app;
    WayfireOutput *output;
    zwf_wm_surface_v1 *wm_surface = NULL;

    Gtk::Window window;
    Gtk::Image image;

    bool inhibited = true;

    void create_wm_surface()
    {
        auto gdk_window = window.get_window()->gobj();
        auto surface = gdk_wayland_window_get_wl_surface(gdk_window);

        if (!surface)
        {
            std::cerr << "Error: created window was not a wayland surface" << std::endl;
            std::exit(-1);
        }

        wm_surface = zwf_shell_manager_v1_get_wm_surface(
            output->display->zwf_shell_manager, surface,
            ZWF_WM_SURFACE_V1_ROLE_BACKGROUND, output->handle);
        zwf_wm_surface_v1_configure(wm_surface, 0, 0);
    }

    int output_width, output_height;
    void handle_output_resize(uint32_t width, uint32_t height)
    {
        output_width = width;
        output_height = height;

        window.set_size_request(width, height);
        window.show_all();

        if (!wm_surface)
            create_wm_surface();

        set_background();
    }

    wf_option background_image;
    wf_option_callback image_updated;

    void set_background()
    {
        auto path = background_image->as_string();
        try {
            auto pbuf = Gdk::Pixbuf::create_from_file(path);
            int scale = window.get_scale_factor();
            pbuf = pbuf->scale_simple(output_width * scale,
                                      output_height * scale,
                                      Gdk::INTERP_BILINEAR);

            set_image_pixbuf(image, pbuf, scale);
            if (!image.get_parent())
            {
                window.add(image);
                window.show_all();
            }
        } catch (...)
        {
            window.remove();
            if (path != "none")
                std::cerr << "Failed to load background image " << path << std::endl;
        }

        if (inhibited)
        {
            zwf_output_v1_inhibit_output_done(output->zwf);
            inhibited = false;
        }
    }

    void setup_window()
    {
        window.set_resizable(false);
        window.set_decorated(false);

        background_image = app->config->get_section("background")
            ->get_option("image", "none");
        image_updated = [=] () { set_background(); };
        background_image->add_updated_handler(&image_updated);

        window.property_scale_factor().signal_changed().connect(
            sigc::mem_fun(this, &WayfireBackground::set_background));
    }

    public:
    WayfireBackground(WayfireShellApp *app, WayfireOutput *output)
    {
        this->app = app;
        this->output = output;

        zwf_output_v1_inhibit_output(output->zwf);
        setup_window();
        output->resized_callback = [=] (WayfireOutput*, uint32_t w, uint32_t h)
        {
            std::cout << "handle resize" << std::endl;
            handle_output_resize(w, h);
        };
    }

    ~WayfireBackground()
    {
        background_image->rem_updated_handler(&image_updated);
    }
};

class WayfireBackgroundApp : public WayfireShellApp
{
    std::map<WayfireOutput*, std::unique_ptr<WayfireBackground> > backgrounds;

    public:
    WayfireBackgroundApp(int argc, char **argv)
        : WayfireShellApp(argc, argv)
    {
    }

    void on_new_output(WayfireOutput *output)
    {
        backgrounds[output] = std::unique_ptr<WayfireBackground> (
            new WayfireBackground(this, output));
    }

    void on_output_removed(WayfireOutput *output)
    {
        backgrounds.erase(output);
    }
};

int main(int argc, char **argv)
{
    WayfireBackgroundApp background_app(argc, argv);
    background_app.run();
    return 0;
}

repository: JohnathanFL/wf-shell

repo_name: JohnathanFL/wf-shell


text:
# CMake version number components.
set(CMake_VERSION_MAJOR 3)
set(CMake_VERSION_MINOR 15)
set(CMake_VERSION_PATCH 20190605)
#set(CMake_VERSION_RC 1)

repository: malaterre/CMake

repo_name: malaterre/CMake

extension: cmake


text:
@InCollection{sep-logic-epistemic,
	author       =	{Hendricks, Vincent and Symons, John},
	title        =	{Epistemic Logic},
	booktitle    =	{The Stanford Encyclopedia of Philosophy},
	editor       =	{Edward N. Zalta},
	howpublished =	{\url{https://plato.stanford.edu/archives/fall2015/entries/logic-epistemic/}},
	year         =	{2015},
	edition      =	{Fall 2015},
	publisher    =	{Metaphysics Research Lab, Stanford University}
}


text:
DESCRIPTION = "Subsurface is an open source dive log program."
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://gpl-2.0.txt;md5=b234ee4d69f5fce4486a80fdaf4a4263"

DEPENDS = "libdivecomputer gtk+ libxml2 glib-2.0 gconf"

inherit gtk-icon-cache

inherit gitpkgv
PKGV = "${GITPKGVTAG}"
PV = "1.1"

SRCREV = "bd275d73ac06823619230915a3aa29deddc996fb"
SRC_URI = "git://subsurface.hohndel.org/subsurface.git"
S = "${WORKDIR}/git"

EXTRA_OEMAKE = "CC='${CC}' \
                libdc-usr=${STAGING_INCDIR}/libdivecomputer/* \
                LIBDIVECOMPUTERINCLUDES=${STAGING_INCDIR}/libdivecomputer \
                LIBDIVECOMPUTERARCHIVE=${STAGING_LIBDIR}/libdivecomputer.a \
"

do_install() {
    oe_runmake install DESTDIR=${D}
    rm ${D}${datadir}/icons/hicolor/icon-theme.cache
}

FILES_${PN} += "${datadir}/icons/hicolor/scalable/apps/subsurface.svg"
RRECOMMENDS_${PN}_append_libc-glibc = " eglibc-gconv-iso8859-15"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace

gha_language: Python


text:
// Copyright (c) 2018 IoTeX
// This is an alpha (internal) release and is not suitable for production. This source code is provided 'as is' and no
// warranties are given as to title or non-infringement, merchantability or fitness for purpose and, to the extent
// permitted by law, all liability for your use of the code is disclaimed. This source code is governed by Apache
// License 2.0 that can be found in the LICENSE file.

package action

import "github.com/pkg/errors"

const (
	// VersionSizeInBytes defines the size of version in byte units
	VersionSizeInBytes = 4
	// NonceSizeInBytes defines the size of nonce in byte units
	NonceSizeInBytes = 8
	// TimestampSizeInBytes defines the size of 8-byte timestamp
	TimestampSizeInBytes = 8
	// BooleanSizeInBytes defines the size of booleans
	BooleanSizeInBytes = 1
	// GasSizeInBytes defines the size of gas in byte uints
	GasSizeInBytes = 8
	// GasLimit is the total gas limit to be consumed in a block
	GasLimit = uint64(1000000000)
)

var (
	// ErrHitGasLimit is the error when hit gas limit
	ErrHitGasLimit = errors.New("Hit Gas Limit")
	// ErrInsufficientBalanceForGas is the error that the balance in executor account is lower than gas
	ErrInsufficientBalanceForGas = errors.New("Insufficient balance for gas")
	// ErrOutOfGas is the error when running out of gas
	ErrOutOfGas = errors.New("Out of gas")
)

repository: shisoft/iotex-core

repo_name: shisoft/iotex-core


text:
/*
* Fibonacci
*
* Author: Catarina Silva
* Email: c.alexandracorreia@av.it.pt
* Email: c.alexandracorreia@ua.pt
*
* Version: 1.0
*/

package main

import "fmt"

func main(){
	var p, c, r int = 1,2,2

	for c < 4000000{
		t := c
		c = c + p
		p = t
		if c%2 == 0{
			r += c
		}
	}
	fmt.Printf("Result: %d\n", r)
}

repository: catarinaacsilva/go-challenges

repo_name: catarinaacsilva/go-challenges


text:
DESCRIPTION = "sinit is a suckless init, initially based on Rich Felker’s minimal init."
HOMEPAGE = "https://core.suckless.org/sinit"
SECTION = "base/shell"
LICENSE = "MIT-X"
LIC_FILES_CHKSUM = "file://LICENSE;md5=1d1472b4fe357433ed8567058835451e"

SRCREV = "28c44b6b94a870f2942c37f9cfbae8b770595712"

SRC_URI = "\
	git://git.suckless.org/sinit \
	file://0001-config.mk-remove-cross-compile-incompatible-variable.patch \
	file://rc.init \
	file://rc.shutdown \
	file://poweroff \
	file://reboot \
	file://syscall-reboot.c \
	file://expand-last-part \
"

S = "${WORKDIR}/git"

do_compile() {
	oe_runmake
	cd ${WORKDIR} && ${CC} ${CFLAGS} ${LDFLAGS} syscall-reboot.c -o syscall-reboot
}

do_install() {
	oe_runmake install DESTDIR="${D}" PREFIX="${prefix}" MANPREFIX="${mandir}"

	install -m 755 ${WORKDIR}/rc.init		${D}${bindir}
	install -m 755 ${WORKDIR}/rc.shutdown		${D}${bindir}
	install -m 755 ${WORKDIR}/reboot		${D}${bindir}
	install -m 755 ${WORKDIR}/poweroff		${D}${bindir}
	install -m 755 ${WORKDIR}/syscall-reboot	${D}${bindir}
	install -m 755 ${WORKDIR}/expand-last-part	${D}${bindir}

	cd ${D}/${bindir}
	ln -s sinit init
}


text:
SUMMARY = "Pure-Python Java Keystore (JKS) library"
DESCRIPTION = "PyJKS enables Python projects to load and manipulate\
 Java KeyStore (JKS) data without a JVM dependency. PyJKS supports JKS,\
 JCEKS, BKS and UBER (BouncyCastle) keystores."
HOMEPAGE = "http://github.com/kurtbrose/pyjks"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=9694d6cc724caf7f7386be88a4a81958"

SRC_URI[md5sum] = "1a6bce95484f1f62f8ff59755972c632"
SRC_URI[sha256sum] = "0378cec15fb11b2ed27ba54dad9fd987d48e6f62f49fcff138f5f7a8b312b044"

inherit pypi setuptools3

RDEPENDS_${PN} = "\
    ${PYTHON_PN}-javaobj-py3 \
    ${PYTHON_PN}-pyasn1 \
    ${PYTHON_PN}-pyasn1-modules \
    ${PYTHON_PN}-pycryptodome \
    ${PYTHON_PN}-twofish\
"

BBCLASSEXTEND = "native nativesdk"

repository: ni/meta-openembedded

repo_name: ni/meta-openembedded

branch_name: refs/heads/nilrt/master/hardknott


text:
#ifndef COST_MAP
#define COST_MAP

#include "edge.h"
#include "minheap.h"
#include <map>

// This header file is to create an weight/cost matrix for all the vertices assuming a complete graph.
namespace costmap{
	class Matrix{
		std::map<vertex::Vertex*, std::map<vertex::Vertex*, edge::Edge*>> costMap;
	public:
		Matrix(heap::MinHeap*);		//Constructor
		edge::Edge* getEdge(vertex::Vertex* a, vertex::Vertex* b) {return costMap[a][b];};
		std::map<vertex::Vertex*, edge::Edge*>* getAdj(vertex::Vertex* a) {return &costMap[a];};
		void printCostMap();
	};
}
#endif

repository: RachithP/planning-in-robotics

repo_name: RachithP/planning-in-robotics


text:
package jira

import (
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
)

type Auth struct {
	SiteUrl string `json:"site_url"`
	Email   string `json:"email"`
	Token   string `json:"token"`
}

func readFile() *Auth {
	configFile, err := os.Stat("config.json")
	if err != nil {
		fmt.Println(err)
	}
	if configFile.Size() > 0 {
		content, err := ioutil.ReadFile("config.json")
		if err != nil {
			fmt.Println(err)
		}
		c := string(content)
		var config Auth
		err = json.Unmarshal([]byte(c), &config)
		if err != nil {
			fmt.Println(err)
		}
		return &config
	}
	return nil
}

func basicAuth(username, password string) string {
	auth := username + ":" + password
	return base64.StdEncoding.EncodeToString([]byte(auth))
}

func Request(httpMethod string, resource string, body io.Reader) string {
	auth := readFile()
	if auth == nil {
		return errors.New("can not parse config.json").Error()
	}
	client := http.Client{}
	req, err := http.NewRequest(httpMethod, auth.SiteUrl+resource, body)
	req.Header.Add("X-Atlassian-Token", "no-check")
	req.Header.Add("Authorization", "Basic "+basicAuth(auth.Email, auth.Token))
	if err != nil {
		return err.Error()
	}
	res, err := client.Do(req)
	if err != nil {
		return err.Error()
	}
	defer res.Body.Close()
	b, _ := ioutil.ReadAll(res.Body)
	return string(b)
}


text:
#===============================================================================
# Copyright 2016-2023 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#===============================================================================

# Locates Doxygen and configures documentation generation
#===============================================================================

if(Doxygen_cmake_included)
    return()
endif()
set(Doxygen_cmake_included true)

if(NOT DNNL_IS_MAIN_PROJECT)
    return()
endif()

find_package(Doxygen)
if(DOXYGEN_FOUND)
    set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/reference)
    set(DOXYGEN_STAMP_FILE ${CMAKE_CURRENT_BINARY_DIR}/doxygen.stamp)
    configure_file(
        ${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in
        ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
        @ONLY)
    file(GLOB_RECURSE HEADERS
        ${PROJECT_SOURCE_DIR}/include/oneapi/dnnl/*.h
        ${PROJECT_SOURCE_DIR}/include/oneapi/dnnl/*.hpp
        )
    file(GLOB_RECURSE DOX
        ${PROJECT_SOURCE_DIR}/doc/*
        )
    file(GLOB_RECURSE EXAMPLES
        ${PROJECT_SOURCE_DIR}/examples/*
        )
    add_custom_command(
        OUTPUT ${DOXYGEN_STAMP_FILE}
        DEPENDS ${HEADERS} ${DOX} ${EXAMPLES}
        COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
        COMMAND ${CMAKE_COMMAND} -E touch ${DOXYGEN_STAMP_FILE}
        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
        COMMENT "Generating API documentation in .xml format with Doxygen" VERBATIM)
    add_custom_target(doc_doxygen DEPENDS ${DOXYGEN_STAMP_FILE})

    if(NOT DNNL_INSTALL_MODE MATCHES "BUNDLE|BUNDLE_V2")
        install(
            DIRECTORY ${DOXYGEN_OUTPUT_DIR}
            DESTINATION share/doc/${LIB_PACKAGE_NAME} OPTIONAL)
    endif()
endif(DOXYGEN_FOUND)

repository: oneapi-src/oneDNN

repo_name: oneapi-src/oneDNN


text:
package framework

// Middleware interface
type Middleware interface {
	Run(context Context) bool
}

// MiddlewareFunc adapter for funcs to middleware
type MiddlewareFunc func(context Context) bool

// Run middleware func
func (f MiddlewareFunc) Run(context Context) bool {
	return f(context)
}

type RouteAdapter func(f RouteHandler) RouteHandler

func AdaptRoute(h RouteHandler, adapters ...RouteAdapter) RouteHandler {
	for _, adapter := range adapters {
		h = adapter(h)
	}
	return h
}

repository: bashmohandes/go-askme

repo_name: bashmohandes/go-askme

gha_language: Go


text:
package work

import (
	"fmt"
	log "github.com/cihub/seelog"
	"github.com/dchest/uniuri"
	"github.com/spaolacci/murmur3"
	"github.com/streadway/amqp"
	"hash"
	"time"
)

func StartReceiver(c *client, signal chan error, opts *Options) {

	ch, err := c.openChannel()
	if err != nil {
		signal <- err
		return
	}

	if !opts.NoDeclare {
		q, err := declareQueue(ch, opts.Queue)

		if err != nil {
			signal <- err
			return
		}

		if opts.Queue == "" {
			opts.Queue = q.Name
		}
	}

	if err := ch.Qos(opts.Prefetch, 0, opts.GlobalPrefetch); err != nil {
		signal <- err
		return
	}

	tag := uniuri.NewLen(4)
	deliveries, err := subscribe(ch, opts, tag)
	if err != nil {
		signal <- err
		return
	}

	log.Infof("receiver (%s) subscribed to queue %s (prefetch=%d; global=%v; priority=%d) ", tag, opts.Queue, opts.Prefetch, opts.GlobalPrefetch, opts.Priority)

	cancelSubscription := make(chan bool)
	go handle(deliveries, opts, tag, c.signal, cancelSubscription)

	cancel := make(chan string, 1)
	ch.NotifyCancel(cancel)

	select {
	case tag := <-cancel:
		_ = tag
		cancelSubscription <- true
		if opts.Renew {
			log.Info("automatically renewing subscription")
			c, err := NewClient(opts, c.flake)
			if err != nil {
				signal <- err
				return
			}
			StartReceiver(c, signal, opts)
		}
	}

	signal <- nil
}

func handle(deliveries <-chan amqp.Delivery, opts *Options, tag string, signal chan error, cancelSubscription chan bool) {

	// TODO This could consume a lot of memory if not LRU'ed
	entropy := make(map[string]hash.Hash)

	for {
		select {
		case <-cancelSubscription:
			log.Infof("subscription cancelled by server")
			return
		default:
			for d := range deliveries {

				now := time.Now().UnixNano()

				if opts.Interval > 0 {
					time.Sleep(time.Duration(opts.Interval) * time.Millisecond)
				}

				if err := d.Ack(false); err != nil {
					signal <- err
				}

				h := murmur3.New32()
				h.Write(d.Body)
				sum := h.Sum(nil)

				e, ok := entropy[d.CorrelationId]
				if !ok {
					e = murmur3.New32()
				}

				e.Write(sum)
				ent := e.Sum(nil)
				entropy[d.CorrelationId] = e

				size := float32(len(d.Body)) / 1024

				var latency float64
				ts, hasLatency := d.Headers[timestampHeader]
				if hasLatency {
					then, ok := ts.(int64)
					if !ok {
						signal <- fmt.Errorf("Invalid nanos timestamp header: %+v", ts)
					}

					latency = float64((now - then)) / (1000 * 1000)
					if latency < 0 {
						log.Warnf("[%s] %s negative latency: %f (ms); sent at %d (nanos), received at %d (nanos)", tag, d.MessageId, latency, then, now)
					}
				}

				if opts.Entropy {
					label := shortLabel(d.CorrelationId)
					if hasLatency {
						log.Infof("[%s] %s receiving %.2f kB (%x) @ %.2f ms [%s, %x]", tag, d.MessageId, size, sum, latency, label, ent)
					} else {
						log.Infof("[%s] %s receiving %.2f kB (%x) [%s, %x]", tag, d.MessageId, size, sum, label, ent)
					}

				} else {
					if hasLatency {
						log.Infof("[%s] %s receiving %.2f kB (%x) @ %.2f ms", tag, d.MessageId, size, sum, latency)
					} else {
						log.Infof("[%s] %s receiving %.2f kB (%x)", tag, d.MessageId, size, sum)
					}

				}
			}
		}
	}

	log.Info("receiver exiting")
	signal <- nil
}

func subscribe(ch *amqp.Channel, o *Options, tag string) (<-chan amqp.Delivery, error) {
	autoAck := false
	exclusive := false
	noLocal := false
	noWait := false
	var args amqp.Table

	if o.Priority > 0 {
		args = amqp.Table{}
		args["x-priority"] = o.Priority
	}

	return ch.Consume(o.Queue, tag, autoAck, exclusive, noLocal, noWait, args)
}

func declareQueue(ch *amqp.Channel, name string) (amqp.Queue, error) {
	durable := false
	autoDelete := true
	exclusive := false
	noWait := false
	var args amqp.Table

	return ch.QueueDeclare(name, durable, autoDelete, exclusive, noWait, args)
}

repository: gitmustashio/rmq

repo_name: gitmustashio/rmq


text:
# Put your BibTeX entries in this file.

@misc{vampir.eu,
  title = "Vampir",
  author = "GWT-TUD GmbH",
  howpublished = "\url{https://vampir.eu}",
  year = 2020,
  note = "Accessed: 2020-10-15"
}

repository: vetter/ECP-ST-CAR-PUBLIC

repo_name: vetter/ECP-ST-CAR-PUBLIC

gha_language: TeX


text:
package crew

import (
	"sync"
)

type Crew struct {
	sync.RWMutex

	Id       string              `json:"id"`
	Machines map[string]*Machine `json:"machines"`
}

// Copy gets a read lock and returns a copy of the crew.
func (c *Crew) Copy() *Crew {
	c.RLock()
	ms := make(map[string]*Machine, len(c.Machines))
	for id, m := range c.Machines {
		ms[id] = m.Copy()
	}
	acc := &Crew{
		Id:       c.Id,
		Machines: ms,
	}
	c.RUnlock()
	return acc
}


text:
@article{lonergan09,
  title={The effects of interpolation error and location quality on animal track reconstruction},
  author={Lonergan, Mike and Fedak, Mike and McConnell, Bernie},
  journal={Marine Mammal Science},
  volume={25},
  number={2},
  pages={275--282},
  year={2009}
}
@article{kalmanJBE60,
  title={A new approach to linear filtering and prediction problems},
  author={Kalman, Rudolph Emil and others},
  journal={Journal of basic engineering},
  volume={82},
  number={1},
  pages={35--45},
  year={1960}
}
@article{kobayashiITIE98,
  title={Accurate differential global positioning system via fuzzy logic kalman filter sensor fusion technique},
  author={Kobayashi, Kazuyuki and Cheok, Ka C and Watanabe, Kajiro and Munekata, Fumio},
  journal={IEEE Transactions on Industrial Electronics},
  volume={45},
  number={3},
  pages={510--518},
  year={1998}
}
@inproceedings{brakatsoulasVLDB05,
  title={On map-matching vehicle tracking data},
  author={Brakatsoulas, Sotiris and Pfoser, Dieter and Salas, Randall and Wenk, Carola},
  booktitle={Very Large Data bases ({VLDB})},
  pages={853--864},
  year={2005}
}
@article{liJG15,
  title={Accuracy and reliability of multi-GNSS real-time precise positioning: GPS, GLONASS, BeiDou, and Galileo},
  author={Li, Xingxing and Ge, Maorong and Dai, Xiaolei and Ren, Xiaodong and Fritsche, Mathias and Wickert, Jens and Schuh, Harald},
  journal={Journal of Geodesy},
  volume={89},
  number={6},
  pages={607--635},
  year={2015}
}

repository: taylorlloyd/ETSLivePredict

repo_name: taylorlloyd/ETSLivePredict