HSC Software Engineering cheat sheet

Software development life cycle stages: requirements analysis, design, implementation, testing, deployment, maintenance; each stage produces documented outputs consumed by the next.

Waterfall model: sequential stages with sign-off gates; requirements frozen before design begins, so late changes are costly and rework is high.

Agile/iterative model: short time-boxed iterations producing working increments; requirements evolve through continuous stakeholder feedback rather than upfront freezing.

Spiral model: iteration driven by risk analysis; each loop passes through objective setting, risk assessment, engineering and evaluation, suited to high-risk projects.

Prototyping model: a throwaway or evolutionary prototype clarifies ambiguous requirements before full construction; risk is scope creep if the prototype is mistaken for the product.

Requirements are functional (what the system does) or non-functional (performance, security, usability, reliability); non-functional constraints shape architecture.

Feasibility study assesses technical, economic, legal and operational viability before commitment; a failed feasibility check terminates or rescopes the project.

Verification asks whether the product was built correctly against specification; validation asks whether the correct product was built for the user's need.

Maintenance types: corrective (fixing defects), adaptive (environment change), perfective (enhancement), preventive (refactoring to reduce future decay).

Three control structures suffice for all algorithms: sequence, selection (if/case) and iteration (pre-test while, post-test do-while, counted for).

Structured programming decomposes a problem top-down into modules with single entry and single exit; cohesion should be high and coupling low.

Pass by value copies the argument; pass by reference passes the address, so the callee's changes are visible to the caller.

OOP encapsulation bundles state and behaviour and hides internals behind a public interface, so internal representation can change without breaking callers.

Inheritance expresses an is-a relationship; a subclass inherits members and may override methods, enabling polymorphism through dynamic dispatch.

Polymorphism: one interface, many implementations; the method executed depends on the runtime object type, not the declared reference type.

Abstraction exposes only essential behaviour; an abstract class or interface defines a contract that concrete classes must fulfil.

Method overloading differs by parameter list at compile time; overriding replaces an inherited method with the same signature at runtime.

Standard algorithms: linear search O(n), binary search O(log n) on sorted data, bubble/selection/insertion sort O(n^2), merge sort O(n log n).

Array: contiguous storage, O(1) index access, O(n) insertion or deletion in the middle; fixed size in static languages.

Linked list: nodes holding data and a pointer; O(1) insertion or deletion given the node, O(n) search, no random access.

Stack is last-in-first-out (push, pop, peek); queue is first-in-first-out (enqueue, dequeue); both support O(1) core operations.

Hash table: average O(1) lookup, insertion and deletion; collisions resolved by chaining or open addressing, worst case O(n).

Binary search tree: average O(log n) search, insertion and deletion; degenerate (unbalanced) trees degrade to O(n), balanced trees such as AVL restore O(log n).

Big-O describes the upper bound of growth with input size n; constants and lower-order terms are discarded, so 3n^2 + 5n becomes O(n^2).

Common growth order from best to worst: O(1) < O(log n) < O(n) < O(n log n) < O(n^2) < O(2^n) < O(n!).

Space complexity counts auxiliary memory beyond the input; an in-place algorithm uses O(1) extra space.

Recursion requires a base case and a recursive case that moves toward it; each call consumes stack frames, so depth is bounded by memory.

Design modelling tools: context diagram (system boundary and external entities), data flow diagram (processes, data stores, flows), entity-relationship diagram (entities, attributes, relationships).

UML structural diagrams: class diagram shows classes, attributes, methods and relationships (association, aggregation, composition, inheritance).

UML behavioural diagrams: use case diagram captures actors and goals; sequence diagram shows time-ordered message exchange; activity diagram models workflow.

Use case description records actor, preconditions, main success scenario, alternate flows and postconditions; it drives test case derivation.

User-centred design cycle: identify user needs, specify context of use, produce design solutions, evaluate against requirements, iterate.

Wireframes are low-fidelity layout sketches; prototypes range from low-fidelity paper to high-fidelity interactive mock-ups used for usability testing.

Usability heuristics include visibility of system status, user control and freedom, consistency, error prevention, recognition over recall and clear feedback.

Accessibility principles (perceivable, operable, understandable, robust) require text alternatives, keyboard operability, sufficient contrast and semantic markup.

Design principles: separation of concerns, modularity, information hiding, single responsibility, and avoiding duplicated logic across modules.

Client-server model: the browser (client) sends an HTTP request; the server returns a response with a status code, headers and body.

HTTP methods: GET retrieves, POST submits data creating state, PUT replaces, PATCH partially updates, DELETE removes; GET and HEAD should be safe and idempotent.

HTTP status classes: 1xx informational, 2xx success, 3xx redirection, 4xx client error (400, 401, 403, 404), 5xx server error (500).

HTML provides structure and semantics, CSS presentation, JavaScript behaviour; server-side code generates dynamic responses and accesses the database.

SQL injection is prevented by parameterised queries or prepared statements, not by string concatenation or client-side validation alone.

Cross-site scripting is mitigated by output encoding and escaping, input validation, and a Content-Security-Policy header.

HTTPS uses TLS to provide confidentiality, integrity and server authentication; passwords must be stored as salted hashes of a slow key-derivation function.

Defence in depth layers controls: validate input on both client and server, enforce authorisation server-side, apply least privilege, log and monitor.

Authentication verifies identity; authorisation decides permitted actions; session tokens must be random, transmitted over HTTPS and expire.

Project constraints form a trade-off triangle: scope, time and cost, with quality affected by changes to any of the three.

Work breakdown structure decomposes deliverables into tasks; a Gantt chart shows task duration and overlap; a PERT/critical path network identifies the longest dependency chain.

Critical path is the longest sequence of dependent tasks; its length equals the minimum project duration, and slack (float) is zero on that path.

Estimation techniques include analogous (similar past project), parametric (effort per unit, e.g. function points) and three-point PERT (optimistic + 4 x likely + pessimistic) / 6.

Version control records commits with unique identifiers; branches isolate work, merges integrate it, and conflicts arise when the same lines change.

Team roles and communication: daily stand-up, sprint review and retrospective; documentation and coding standards reduce integration risk.

Testing levels: unit (single module), integration (interfaces), system (whole system against requirements), acceptance (user sign-off); regression re-runs after change.

Mechatronic system loop: sensors acquire data, a controller (microcontroller) processes it with an algorithm, actuators act on the physical system, feedback closes the loop.

Embedded constraints: limited memory and processing, real-time deadlines, interrupt handling, debouncing of noisy sensor input, and fail-safe behaviour on error.

Copyright protects the expression of software (source and object code) automatically on creation; it does not protect the underlying idea or algorithm.

Software licences: proprietary (restricted use), freeware (free use, source closed), open source (source available with rights defined by the licence terms).

Permissive open-source licences allow reuse with attribution; copyleft licences require derivative works to be distributed under the same terms.

Patents may protect novel, non-obvious technical processes for a limited term; trade secrets protect confidential algorithms without registration or expiry.

Privacy legislation (for example Australia's Privacy Act and Australian Privacy Principles) governs collection, use, disclosure, security and access to personal information.

Intellectual property in employment: work created within the scope of employment generally belongs to the employer unless the contract states otherwise.

Professional codes of ethics require honesty about competence and product limitations, avoidance of conflicts of interest, and prioritisation of public safety.

Social impacts include automation-driven job displacement, algorithmic bias from unrepresentative training data, and the digital divide in access to software services.

Accessibility and inclusion are legal obligations in many jurisdictions; failure to provide equivalent access can constitute discrimination.