Weak authentication practices that rely on passwords for security have led to widespread data breaches and successful phishing attacks. Recent advances in the cost and usability of hardware security tokens have made the prospect of effectively augmenting password-based authentication or removing it altogether a possibility. To actualize this, a paradigm change in how people learn to authenticate accounts on-line must occur. Towards this end, we describe a curriculum to teach high-school students the perils of passwords and a program to distribute hardware security tokens to them as they are first setting up their on-line presence in order to improve the security of the next generation.

CyberPDX is an annual professional development program hosted at Portland State University. Our long-term goal is to broaden participation in cybersecurity. Since 2016, over 70 middle and high school teachers from the Pacific Northwest have participated in the STREAM program, which offers interdisciplinary instruction in programming, cryptography, personal security, policy, literature, and arts. In this poster, we share our interdisciplinary curriculum, present data on short-term impacts, and describe our in-progress work to evaluate the program's longer term impacts.

Domain-specific web applications often need to integrate information from schematically heterogeneous sources that share some semantic similarities. These applications often include application widgets—where each widget may address a (potentially small) subset of the local schema. We seek to provide flexible integration where each widget may use its own “global” schema and use its own mapping to each local schema. It is possible for each such “global” schema to be mapped multiple times, in different ways, to a given local schema. Traditional information integration is too rigid to meet these requirements. Here, we define a new integration model that introduces a metamodel of small domain-specific schema fragments—called domain structures—that can be mapped to local schemas. We show how generic, polymorphic widgets can be created by writing queries against domain structures using an extended relational algebra that includes a local type operator to propagate local type names to the domain structures. By bringing the local semantics to the global level we create an integration system with local dominance where important, distinct local schema semantics are available globally.

The Ensemble computing portal originated under the NSF NSDL program and enjoys the respect and continued interest of the computing education community. The project has reached a maturity level at which it is time to focus on the long-term viability of the activity. The original proposal included a commitment from the Villanova University library to adopt the system and keep in running in perpetuity. However, merely keeping the system running will not preserve nor extend the true promise of the project. That requires an active, engaged community. The leaders of the Ensemble project invite our partner projects and the SIGCSE community to join us in an initial meeting of an organization devoted to the continued development and support of the Ensemble vision: that of a community of educators sharing their best efforts, showcasing the best resources, and archiving materials that deserve long term preservation.

With the proliferation of digital educational resources comes the requirement to provide educators with tools for collaboration, customization, and reuse of these resources. We describe our repository software built upon the Drupal content management system that allows educators to form curriculum-based online communities to create, share, and adapt educational resources and curricula. Teachers can create curricula from scratch, add to existing curricula, or clone and customize curricula to fit their teaching environment. We also show how our system can help educators see the usage contexts of their materials. The software is demonstrated in the STEMRobotics middle and high school robotics curricula repository and the MSScience middle school standards-based curriculum collaboration site.

Search engines are mostly targeted toward the generic user but educators have specific information needs with specialized information-seeking behaviors. When designing a course, educators may create a syllabus, lecture slides, and use tools as lecture aides. These resources are scattered across a large number of websites and require time and effort in finding them. To design a useful system for educators we must understand the problems they face when they seek, use, and re-use online resources. With that in mind, the Ensemble team conducted focus groups to identify current practices and problems in locating online resources for educational purposes. The data provides better understanding of the information-seeking process of educators that can lead to better educational resource sites.

Applications typically have some local understanding of a database schema, a virtual database that may differ significantly from the actual schema of the data where it is stored. Application engineers often support a virtual database using custom-built middleware because the available solutions, including updatable views, are unable to express necessary capabilities. We propose an alternative means of mapping a virtual database to a physical database that guarantees they remain synchronized under data or schema updates against the virtual schema. One constructs a mapping by composing channel transformations (CTs) that encapsulate atomic transformations --- including complex transformations such as pivoting --- with known updatability properties. Applications, query interfaces, and any other services can behave as if the virtual database is the implemented schema. We describe how CTs translate queries, DML, and DDL, and the properties that are necessary for such translation to be correct. We describe two example CTs in detail, and evaluate an implementation of channels for completeness and performance.

We seek to leverage knowledge about information organization in a domain to effectively and efficiently meet targeted information needs of expert users. The semantic components model represents document content in a manner that is complementary to full text and keyword indexing. Semantic component instances are segments of text about a particular aspect of the main topic of the document and may not correspond to structural elements in the document. This paper describes the semantic components model and presents experimental evidence from a large interactive searching study showing that semantic components, used to supplement full text and keyword indexing and to extend the query language, enhanced the retrieval of domain-specific documents in response to realistic queries posed by real users.

Web applications called mash-ups combine information of varying granularity from different, possibly disparate, sources. We describe Mash-o-matic, a utility that can extract, clean, and combine disparate information fragments, and automatically generate data for mash-ups and the mash-ups themselves. As an illustration, we generate a mash-up that displays a map of a university campus, and outline the potential benefits of using Mash-o-matic. Mash-o-matic exploits superimposed information (SI), which is new information and structure created in reference to fragments of existing information. Mashomatic is implemented using middleware called the Superimposed Pluggable Architecture for Contexts and Excerpts (SPARCE), and a query processor for SI and referenced information, both parts of our infrastructure to support SI management. We present a high-level description of the mash-up production process and discuss in detail how Mash-o-matic accelerates that process.

People often impose new interpretations onto existing information. In the process, they work with information in two layers: a base layer, where the original information resides, and a superimposed layer, where only the new interpretations reside. Abstractions defined in the Superimposed Pluggable Architecture for Contexts and Excerpts (SPARCE) ease communication between the two layers. SPARCE provides three key abstractions for superimposed information management: mark, context, and excerpt. We demonstrate two applications, RIDPad and Schematics Browser, for use in the appeal process of the US Forest Service (USFS).

In our research on superimposed information management, we have developed applications where information elements in the superimposed layer serve to annotate, comment, restructure, and combine selections from one or more existing documents in the base layer. Base documents tend to be unstructured or semi-structured (HTML pages, Excel spreadsheets, and so on) with marks delimiting selections. Selections in the base layer can be programmatically accessed via marks to retrieve content and context. The applications we have built to date allow creation of new marks and new superimposed elements (that use marks), but they have been browse-oriented and tend to expose the line between superimposed and base layers. Here, we present a new access capability, called bilevel queries, that allows an application or user to query over both layers as a whole. Bi-level queries provide an alternative style of data integration where only relevant portions of a base document are mediated (not the whole document) and the superimposed layer can add information not present in the base layer. We discuss our framework for superimposed information management, an initial implementation of a bi-level query system with an XML Query interface, and suggest mechanisms to improve scalability and performance.

Abstract Digital libraries allow information access to be integrated into work processes rather than separated from them, but also have the potential to overwhelm users with excessive or irrelevant information, impairing their performance rather than improving it. With the opportunity to create new models of what a library is and how it can be used comes the challenge of improving our understanding of its patrons, their work, and the circumstances under which they perform it. In this article we offer an overview of our experiences using observational methods to learn about one class of users, expert clinicians treating patients in hospital settings. We describe the evolution of our understanding of the users and their informational tasks, and how this evolving understanding is guiding our efforts to create digital library technology. The multidisciplinary composition of our team has enriched our observations and improved the validity of our analysis and interpretations. The multiple observation methods we have employed, including “think‐aloud” scenarios in the laboratory, participant observation in the field, key informant interviews, and focus group sessions, have enabled us to enrich the data set, gain greater insight, and verify findings with informants. The relatively tight cycle of observation, analysis, development, and repeat observation has enabled us to iteratively and more rapidly refine our “user model” and “task model,” improving, we hope, the usefulness of the technologies we are developing.

What do you do to make sense of a mass of information on a given topic? Paradoxically, you likely add yet more information to the pile: annotations, underlining, bookmarks, cross-references, etc. We want to build digital information systems for managing such added or superimposed information and support applications that create and manipulate it. We find that requirements for a superimposed information system can be quite different from those for a traditional database management system: a lightweight implementation, multi-model information structures, "schema-later" data entry, interacting with data that is "outside the box" (controlled by other applications), and support, rather than removal, of redundancy. We report on SLIMPad (Superimposed Layer Information Manager scratchPad), a superimposed application which was inspired by the "bundling" of information elements from disparate sources we observed in a medical setting. We propose an architecture for superimposed applications and information management. Our prototype components to implement the architecture give flexibility in structuring superimposed information, and also encapsulate addressing, at a sub-document granularity, into a variety of base information sources.

In the trade-offs between security and performance, it seems that security is always the loser. If we allow for adaptive security, we can at least ensure that security and performance are treated somewhat equally. Using adaptive security, we can allow a system to exist in a less secure, more performant state until it comes under attack. We then adapt the system to a more secure, less performant implementation. In this paper, we introduce the Security Adaptation Manager, or SAM. We describe SAM and how we have implemented SAM to take advantage of the different protection strengths offered by the StackGuard compiler. Using SAM to provide StackGuard-based adaptive security provides a form of misuse-based intrusion detection, capable of detecting known and novel attacks.

Electronic Design Automation (EDA) tools, such as layout generators and simulators, have generally focused on algorithms and techniques for hardware design. Data management aspects have not been emphasized, but the volume of data, heterogeneity of data formats, and the evolution/proliferation of tools have made data modeling and data interchange increasingly important research issues. The data sharing problem stems from the fact that related EDA tools are often used in various sequences to manipulate and annotate a single design. In a typical design environment, tools use file-based data storage, with limited data modeling capabilities, and primitive or non-existent query facilities. In order to support current tools, we wish to preserve the semantics of existing hardware description languages in rigorous data models; we propose to capture each existing language in a semantic space model. We view data interchange as a query against one semantic space that produces objects, i.e., query answers, in another semantic space. We define an integrating meta-model, the meta-space, and also define general query operators for transforming objects between semantic spaces. These query operators define both the intension and extension of a query result; the transformed data is described in the type system of the meta-space, thus providing explicit semantics for the shared data. Our modeling approach supports advanced and evolving applications, such as hardware/software codesign, through the ability to retrieve data resident in individual semantic spaces, as well as to share data in semantic spaces from different EDA sources.

A shrink-wrap schema is a well-crafted, complete, global schema that represents an application. A concept schema is a subset of the shrink-wrap schema that addresses one particular point of view in an application. We define schema modification operations to customize each concept schema, to match the designer's perception of the application. We maintain the integrated, customized user schema. We enforce consistency checks to provide feedback to the designer about interactions among the concept schemas. We embody these mechanisms in an interactive system that aids in shrink-wrap schema-based design. The shrink-wrap schema approach promotes reuse of past design efforts; prior approaches to schema reuse did not attempt to reuse an entire schema nor did they focus on local customization. The focus of this paper is on the definition of concept schemas and their corresponding modification operations.

Evolution of software systems is prompted by all sorts of changes. This paper demonstrates how the use case, a well known construct in object-oriented analysis, is adapted to form the change case, to identify and articulate anticipated system changes. A change case provides the ability to identify and incorporate expected future change into a design to enhance the long-term robustness of that design. In this paper, we define change cases and demonstrate how change cases are captured by the analyst. We present examples to illustrate how change cases can influence present system design and point the way toward designs that more easily accommodate expected future changes. Change cases can be effectively employed in the context of any methodology that supports use cases and traceability links.

Vertical information management (VIM) is a term coined to describe a particular set of information management activities. These activities support decision makers working within various levels of a management hierarchy, who seek information from potentially large, distributed heterogeneous, and federated information sources. Decision makers usually require information beyond what is stored. Yet, the collected data is a valuable resource. This as particularly important for scientific experimental results where the samples are expensive to collect and analyze, as in environmental remediation and restoration. One sample from a storage tank containing nuclear waste can cost over $1000000. A fundamental assumption of the work is that high-level information requests may involve data that is extracted or derived from underlying information sources, as well as data that is not present in the underlying information sources (referred to as "gaps"). The authors observe that current practice often involves manual processing and negotiation to select relevant information and to fill gaps. They present a VIM framework for the specification, refinement, and partitioning of a high-level information request resulting in the extraction, collection, aggregation, and abstraction of the underlying data. This framework captures the specification of the information and the summarization steps used in a highly manual process to leverage the investment against future information requests. The work has been supported, in part, by the Department of Energy's Pacific Northwest National Laboratory.

A detailed analytical and simulation model that accurately captures the effect of communication delay for local area networks is presented. To demonstrate the framework, load sharing algorithms are presented and evaluated both with and without the effect of the communication network delay. The algorithms use the Ethernet communication protocol to their advantage and provide superior performance compared to several published algorithms. The strong performance results for the new algorithms demonstrate that a load sharing algorithm can cooperate rather than compete with a communication network.>

The notion of object-centered (O-C) constraints, a subset of range-restricted Horn clauses with existential variables is presented. O-C constraints correspond, intuitively, to sets of clauses that involve connected objects or objects that can be located through navigation. Other types of constraints, e.g. transition or other temporal constraints are not specifically addressed. The research philosophy adopted is that such constraints can be expressed by introducing additional constructs into the schema, e.g. old-Student or new-Student and then expressing constraints in the same manner as the O-C constraints. This approach is conceptually accurate; it provides a uniform method for expressing and enforcing constraints using generalized constraint analysis. It allows the user to precisely describe the intended semantics, e.g. when to delete the old values after an update. This philosophy basically states that database constraints necessarily constrain database objects; in order to address additional issues like old/new values, the additional structures should be brought into the purview of the database by defining them in the database schema.>

A design process for an object-oriented database design environment, known as constraint analysis, is presented. Given the increased level of semantics associated with an object-oriented database schema, constraint analysis makes use of semantics expressed as database constraints to support the flexible specification of propagation actions for operations on objects. Constraints are formally represented using Horn logic. The constraint analysis process then reasons about constraints at design time to help the designer understand the effects of constraints on object manipulation, identifying possible constraint violations as well as design alternatives for handling violations. An advantage of constraint analysis is that both inherent and explicit schema constraints are included in the analysis process. A formal representation is given that supports the analysis of constraints and the automatic identification of design alternatives for responding to constraint violations.>

The philosophy of explicitly representing simple range classes for properties and explicitly specifying range and/or cardinality restrictions on inherited properties is adopted so that the membership of an object in classes is characterized by the object's property values. The motivation for this approach is twofold: first, it is in keeping with the database philosophy of emphasizing the representation of an application (rather than some intrinsic meaning); and second, it provides a framework for algorithmically verifying the structural aspects of the schema. An automatic classifier for the structural validation of object-oriented schemas based on sound and complete rules of inference is presented. If the classifier discovers structural relationships and/or inconsistencies, the designer can refine the schema to reflect the semantics of the application. Thus the classifier serves as an interactive design tool that can be used at any stage during the design process.>

An approach known as constraint analysis is presented for specifying updatable perspectives of class objects in an object-oriented data schema. Perspectives provide a way of defining the scope of a user's view of a schema. Operations on class objects are then defined in terms of specific perspectives based on the semantics associated with the schema. Schema semantics are represented as a set of integrity constraints expressed in Horn logic. The constraint analysis process then reasons about schema constraints to support a flexible approach to update propagation. The advantage of constraint analysis is that both inherent and explicit constraints can be used to support the automated specification of updatable perspectives that preserve object integrity. >

The Relational Production Language (RPL) solves the paradigm mismatch between expert systems and database systems by relying on the relational data model as the underlying formalism for an expert system. The result is a formally-defined production system language with immediate access to conventional databases. Working memory is modeled as a relational database and rules consist of a relational query on the left hand side (LHS) and database updates on the right hand side (RHS). This paper reports on the design of the RPL 1 0 prototype. The prototype directly executes RPL programs and capitalizes on the inherent advantages of the relational approach, particularly for intra-rule and inter-rule parallelism. By using a self-describing approach for representing the interpreter data structures, the interpreter is a self-controlling system that allows conflict resolution, error handling and a wide spectrum of software metrics to be explicitly specified using RPL meta-rules.

This paper presents the notion of forming user perspectives over a semantic schema. Perspectives are a mechanism for providing user-oriented views of abstract objects. The perspectives of interest to each user group are collected into user views to provide a modularization tool for semantic schemas. A novel aspect of the approach to forming perspectives is that the semantics expressed within a schema are actively used to present design alternatives in the formation of perspectives and in the manner in which exception violations are handled. As a result, perspectives and their associated update operations are developed in a manner that conforms to the integrity constraints of the underlying semantic schema.

Semantic data models have been influenced by abstraction techniques used in knowledge representation. Early semantic models concentrated on the structural aspects of an application. More recently, researchers in semantic modeling have realized the importance of capturing the dynamic and temporal aspects of an application as well. This paper presents a detailed and uniform analysis of the structural, dynamic, and temporal aspects of object-oriented semantic models that support classification, aggregation, generalization, and association abstractions.

An examination of high-level language architectures reveals that some design considerations are based on inaccurate premises. This paper discusses some HLL architecture design misconceptions. Some features that should be considered in the design of HLL architectures are presented. Based on the HLL architecture design considerations, a methodology for quantifying architecture is proposed.