Jahziah.
العربية

STUDY GUIDE · GKU 1

Computing foundations study guide (Software Engineering)

Computing foundations is the heaviest unit of the exam because everything else rests on it. It starts with the craft of turning a problem into a correct program — tracing loops, counting operations, choosing a data structure — and with the paradigms that languages offer for expressing that program. It then opens the machine the program runs on: the operating system that schedules processes, shares memory and stores files, and the database that keeps data consistent while many users change it. The later parts move from a single program to a system: systems-engineering thinking and reliability, construction standards, lifecycle models and measurement, testing, design by contract, state machines and grammars, distributed and real-time design, and finally the tools and platforms — debuggers, profilers, web, mobile and GUI frameworks — that a software engineer uses every day. Each section opens with a quick-revision card, and the worked examples run from easy to exam level; every trace and number in them was checked by running it.

Continue in the app

Structured by the official ETEC subject standard for this topic: every listed topic and learning outcome, with formulas, figures and worked examples. The full sections are available to members in the app.

SKU 1.1 · Foundations of computer science

  1. Programming fundamentals and problem solving

    From a problem statement to a correct program: decomposition, the three control structures, trace tables, counting loop iterations exactly, and the language details (integer division, overflow, a stray semicolon) that exam questions are built on.

  2. Algorithms and complexity

    How fast a program grows with its input: Big-O, counting operations in loops, searching and sorting costs, recursion and the master theorem, and the design strategies — divide and conquer, greedy, dynamic programming — with the case where greedy fails.

  3. Data structures

    Arrays, linked lists, stacks, queues, binary search trees, heaps, hash tables and graphs: what each one makes cheap, what it makes expensive, and how to trace it by hand.

  4. Object-oriented programming

    Classes and objects, the four pillars (encapsulation, abstraction, inheritance, polymorphism), access control, constructors and destructors, overloading against overriding, and the virtual-function rule that decides which method runs.

  5. Programming paradigms and language design

    Imperative, object-oriented, functional and logic programming compared, and the language-design questions an exam asks about them: syntax against semantics, compiled against interpreted, static against dynamic typing and scoping, and how parameters are passed.

  6. Operating systems: processes, scheduling and deadlock

    What an operating system does, the life of a process, CPU scheduling with turnaround and waiting times (FCFS, SJF, SRTF, round robin), and deadlock — its four conditions and the banker's safety test.

  7. Database systems: relational model, SQL and NoSQL

    Why a DBMS instead of files, the relational model and its keys, relational algebra and SQL (joins, grouping, NULLs), transactions and ACID, and when a key-value, document, column-family or graph store fits better.

  8. Functional dependencies and normalisation

    Why badly designed tables cause update anomalies, how functional dependencies and attribute closure find the candidate keys, and how 1NF, 2NF, 3NF and BCNF are tested and reached by lossless decomposition.

SKU 1.2 · Software engineering design

  1. Concurrency and systems design

    Designing a system as cooperating concurrent parts: races and lost updates, the critical-section requirements, locks, semaphores and monitors, the bounded-buffer problem, and how lock ordering keeps a design free of deadlock.

  2. File systems and storage management

    How a file system maps named files onto disk blocks (contiguous, linked and indexed allocation, inodes), what a disk access costs, how disk-scheduling algorithms order requests, and what each RAID level buys.

  3. Memory management and virtual memory

    The memory hierarchy, logical against physical addresses, fragmentation, paging and address translation, the TLB and effective access time, and demand paging with FIFO, LRU and optimal page replacement.

  4. Data modelling for solution construction

    From business rules to a schema: conceptual, logical and physical models, entities, attributes, relationships with cardinality and participation, the rules that map an ER diagram to tables, and embedding against referencing in a document store.

SKU 1.3 · Software development

  1. Systems engineering concepts

    Software as part of a larger system: emergent properties, the system life cycle, requirements and interfaces, the V-model pairing of design and verification, trade studies, and availability of series and redundant designs.

  2. Standards in software construction

    Why construction follows standards, the coding standards a team adopts (style, safety and secure-coding rules), and the ISO/IEC/IEEE process and quality standards — 12207, 25010, 730, 1012, 29119 — with the product-quality model used to state and check quality.

  3. Life-cycle models, construction planning and measurement

    Waterfall, V, incremental, spiral and agile models and how to choose among them; planning construction; and the measurements used to steer it — size in KLOC, cyclomatic complexity, defect density and basic COCOMO effort and schedule.

  4. Construction languages, coding, testing, reuse and quality assurance

    The kinds of construction language, defensive coding, the test levels, black-box design by equivalence partitions and boundary values, white-box statement and branch coverage, reuse and its risks, and the reviews and metrics that assure quality.

SKU 1.4 · Design planning and construction

  1. Engineering design and design by contract

    The engineering design process applied to software, the principles that make a design good (abstraction, information hiding, low coupling, high cohesion), and API design by contract: preconditions, postconditions, invariants, Hoare triples, and the rule for overriding a contract.

  2. State machines, tables and grammars in construction

    State-based construction with finite-state machines, table-driven code that replaces nested if chains, and grammar-based input processing: BNF, derivations, precedence and a recursive-descent parser.

  3. Software development environments and toolchains

    What an IDE bundles, the path from source to running program (compile, link, load), build and dependency tools, version control with Git, continuous integration, containers and the dev–test–production chain, and semantic versioning.

  4. Distributed, real-time and concurrent system design

    What changes when a system spans machines (latency, partial failure, no shared clock), the middleware that hides heterogeneity — RPC, message queues, publish–subscribe, REST — and real-time scheduling with the rate-monotonic bound and response-time analysis.

SKU 1.5 · Software construction tools

  1. Debugging, profiling and parallel performance

    A systematic debugging method and the tools that serve it (debuggers, logging, bisection), profiling to find where time goes, and the parallel and distributed speedup limits that decide whether more processors help: speedup, efficiency and Amdahl's law.

  2. Web, mobile and desktop development

    How web applications work (HTTP, REST, status codes, MVC frameworks on the server and the client), how mobile apps differ (native against cross-platform, the app life cycle, offline use), where desktop frameworks fit, and how to choose among them.

  3. GUI design, HCI and event-driven programming

    The HCI foundations behind a usable interface — usability as defined by ISO 9241-11, Nielsen's heuristics, Fitts's law for pointing time — and how GUIs are built: the event loop, callbacks, layout managers and GUI builders.

MORE SOFTWARE ENGINEERING GUIDES

All study guides

Read the full guide beside your practice questions.

Open the app