NOTE: The first page of text has been automatically extracted and included below in lieu of an abstract EVALUATION OF FACTORS AFFECTING THE SUCCESS OF IMPROVING MATH COURSE PLACEMENT FOR INCOMING FRESHMEN IN A SUMMER BRIDGE PROGRAM Abstract A summer bridge program for incoming engineering and computer science freshmen has been used at the University of Wisconsin-Milwaukee from 2007-09. The primary purpose of this program has been to improve the mathematics course placement for incoming students who initially place into a course below Calculus I on our math placement examination. The students retake the math place examination after completing the bridge program to determine if they then place into a higher-level mathematics course. If the students improve their math placement, the program is considered successful for that student. The math portion of the bridge program centers on using the ALEKS software package for targeted, self-guided learning. In the 2007 and 2008 versions of the program, both an on-line version and an on-campus version with additional instruction were offered. In 2009, the program was exclusively in an on-campus format, and also featured a required residential component and additional engineering activities for the students. From the results of these three programs, we are able to evaluate the success of the program in its different formats, and are able to judge the utility of the enhancements that have been added to the program. In addition, data has been collected and analyzed regarding the impact of other factors on the program’s success. The factors include student preparation before the beginning of the program (as measured by math ACT scores) and the amount of time the student spent working on the material during the program. Not surprisingly, better math preparation and the amount of time spent on the program are good indicators of success. Furthermore, the on campus version of the program is more effective than the on-line version. Introduction In the United States today, there is great interest in the education and graduation of more students in the Science, Technology, Engineering, and Mathematics (STEM) disciplines.1,2 There are two primary tasks that are needed for this goal to be accomplished. First, more students need to be attracted to pursue college-level studies in the STEM fields. Second, once those students are attracted to a STEM field, the colleges and universities must provide an attractive, nurturing environment designed to allow a wide range of students to succeed, while still providing a rigorous education. The College of Engineering and Applied Science (CEAS) at the University of Wisconsin- Milwaukee (UWM) has generally been able to attract as many students into its engineering and computer science programs as for whom it can provide quality educations. But the graduation rates have been lower than desired. While the number fluctuates a bit each year, based on incoming classes from 2003-2005, the graduation rate of incoming freshmen in CEAS is about 35%. Recognizing that this is an undesirably low graduation rate in that it does not advance

The Extensible Markup Language (XML) is widely used to store, retrieve, and share digital documents. Recently, a form of Version Control System has been applied to the language, resulting in Version-Aware XML and allowing for enhanced portability and scalability. While Version Control Systems are able to keep track of changes made to documents, we think that there is untapped potential in the technology. In this paper, we define a set of requirements for visualization tools in a modern version control system. We also present an interactive and scalable visualization framework to represent Version-Aware-related data that helps users visualize and understand version control data, delete specific revisions of a document, and access a comprehensive overview of the entire versioning history. We evaluated our interface prototype by conducting semi-structured usability tests and questionnaires to obtain both qualitative and quantitative feedback from volunteers with a general technological background.

In this paper, we describe an enhancement of the Automated Policy Enforcement eXchange framework (APEX) called eAPEX. eAPEX uses version-control information as the basis for a more incremental approach to scanning document text to determine if security policies are being followed. Where APEX requires a full or deep scan of the document each time an exposure operation is invoked, eAPEX usually requires only a scan of changed elements (deltas). A new scanning approach was designed and implemented. eAPEX works by combining version-aware document technology with a policy database that functions as a cache of security policy results. eAPEX is evaluated by testing an application that was created to simulate the behavior of the proposed scannning approaches. This evaluation suggests that an incremental approach to checking document security should yield noticeable performance benefits.

XML has become the standard document representation for many popular tools in various domains. When multiple authors collaborate to produce a document, they must be able to work in parallel and periodically merge their efforts into a single work. While there exist a small number of three-way XML merging tools, their performance could be improved in several areas. We present a three-way XML merge algorithm that is faster, uses less memory and is more precise than previous algorithms. It uses a specialized versioning tree data structure that supports node identity and change detection. The algorithm applies the traditional three-way merge found in GNU diff3 to the children of changed nodes. The editing operations it supports are addition, deletion, update, and move. The algorithm is evaluated by comparing its performance to that of the previous algorithms, using synthetically generated XML documents of a range of sizes and modified by varying numbers of random editing operations. The prototype merge tool used in these tests also includes a simple graphical interface for visualizing and resolving conflicts.

The DChanges series of workshops focuses on changes in all their aspects and applications: algorithms to detect changes, models to describe them and techniques to present them to the users are only some of the topics that are investigated. This year, we would like to focus on collaboration tools for non-textual documents. The workshop is open to researchers and practitioners from industry and academia. We would like to provide a platform to discuss and explore the state of the art in the field of document changes. One of the goals of this year's edition is to review the outcomes of the last four editions and to develop plans for the future.

Markup language is the combination of text and information (about text s structure and presentation style) about the text. A language that has codes for indicating layout and styling of a document (such as boldface, italics, paragraphs, placement of graphics, etc.) within a text file is called a Markup language. Widely used markup languages include SGML (Standard General Markup Language) and HTML (Hypertext Markup Language. In other words, when we format text to be printed (or displayed on a computer), we need to distinguish between the text itself and the instructions for printing the text. The markup is the instructions for the text. Markup can also indicate information about the text. For example, many students in school highlight certain phrases in their text books. This indicates that the highlighted text is more important than the surrounding text. The highlight color is markup. Markup Text added to the data of a document to convey information about the document; for example: tags, processing instructions, and hyperlinks.3 A text-formatting language designed to transform raw text into structured documents, by inserting procedural and descriptive markup into the raw text. 3 A language designed to describe or transform in space or time data, text, or objects into structured data, text, or objects, for example: SGML, HTML, and VRML.

Software comprehension and analysis of MATLAB and Octave programs are not trivial tasks. Programmers have to devote considerable effort to obtain relevant data from source code and related artifacts. Tools that provide support for software comprehension activities usually rely on parsers to obtain data from source code. The problem in the MATLAB/Octave case is the limited number of available parsers and the difficult to build an extensible solution with them. In this paper, we describe the development of a parser that converts MATLAB and Octave program codes into instances of the Knowledge Discovery Metamodel (KDM), which can subsequently undergo static analyses to feed different visual representations. The goal of these representations is to support software comprehension. We describe our experience in the use of this parser to build a software visualization environment to support the comprehension of MATLAB and Octave programs.

Coakley et al. described how they developed Version Aware Word Documents, which is an enhanced document representation that includes a detailed version history that is self-contained and portable. However, they were not able to adopt the unique-ID-based techniques that have been shown to support efficient merging and differencing algorithms. This application note describes how it is possible to adapt existing features of MS Word's OOXML representation to provide a system of unique element IDs suitable for those algorithms. This requires taking over Word's Revision Save ID (RSID) system and also defining procedures for specifying ID values for elements that do not support the RSID mechanism. Important limitations remain but appear surmountable.

Securing sensitive digital documents (such as health records, legal reports, government documents, and financial assets) is a critical and challenging task. Unreliable Internet connections, viruses, and compromised file storage systems impose a significant risk on such documents and can compromise their integrity especially when shared across domains while they are shared in offline fashion. In this paper, we present a new framework for maintaining integrity in offline documents and provide a non-repudiation security feature without relying on a central repository of certificates. This framework has been implemented as a plug-in for the Microsoft Word application. It is portable because the plug-in is attached to the document itself and it is scalable because there are no fixed limits on the numbers of users who can collaborate in producing the document. Our framework provides integrity and non-repudiation guarantees for each change in the document's version history.

Understanding how Brazilian health units have been reimbursed due to services provided on behalf of the Brazilian Public Unified Health System (SUS) is not a simple task.It requires the analysis of a myriad of data and hampers the identification of flaws as well as improvement opportunities regarding the budget application in the context of health public services.In this paper, we proposed an infrastructure to support the visual analysis of data from SUS related to services provided by licensed health units.To illustrate the use of proposed infrastructure, we conducted an example of use that analyzes the performance of licensed health units from the Brazilian Northeast region in a specific time interval.

Word processing merge tool interfaces can show users the changes made by each editor and allow a primary editor to accept or reject individual changes to create a finished document. But when there are many changes, possibly from many editors, users may be confused by the wealth of detail and find themselves unable to be select changes thoughtfully. In this paper, we present a new merging interface that enables users to filter changes based on the type of change being made, as well as providing controls that help users choose among conflicting changes in order to produce a correctly merged document. The interface's usability was tested via a usability study conducted with ten graduate students from the University of Wisconsin-Milwaukee. The study was designed to test whether the interface would help users better understand the changes made in two revisions and enable them to choose the best revisions. While the study found both positive and negative qualities in the prototype, most participants valued the change classification feature, suggesting that it is worthy of further research.

The year 2014 marked an important shift in theWeb's history, as users started to spend more time surfing the web using mobile devices than using desktop computers. However, today, a large proportion of websites are still not designed for good mobile device access. To tackle this problem, this paper proposes a new approach to adapting desktop-based web applications to the mobile environment. Our approach is supported by a task-based usability evaluation tool called MOBILICS, which is able to evaluate desktop-based web applications used in mobile devices. Based on the evaluation results, our tool provides detailed recommendations for fixing the detected usability problems. We conducted an experiment which demonstrates that our approach provides useful support for the adaptation of a desktop-based web application into a mobile version.

As a software project evolves, so does its build system. Significant effort is necessary to maintain the build system to cope with this evolution, in part because changes to source code often require parallel changes in the build system. Our tool, Formiga, is a build maintenance and dependency discovery tool for the Ant build system. Formiga's primary uses are to automate build changes as the source code is updated, to identify the build dependencies within a software project, and to assist with build refactoring. Formiga is implemented as an IDE plugin, which allows it to recognize when project resources are updated and automatically update the build system accordingly. A controlled experiment was conducted to assess Formiga's ability to assist developers with build maintenance. Subjects responded to scenarios in which various forms of build maintenance and/or knowledge about deliverables and their contents were requested. Subjects completed eleven different build maintenance tasks in both an experimental condition using Formiga and a control condition using only conventional IDE services. The study used a balanced design relative to both task order and use of Formiga. This design also ensured that order balancing was not confounded with the subjects' level of Ant expertise. Formiga was shown to significantly reduce the time required to perform build maintenance while increasing the correctness with which it can be performed for both novice and experienced developers.

CISS+ is a new surveillance system designed to aidclinicians seeking to help patients make healthy decisions abouttheir lifestyle and health. It takes clinical records as queries anduses these records to find articles in the scientific literature thatdescribe risk factors relevant to the patients' history and medicalstate. CISS+ is a revision of the earlier CISS system, which useda simple n-gram text retrieval strategy. CISS+ enhances CISS byusing higher-relevance terms and concepts taken from the UMLSand MetaMap systems and by using automated techniques relatedto relevance feedback to refine queries. CISS+ was evaluated viaa small set of experimental queries that were sent to other widelyavailable biomedical research search systems. CISS+ returned asmall number of results that had better relevance to the goal ofidentifying risks factors.

In an earlier paper at DocEng 2013, we reported on our efforts to make LibreOffice Writer documents be "version aware". Version aware documents use a namespace protected preamble to include a complete version history within the saved document file, plus unique identifier attributes on the document content elements in order to support efficient differencing and merging of versions. A particular challenge in this effort has been to ensure that the unique identifiers on the elements would be preserved through a complete load-edit-save cycle. This is challenging because content element data passes through three representations in its lifetime. At load time, XML is read to create ImportContext objects, which are then used to generate internal data structures used during editing. At save time, the internal data structures are converted to ExportContext objects, from which XML is generated for the saved file. The internal data structures are drawn from a small forest of inheritance hierarchies, where each hierarchy has a slightly different construction-destruction protocol and thus each one requires a different solution to preserving the unique identifiers. Working with a particular snapshot of the C++ implementation of LibreOffice Writer, we have reached a point where unique identifiers are preserved on nearly all content elements used in Writer documents. Unfortunately, there is no support for versioning of document style elements at this time. Support for version awareness has added about 3000 lines of code to a code base of slightly more than one million lines. The changes affect 128 files out of a total of 3354, organized in three large modules. We believe that these numbers show that adding full support for version awareness would have only a modest affect on the implementation of an office software suite. However, the fairly large number of files affected shows that version awareness resembles a non-functional requirement, since its support is not isolated in a small set of files.