Contents

Introduction

This page attempts to provide an organizational overview of the PC² wiki -- that is, to act as a sort of "Table of Contents" for the wiki, while recognizing that wikis are inherently not well-suited to "top-down organization/explanation".

The page provides links to all of the pages within the PC² Wiki, arranged hierarchically by subject. While it's possible that some pages (especially newly-added pages) might be missing from this list, an effort is made to keep the list "current".

The PC² Wiki is conceptually divided into two major sections: the PC2 User's Wiki and the PC2 Developer's Wiki; these are described below.

PC2 User's Wiki

The PC2 User's Wiki has numerous pages documenting a variety of user-interest topics including things like

• Using a web browser to access PC2
• Contest Clock, a description of how PC² allows the Contest Administrator to manage contest time.
• YAML Contest Configuration, which explains how a contest can be configured from input files (as opposed to interactive configuration).
• Scoreboard Viewing, information on how the Contest Administrator can provide both public and private scoreboards.
• Scoreboard HTML Configuration, which describes how the Contest Administrator can use XSL Transformations (XSLT) to change the formatting of the scoreboard pages produced by PC².
• Scoreboard Standings Data Fields, a listing of data fields which a user can access when applying XSL Transformations for reformatting scoreboard pages.
• What Validators are and how they work, including both
  • Input-Validators and
  • Output Validators, which comprise several types:
    • the PC² CLICS Validator
    • the PC² Internal Validator
    • user-supplied Custom Validators
• Sample Contests
• how Multi-site-Support works
• the PC2v9-API
• background and historical information such as PC2 Recent Releases and PC2 Release History

PC2 Developer's Wiki

The PC2 Developer's Wiki contains the following sections:

PC2 Design, which in turn contains pages on

• PC2v9 Architectural Overview
• PC2 Client-Server Organization
• Modules, a description of the organization of PC2 into different components such as
  • the Administrator Client
• MVC Details, a description of how the Model/View/Controller pattern is used in PC²
• Validators, a page which gives an overview of what Validators are and how they are used in PC2v9, and which includes links to related pages including:
  • Input Validators (what they are and how they work)
  • Output Validators (what they are and how they work)
  • CLICS Validator, an overview of PC² support for the CLICS Validator specification
  • CLICS Validator Implementation, giving the details of the PC² implementation
  • Custom Validators, which describes how to incorporate user-written validators into PC²
• Multi Site Support, which describes the concept of multi-site contests and how it is supported in PC2v9.
• Replay Contest Submissions, a description of how events in a contest (such as submissions) can be "replayed".
• Realm.properties, information on configuring access to the PC2 webserver which provides access to things like the Event Feed.
• Notes on YAML Loading, which explains a few quirks related to YAML Contest Configuration files.
• Sample Contests, an explanation of the sample contests which are built into PC2v9.

PC2 Developer's Notes, which contains links to pages on

• Guidelines for Contributing to PC2
• Development Standards, a detailed list of expectations for developer coding standards and practices
• Development Environment, a set of descriptions about how the system is organized and how distributions are generated and tested, including sections on
  • Building the system
  • Creating a distributable version of the system
  • Automated Continuous Integration/Deployment
  • Testing during development, including Unit Testing
• Development Flow, a detailed list of the steps which a developer should follow when fixing bugs or proposing new features
• Development Policies and Procedures, a set of policies and procedures which we expect all developers (including ourselves) to follow
• Guidelines for Submitting Pull Requests
• PC2 JUnits, which contains information on creating JUnit tests for suggested upgrades to PC²
• Continuous-Integration-and-Deployment (CI-CD), detailed description of how the PC² Continuous Integration and Deployment pipeline works
• Building a PC2 Distribution, which explains how to create a self-contained PC² distribution file for deploying the system
• Building the PC2 GitHub-Website, which explains the automated process by which the PC² github.io website is built and explains how to edit/update the website pages
• PC2 Project Organization, a description of the top-level organization of the (set of) Eclipse projects comprising the PC2v9 system
• PC2v9 Source Code, a description of each of the Java "packages" comprising the PC2v9 source code
• Hints on Using Eclipse, a set of notes which will (hopefully) make developers' lives easier, and
• Notes on Debugging, a set of hints intended to help developers.

PC2 Details, which contains links to dozens of low-level design articles, including:

• PC2v9 Module Startup, a description of the code flow when a PC² module is started.
• Transport Layer, which covers details on how PC² modules communicate using PC2 Packets.
• PC2V9 Run Execution, a description of how the system actually executes submissions from teams.
• CLICS Validator Implementation, a description of how PC2V9 supports the CLICS Validator specification.
• Web Team Interface Implementation, giving implementation details about how the components of the EWU "Web Team Interface" works, including:
  • WTI API Project Implementation Details
  • WTI UI Project Implementation Details
  • WTI Build Package Details
  • WTI UI Angular Project Structure
  • WTI-API Scoreboard Implementation
  • WTI UI Scoreboard Implementation
  • Web Team Interface Upgrades, a list of upgrade tasks waiting to be implemented
• Scoreboard Implementation, which covers details on how the various PC² scoreboard displays are generated.
• Scoreboard HTML Transformations, which explains how the system applies XSL Transformations in generating scoreboards.
• Contest Clock, which describes various things about how PC² manages "contest time"
• Technical Debts, a list of "technical deficits" -- places that should be fixed/improved in the code.
• Evil Programs, a description of PC2V9 sample submissions designed to cause a Security Violation.
• Exit Code, an overview of what OS exit codes are and how they different between platforms.
• Creating a Custom Module, an explanation of how to create custom PC2v9 modules with arbitrary characteristics.
• Using the PC2v9 API to Start a Contest, which explains what its title describes.
• Notes on YAML Loading, which provides some details about how PC2v9 handles loading contest configurations via YAML files.
• Test Case Results Table, which gives a narrative explanation of how the Judge's Test Results Table is populated.
• UI Design Elements, which gives insight into the philosophy behind the flexible UI design approach used in PC2.
• Edit Problem Pane, a low-level description of the structure of one of the specific UI classes in PC2.
• Input Validator Pane, a low-level description of another of the PC2 UI classes.
• Realm.properties - a configuration file for managing access to PC2v9 web services such as the Event Feed
• Replay Contest Submissions, an explanation of how a previous contest can be "re-run".
• Undocumented Features, which describes a collection of, well, features that are (otherwise) undocumented -- shortcuts that might make life easier and so forth.
• Detailed Design Elements, about additional low-level detailed design elements making up the PC2v9 code.

Future Tasks, a list of tasks which potential PC² developers are invited to examine for possible interest.