WGU C867: Scripting and Programming - Applications

What C867 Is, and Why It Feels Different From Your Other Courses

Scripting and Programming – Applications (C867) is a four-competency-unit course in WGU's School of Technology, and it is where a lot of students write their first real C++ program. There is no proctored multiple-choice exam here. The entire course is assessed by a performance assessment: you build a working C++ application, you document it, and you submit the source code and supporting files for evaluation against a rubric. That single fact changes everything about how you should prepare.

Direct answer: You pass C867 by writing, compiling, and submitting a C++ program that satisfies every individual line of the task rubric — not by memorizing anything. Work through the course material until pointers, classes, and arrays feel routine, then build the program one requirement at a time, compiling and testing after every small addition. Before you submit, walk the rubric top to bottom as a checklist and confirm your code builds and runs cleanly from a fresh compile.

The students who take C867 are usually early in a computer science, software engineering, or IT degree, and many of them have never written a line of compiled code before. If that is you, the discouragement you may feel in week one is normal and it is not a signal about your ability. C++ is unforgiving in a way that Python and JavaScript are not: it will refuse to compile over a missing semicolon and it will happily let you point at memory that no longer exists. That strictness is exactly why the course sits where it does in the degree. Once you have wrestled a C++ program into working order, the languages that come later feel considerably gentler.

It also matters because this course is load-bearing. Object orientation, references and pointers, and the habit of reading a compiler error instead of flinching at it all carry forward into later coursework such as D387 Advanced Java and D385 Software Security and Testing. Course codes at WGU do get refreshed periodically, so confirm the exact code on your own degree plan — but the C++ skills below are what you are being asked to demonstrate regardless of the label.

What the Performance Assessment Asks You to Demonstrate

The assessment is a build task: you are given a written specification and asked to produce a small console application in C++ that meets it. Rather than testing recall, it checks whether you can translate requirements into compiling, running code. The skill areas the course covers, and that the task exercises, include:

• Variables, data types, and expressions — declaring and using the built-in types correctly, and knowing what happens at the boundaries between them.
• Control structures — branching and looping, including nested loops and the off-by-one errors that live there.
• Arrays and vectors — storing collections, iterating over them, and knowing when a fixed-size array is the wrong tool.
• User-defined functions — parameters, return values, pass-by-value versus pass-by-reference, and splitting logic into functions that each do one thing.
• Pointers and dynamic memory — allocating on the heap, dereferencing safely, and releasing what you allocated. This is the concept most students name as the hard one.
• Classes and objects — constructors, destructors, accessors and mutators, private data, and inheritance between related classes.
• String handling and parsing — pulling structured fields out of delimited text, which student projects for this course consistently involve.
• Console output formatting and basic error handling — printing readable, correctly formatted results and handling input that does not behave.

Alongside working code, rubrics for programming tasks expect professional presentation: meaningful identifier names, consistent formatting, and comments that explain intent. Treat those as scored requirements rather than as polish you add if time allows, and check your own task's rubric for exactly how they are worded.

How Hard Is It, and How Long Should You Budget?

Many students describe C867 as moderately difficult with a steep opening — hard for the first week or two, then noticeably easier once the mental model clicks. Students who arrive with prior programming experience commonly report finishing in roughly two to four weeks of steady evening work. Students with no programming background more often report six to eight weeks or more, which is a perfectly respectable pace.

The honest advice is to stop benchmarking yourself against acceleration posts. A performance assessment has no clock running during the attempt, and if your submission comes back with evaluator notes, you fix the named items and resubmit. Plan around that safety net rather than fearing it. Budget your time for the build, not for a test date, and give yourself a week of slack for at least one revision cycle.

A Build Plan That Actually Works for This Course

Reading about C++ does not teach C++. Everything below is built around producing code, because typing code is the activity that transfers.

Week 1 — get a toolchain working and stop fearing the compiler. Install a development environment first and prove you can compile and run a "hello world" before you study anything else. Students most commonly report using the free Visual Studio Community edition or Code::Blocks; either is fine, and getting one working end to end removes the single most common source of week-three panic. Then work through the course's interactive courseware — students consistently report an interactive zyBooks C++ text — and actually type the exercises rather than skimming the readings.

Week 2 — drill the three concepts the task leans on. Practicing retrieval beats rereading. Write tiny standalone programs: one that allocates an object on the heap and deletes it, one that splits a delimited string into fields, one base class with a derived class that overrides a method. Each should take fifteen minutes and each should be thrown away. The goal is fluency, not artifacts.

Week 3 — build the task incrementally. Open your rubric and turn it into a literal to-do list, one line per requirement. Implement the smallest piece, compile, run, confirm the output, save a checkpoint, then move to the next. Never write two hundred lines before compiling; if you do, you will be debugging four problems at once and will not be able to isolate any of them. If you are comfortable with source control, use it — the habits from D197 Version Control pay off immediately here, because being able to roll back a broken change is worth an entire evening.

Week 4 — verify, document, submit. Do a clean rebuild from scratch. Read your own code against each rubric line and mark it satisfied or not. Re-drill only the concepts you fumbled, not the whole language. And use the support you are paying for: course instructors are available for one-on-one help, and one screen-share on a stubborn pointer bug can save days.

Where C867 Submissions Most Often Come Back

• Code that does not compile on the evaluator's machine. A program that runs in your editor but depends on your local setup is the most avoidable failure in the course. Rebuild clean and test the exact files you are about to upload.
• Partially met rubric lines. Rubrics are scored line by line. A requirement that is "mostly" implemented is not implemented.
• Submitting code from public repositories. Many past C867 projects sit on GitHub. Submitting someone else's work is an academic integrity violation, it is detectable, and it leaves you unable to explain your own code. Read for structure if you must, then close the tab and write your own.
• Memory handled carelessly. Allocating without releasing, or dereferencing something already freed, produces bugs that appear at random and are miserable to chase down.
• Waiting too long to ask for help. Students who stall for three weeks and then contact their instructor almost always wish they had reached out in week one.
• Ignoring readability. Single-letter variable names, inconsistent indentation, and zero comments undercut a submission independently of whether the program works.

C867 Readiness Checklist

• Can you compile and run a C++ program from a clean project without looking up the steps?
• Can you explain, in your own words, what a pointer holds and what happens when you dereference one that is no longer valid?
• Can you write a class with a constructor, a destructor, private data members, and accessor methods from memory?
• Can you create a derived class that overrides a base class method and explain why the override is called?
• Can you take a delimited string and split it into typed fields without copying code from a tutorial?
• Can you loop over an array or vector of objects and print formatted output in a specific column layout?
• Can you read a compiler error message, identify the offending line, and fix it without guessing?
• Have you mapped every single line of your task rubric to a specific place in your code?
• Have you done a fresh rebuild of the exact files you intend to submit and confirmed the program runs correctly?

C867 FAQ

Is C867 an objective assessment or a performance assessment?

It is a performance assessment. There is no proctored multiple-choice exam. You submit a C++ project and it is evaluated against a rubric, with revision and resubmission available if any requirement is not fully met.

How many competency units is C867 worth?

Four competency units, per the WGU institutional catalog. Confirm against your own degree plan, since program versions differ.

Do I need programming experience before starting?

No. The course teaches C++ from the beginning, and the provided courseware starts with fundamentals. Students without experience simply need to budget more calendar time and resist comparing themselves to classmates who have coded before.

What software do I need?

A C++ development environment. Students most commonly report using the free Visual Studio Community edition or Code::Blocks. Install and verify your setup on day one — toolchain problems cause more lost time in this course than any concept does.

How long does C867 usually take?

Many students with prior programming experience report two to four weeks; many beginners report six to eight weeks or more. Because there is no exam date, plan around your build pace and leave room for one revision cycle.

What happens if my submission is returned?

You receive notes identifying which rubric items were not met, you correct those specific items, and you resubmit. This is a normal part of the performance assessment process and is not a mark against you.

Want to see how this course fits the rest of your program? Browse the School of Technology guides, compare notes with the gentler on-ramp in D335 Introduction to Programming in Python, or open the full index of WGU course guides. For official course and program details, check WGU's institutional catalog.

wguproctoredexams.com is an independent study resource and is not affiliated with or endorsed by Western Governors University.