Software Development Concepts for CompTIA Tech+ (FC0-U71): Programming Languages, Data Types, and Pseudocode

If you have worked through the Database Fundamentals domain for the CompTIA Tech+ (FC0-U71) exam, Domain 4.0, Software Development Concepts, is the logical next stop. It carries the same 13% exam weight as the database domain, but candidates often underestimate it because it looks like a "programmer's domain" on a non-programming exam. In reality, Tech+ does not expect you to write working code. It expects you to recognize categories of programming languages, know the handful of data types every language shares, understand basic programming building blocks, and read simple pseudocode or a flowchart. This guide walks through every one of CompTIA's official sub-objectives for Domain 4.0 so you can walk into the FC0-U71 exam room without a single surprise on this section.

Programming Language Types: Compiled, Interpreted, Scripting, Markup, and Assembly

The first sub-objective asks you to distinguish between categories of programming languages, not specific languages. CompTIA groups them into five buckets:

• Compiled languages (C, C++, Java) are translated entirely into machine code by a compiler before the program ever runs. That extra step makes compiled programs fast to execute but slower to develop, since you must recompile after every change.
• Interpreted languages (Python, Ruby) are read and executed line by line by an interpreter at runtime. There is no separate compile step, which makes testing and debugging faster but execution somewhat slower. Our introduction to Python is a good real-world look at how an interpreted language behaves, even though that article is written for security scripting rather than the Tech+ exam.
• Scripting languages (JavaScript, Bash, PowerShell) automate tasks and are typically interpreted rather than compiled. The exam wants you to know that "scripting" describes a use case (automation, gluing systems together) more than a strict technical category.
• Markup languages (HTML, XML) describe how content should be structured or displayed. They are not "programming" languages in the logic-and-computation sense because they contain no executable instructions of their own.
• Assembly language is the lowest-level, human-readable representation of machine code, specific to a particular processor architecture. It is the closest thing to "speaking" directly to hardware without writing raw binary.

Exam tip: expect a matching or scenario question that gives you a short code sample or a description ("this program must be translated before it can run on any machine") and asks you to pick the category. Memorize compiled versus interpreted first; it is the pairing CompTIA tests most often.

Data Types: Booleans, Integers, Floats, Characters, and Strings

Every programming language, regardless of category, organizes data into types. Tech+ expects you to recognize these by name and by example:

• Boolean — a value that is only ever true or false. Booleans drive every decision point in a program.
• Integer — a whole number with no decimal component (-2, 0, 42).
• Float (floating-point number) — a number with a decimal component (3.14, -0.5), used whenever precision below a whole unit matters.
• Character — a single letter, digit, or symbol ('A', '7', '$').
• String — a sequence of characters treated as text ("Tech+", "Las Vegas"). Strings are technically built out of individual characters, which is why the two are tested as a pair.

Data types also connect back to Domain 1.0's number systems. An integer stored in memory is ultimately binary, and a programmer debugging a numeric overflow needs to think in terms of how many bits a given integer type can hold. If binary, decimal, and hexadecimal conversions are still shaky for you, review our number systems guide before moving on, since a few FC0-U71 questions blend the two domains in a single scenario.

Exam tip: CompTIA likes to test data type recognition with a short literal value and four answer choices. If you see a value with a decimal point, it is a float, not an integer, even if the decimal is .0.

Core Programming Concepts: Variables, Constants, Arrays, Functions, and Objects

This sub-objective covers the vocabulary every piece of code is built from:

• Variables store data that can change while a program runs (a user's current score, a running total).
• Constants store data that is set once and never changes (the value of pi, a maximum login attempt limit).
• Arrays are indexed collections that hold multiple values of typically the same data type under a single name, accessed by position (array[0], array[1]). If you have ever looked at a JSON document, the bracketed lists you saw there are a real-world array in action.
• Functions package a block of reusable code under a name, so it can be called repeatedly instead of rewritten. This is also exactly how most APIs are exposed to other programs: an API endpoint is, conceptually, a function another application can call over a network.
• Objects bundle related data and the functions that act on that data into one unit, forming the basis of object-oriented programming (more on that below).

Exam tip: the distinction CompTIA tests most is variable versus constant. If a scenario describes a value that "should never be changed by the program once it is set," the answer is constant, not variable, even if a variable could technically be made to behave that way.

Organizing Logic: Pseudocode, Flowcharts, Branching, and Looping

The final sub-objective is about how developers plan and visualize logic before, or instead of, writing actual syntax:

• Pseudocode is a plain-language, structured description of an algorithm's steps, written so a human can follow the logic without knowing a specific programming language's syntax. A pseudocode line might read "IF temperature > 100 THEN display warning."
• Flowcharts represent the same kind of logic visually, using standardized shapes: ovals for start/end, rectangles for process steps, and diamonds for decision points.
• Branching is the general term for a program choosing between two or more paths based on a condition, implemented with if/then/else logic.
• Looping repeats a block of code while a condition holds true (or for a set number of iterations), avoiding the need to write the same instructions over and over.
• Object-oriented methods organize a program as a collection of interacting objects (see above) rather than a single top-to-bottom script, grouping data and behavior together for easier reuse and maintenance.

Exam tip: when CompTIA shows you a flowchart diagram on the actual exam, trace it exactly as drawn. The most common wrong answer is the one a test-taker gets by assuming what the logic "should" do rather than reading the diamond's actual condition.

Exam Tips for Domain 4.0 on the FC0-U71

• Domain 4.0 is worth 13% of the exam, tied with Data and Database Fundamentals, so under-preparing here costs you as much as skipping a whole domain elsewhere.
• CompTIA will not ask you to write code from scratch. Every question is multiple choice, matching, or "identify this concept from a short example."
• Pair this domain with Domain 5.0 (databases) and Domain 1.0 (number systems) in your review; FC0-U71 scenario questions frequently cross domain lines.
• When a question gives you a code-like snippet, first identify the data type being used, then ask what structure (variable, array, function, object) it belongs to. That two-step habit resolves most of these items quickly.

Key Takeaways

• Domain 4.0, Software Development Concepts, makes up 13% of the CompTIA Tech+ (FC0-U71) exam and tests recognition, not coding ability.
• Know the five programming language categories: compiled, interpreted, scripting, markup, and assembly.
• Memorize the five core data types: Boolean, integer, float, character, and string.
• Understand variables, constants, arrays, functions, and objects as the basic building blocks of any program.
• Be able to read pseudocode and a simple flowchart, and recognize branching, looping, and object-oriented organization when described in a scenario.