This manual is for IT-FPX2249 Assessment 1, start to submission. Assessment 1 of IT-FPX2249, Introduction to Programming with Java, is usually the course's first paired deliverable: a design artifact written against the requirement, and a program written against that design. FlexPath grades it one criterion at a time, and functionality, design, style and documentation are graded apart, which is why flawless output from a single long method loses rows that correct output cannot buy back. The method our tutors use is written out below, with a structure keyed to the criteria and an annotated sample excerpt. Want it handled instead? Delivery of a premium original sample for this exact assessment takes 24 to 48 hours, with free revision until the guide is cleared. Your courseroom may print this as IT FPX 2249 Assessment 1 or IT2249 Assessment 1; it is the same deliverable, and IT-FPX2249 Assessment 1 is what this manual walks through.
One honesty note before the manual: Capella revises courses and scoring guides over time, so always write to the exact scoring guide attached to your assessment in the courseroom. The course identity above is verified on capella.edu; the method and structure below are our tutors' approach to it, not Capella's official rubric text.
How IT-FPX2249 Assessment 1 is scored
FlexPath issues levels rather than letters. Each criterion lands on one of four, and the level text is the specification for the artifact underneath it:
| Level | What it means on a design and first program |
|---|---|
| Distinguished | The design is written from the requirement rather than narrated backwards from the code, the program matches it, the decisions about types and rounding are stated with reasons, and the document says which requirement is unimplemented if any is. The stated decision is where the top level hides. |
| Proficient | A correct program with a matching design artifact and conventional style. Competent work, one explained decision below the column above. |
| Basic | Working output produced by one long method, with pseudocode reconstructed afterwards. The commonest result on a first programming deliverable. |
| Non-performance | A required artifact never arrives, most often the design or the source file itself. A criterion written about something you did not attach is scored as empty. |
Faculty can tell when a design was produced after the fact, because reverse-engineered pseudocode describes the code line by line with the variable names included instead of describing the problem. Write the design first, then let the program teach you something and update the design honestly.
The IT-FPX2249 Assessment 1 method, step by step
-
Count the artifacts on the guide before you open an editor
Programming criteria usually split four ways, and each of the four exists separately: the design artifact, the source, the evidence of execution, and the written explanation. Write that list down. Building the program first and reconstructing the rest afterwards is exactly how a learner finishes with correct output and three unanswered rows.
-
Restate the requirements as testable sentences
One line per rule, each phrased so you could later point at the code that enforces it. What comes in, what goes out, what is rejected, and what the boundaries are. Rules you cannot phrase testably are rules you have not understood yet, and they are cheaper to fix in a sentence than in a method.
-
Write the design against the problem, not the solution
Pseudocode, a flowchart or an input, process and output breakdown, whichever the prompt names. Keep it at the level of steps a person could follow, with the decisions visible and no Java syntax in it. The point is to fix the logic while changing it is still free, which is also the argument you make in the design section.
-
Fix the type and rounding decisions on purpose
Dividing two integers discards the remainder, so an average computed that way is quietly wrong rather than visibly broken. Floating point cannot represent tenths exactly, so money belongs in whole cents or in a decimal type. Decide these before you code, then state each decision in a sentence, because explaining one earns a row that silently getting it right does not.
-
Decompose, name, and declare the constants
Main reads short and calls methods named for what they compute; each method does one job and returns; thresholds are declared once as named constants rather than typed wherever needed. Classes in Pascal case, methods and variables in camel case, constants in upper case with underscores, and the file named for the public class it holds.
-
Run it against your own list, then self-score
Execute the program once per requirement, capture each run separately, and include the run where bad input is refused politely. Submit the source as text as well as any image, since a grader cannot compile a picture. Then grade each criterion yourself and upload with the two business days of evaluation still available.
A structure that maps to the criteria
The word targets are planning figures our tutors use for a first programming deliverable of this size, not Capella rules; expand whichever section your own guide weights.
| Section | What it must do | Guide |
|---|---|---|
| Problem and requirements | The task restated, the inputs, the outputs, and the rules the program has to enforce. | ~200 words |
| Design artifact | Pseudocode, flowchart or an input, process and output breakdown, written from the requirement. | ~250 words |
| Decisions and their reasons | Types, rounding, constants and structure, each choice justified in a sentence. | ~220 words |
| The program | Classes, methods and control flow, supplied as selectable text as well as attached. | ~250 words |
| Execution evidence | One capture per requirement, numbered and captioned to the criterion it serves. | ~200 words |
| Comments, style and references | Documentation comments, formatting, and any adapted source attributed in place. | as needed |
Annotated sample excerpt
A passage from an original model our team wrote, at the register the top column describes. Study how the decisions arrive before the code, then do the same for your own task.
The co-op needs one number at the scale: the price of whatever is in the scoop, given a bin code and a weight in pounds.1 The design is written as input, process and output before any Java exists, so the process column reads look up the price per pound for the bin code, reject the code if the table does not hold it, multiply price by weight, round to the nearest cent, return the total.2 Two decisions are fixed here rather than discovered later: weight arrives as a double because the scale reports fractions of a pound, and money is held in whole cents in a long, because a tenth of a dollar has no exact representation in binary floating point and a total accumulated in doubles drifts away from the receipt.3
- 1States the whole requirement in one sentence with the inputs and the output named. A design that starts here cannot drift, because there is only one thing the program is for.
- 2Keeps the design at the level of steps rather than syntax, and includes the rejection path. A design showing only the successful route is the version that produces an unvalidated program.
- 3Justifies two type decisions with the mechanism behind each. Explaining why doubles drift earns a row that quietly using a long would not have earned at all.
The full premium sample for your exact assessment, written fresh to your scoring guide and issue, is free to request. Study it, revise it into your own voice, and submit work you understand.
The five mistakes that cost Distinguished
- Pseudocode reconstructed from finished source. It describes the code line by line with variable names attached, and faculty recognise the pattern immediately.
- An average computed with integer division. The remainder is discarded before anything is displayed, so the output looks plausible and survives a careless test.
- Money accumulated in a floating point variable. The total drifts by fractions of a cent, and a receipt that disagrees with a hand calculation fails the functionality row.
- Thresholds typed wherever they are needed. A number repeated in four methods is four places to forget when it changes, and the style criterion is written about exactly that.
- Source submitted only as a screenshot. An evaluator cannot compile an image, and a required file that was never attached is graded as missing.
Pre-submission checklist
- All four artifacts identified from the guide before any code is written
- Requirements restated as testable sentences, each traceable to a line of code
- Design written from the problem, with the rejection path included
- Type and rounding decisions stated with the reason for each
- Named constants declared once, with conventional naming throughout
- Source supplied as selectable text and attached as the file the prompt asked for
First Java deliverable due?
Send us the prompt, the criteria and the release your section compiles against. The sample comes back inside 24 to 48 hours as source that builds on that release, a design written against the requirement rather than the code, and a capture per requirement. A developer compiles and runs it before the file reaches you, and revisions stay free until the guide clears.