C867 Scripting and Programming - Applications is banner number ITSW 2130, four competency units in the School of Technology, and it is the C++ course. The catalog describes it as an exploration of the C++ language through its syntax, development environment and tooling, which means the competency is not only writing correct code but working inside a compiled toolchain: a compiler, a build step, an executable and errors that arrive before the program ever runs. Note carefully that D493 prints the exact same title in the catalog and teaches Python instead, so the two courses share a name and not a subject.
What changes when the language is compiled
Students arriving from a scripting background meet three new facts at once in C867. Code has to compile before it can be wrong at runtime. Memory is something you can hold a reference to, and something you can lose. And types are checked by the compiler rather than discovered by the program, so a mismatch is a build error rather than a surprise in output.
That first fact reorders how you work. A compiler error message names a line and a category, and reading those messages fluently is a real skill that this course quietly grades. A missing semicolon cascades into a dozen errors that all point somewhere else, and the useful habit is to fix the first reported error and rebuild rather than working down the list.
The second fact is where four units of weight come from. Pointers, references, dynamic allocation and the discipline of releasing what you allocated are not decoration in C++, they are the language. Whether or not an aspect names memory directly, a program that leaks or that dereferences something already freed is a program that will behave differently on the evaluator's machine than it did on yours.
Object orientation arrives on top of all that. Classes with private data and public behavior, constructors that establish a valid object, and the separation of a header from an implementation file are the structural moves the course asks for. Students often write correct C that happens to compile as C++, and it works, and it does not demonstrate the competency the aspects describe.
From scored aspects to classes, files and a word budget
Every rubric aspect is judged independently, a score of 2 in each is what passes, and one missed aspect returns the whole task. In a programming course the translation is direct: each aspect maps to a class, a member function, a file or a documented decision, and you should be able to name that mapping before you write code.
Try the arithmetic on a typical shape. Suppose your rubric lists eight scored aspects and the deliverable is a program plus a short design document of about 1,200 words. Eight into 1,200 is 150 words per aspect. Sort the rows first. Five of them are implementation aspects that say the program does something, and for those the code is the evidence, so the document only needs a pointer of about 80 words each naming the class and function that satisfies it. That is 400 words, releasing 350. The remaining three are explanation aspects, asking why a data structure was chosen or how the design handles an error condition, and those get 250 each, which is 750. The total comes to 1,150, close enough to the target, and the explanation sections are now three times the size of the pointer sections, which is the correct ratio.
Then order the build by dependency, not by rubric. Data model first, then the class interface, then the behavior, then input handling, then output formatting. Input handling written first always gets rewritten once the data model settles.
In the C++ course now?
Send the scored aspects and your specification. You get a class design mapped to each row plus a walkthrough of the parts that trip students in a compiled language.
How a C++ submission is put together
| Component | What belongs in it | Why it is scored |
|---|---|---|
| Header files | Class declarations, member signatures, include guards | Shows the interface was designed before the implementation |
| Implementation files | Definitions matching the declarations, one class per file where practical | Demonstrates separation of interface from behavior |
| Main program | Setup, the driving flow, and nothing that belongs in a class | A crowded main is the classic sign of missing abstraction |
| Input validation | Every value read from a user checked before it is used | Aspects about robustness are answered here or not at all |
| Memory handling | Every allocation paired with a release, ownership stated in comments | The specific competency a compiled language course exists to build |
| Output formatting | Exact labels, spacing and precision the specification asked for | Literal requirements are checked literally |
| Build instructions | Compiler, standard version and the command or project settings used | An evaluator who cannot build the program cannot score it |
The last row is the cheapest insurance in the course. A short note naming the compiler and the language standard removes the single most common reason a working program fails to run for someone else.
Comments, test evidence and honest sourcing
Code carries its own evidence when it is commented for a reader rather than for the author. Useful comments state intent and constraint: why this loop stops where it stops, what range this parameter accepts, what happens when the input is empty. Comments that restate the syntax add nothing. A block comment at the head of each file naming its purpose and its author is the convention most programs expect.
Test evidence matters more than students expect in a course with four units on it. Keep a short table of the inputs you tried and the outputs you got, including the invalid inputs, and put it in the document. It answers robustness aspects directly and it proves the program was exercised rather than compiled once and submitted.
On sourcing, be exact. C++ has an enormous body of published example code and the temptation to adopt a snippet is constant. If you use one, attribute it in a comment with the source and adapt it knowingly, and be certain you can explain every line, because an aspect that asks you to justify a design decision cannot be answered about code you did not reason through. Cite the language reference or a standard text when your written explanation makes a claim about how the language behaves, in APA where your program requires it.
What passes on the first submission
Work at WGU is Competent or Not Competent rather than graded on a curve or a letter scale, and there is no ordinary grade point average behind it. A performance assessment that misses an aspect comes back with evaluator comments and can be revised and resubmitted without penalty, so a return costs queue time in a six month term rather than a permanent mark.
Programs that clear the first time compile from a clean folder with no leftover build artifacts, run without a debugger attached, and produce output that matches the specification character for character where the specification was specific. Their design documents point at real function names. Their error handling exists for the inputs the specification named rather than for imagined ones.
The returns are predictable. A program that works only in the development environment because of a hardcoded file path. Output that is right in substance and wrong in format when the specification asked for a particular layout. An explanation aspect answered with a description of what the code does rather than an argument for why it does it that way. And memory handling absent because the program is small enough to get away with it, which is true right up until an aspect names it.
Six things that slow C867 students down
- Fighting the toolchain instead of the problem. Set up the compiler and confirm a hello world builds on day one. Environment problems discovered in week six read as content problems and are not.
- Reading compiler errors from the bottom. Fix the first error, rebuild, repeat. The rest of the list is usually the first error echoing.
- Writing C++ that is really C. Arrays, raw loops and free functions everywhere will run. The scored aspects are usually about classes and encapsulation.
- Allocating without a plan for release. Decide who owns each allocation when you write it, not after the leak appears.
- Confusing this course with D493. The catalog prints the same title on both. C867 is the C++ course under ITSW 2130 and D493 is the Python course under ITSW 2135, so make sure the code on your degree plan is the one you are studying.
- Submitting without a fresh build. Delete the build folder, rebuild from source, run once more. It takes two minutes and catches the file that was never actually saved.
How we work on this course
For C867 the work is design first. Send the scored aspects and the specification and you get a class breakdown keyed to each row, a model design document, and a code review that names what is wrong and why rather than handing back a rewritten file, because an aspect asking you to justify a decision is unanswerable if the decision was not yours. Where a section of your course is assessed by an objective assessment, support is preparation only: concept notes, drills and an honest go or wait call on your preassessment. Objective assessments are proctored, we never sit or assist during one, and we never ask for or touch WGU portal credentials.
Four units is one of the heavier single courses in the technology plan, and clearing it inside the same six month flat rate term as the rest of your load is what makes the term arithmetic work in your favor.
Three questions C867 students ask
Is C867 the same as ITSW 2130?
C867 and D493 have identical titles. Are they the same course?
What language standard and compiler should I use?
Where C867 sits in WGU's programs
The July 2026 catalog places this code in 2 current WGU programs. Open a program page for the complete standard path and term positions. The live Degree Plan remains authoritative after transfer credit, substitutions, and mentor planning.
The assessments, one by one
The public catalog does not publish this course's PA/OA identity or task count. WGU Tutors publishes at most one PA manual per course and only from a WGU-controlled public rubric. Until that source exists, PA help begins from the student's real Course of Study and OA support remains preparation only.