Ethics in Professional Practice

What Ethics Is, and Why It Is Taught exam

Most of this subject is about getting software built on time, on budget and to the right quality. This Part asks a different question: should it be built that way, and what do you do when the fastest route hurts someone? Software now runs hospitals, aircraft, elections and bank accounts, so the people who build it make decisions that reach far beyond the project team. Ethics is the discipline of making those decisions well.

The phrase to notice is "irrespective of law". Ethics is wider than legal compliance. Plenty of behaviour is perfectly legal and still unethical: telling a client that a half-built feature is finished breaks no statute, but it deceives someone who is relying on you. The figure shows the relationship. The law sets a floor, and a professional code such as the ACS Code (introduced in 9.3) asks for a good deal more above it.

Why it is in a software management subject

Two professional bodies accredit software engineering degrees in Australia: the Australian Computer Society (ACS), the professional association for ICT (information and communications technology) workers, and Engineers Australia. Both require ethics to be taught. This subject is the starting point, and later project subjects apply it with real clients. Engineers Australia has its own code, which asks members to demonstrate integrity, practise competently, exercise leadership and promote sustainability, but this course uses the ACS Code, so that is the one to quote in the exam.

The ethical challenges graduates face

The research cited in the W08 lecture explains why ethics has to be taught rather than assumed. Software engineering graduates often feel ill-prepared for the ethical issues they meet at work. Worse, they struggle even to recognise that they are facing a dilemma, let alone navigate it. Part of the difficulty is that different people may judge the same act differently, and culture has a large influence on how they judge it. A survey of over 2,300 ACS members (Al-Saggaf & Ceric 2017) found that many had faced ethical problems at work, such as bullying, and that many professionals do not realise when they are in an ethical situation at all.

Micro-Ethics, Macro-Ethics and Where Issues Arise exam

If ethics only meant headline scandals, most developers would think it had nothing to do with them. The distinction between micro- and macro-ethics fixes that misconception: it shows that ethics happens at your desk, every day, and that the headline scandals are made out of exactly those everyday choices.

The lesson the slides draw is that ethics is not only for big issues. Micro-ethics matters because it shapes the processes and data we use and the products we make. In fact you already practise it whenever you deal with risk management, product quality and safety, intellectual property, environmental impact and security, all topics from earlier Parts (Part IV on risk and Part VII on quality). The two scales are also connected: macro-ethical disasters usually grow from many unchallenged micro-ethical decisions.

Eight contexts where ethical issues arise

To help you recognise an ethical issue when you meet one, the W08 slides list eight contexts in which they commonly arise. Think of them as a checklist to run over any system you build or any scenario you are given: if a feature touches one of these, slow down and ask who could be harmed.

The ACS Code: Preamble and Four Values exam

Knowing that something feels wrong is not enough in a professional setting; you need a shared standard you can point to when you push back. A code of professional ethics is that standard: a public statement, by a profession, of what its members owe to others. The subject uses the ACS Code of Professional Ethics, adopted into the ACS National Regulations (NR4) on 14 March 2023.

The preamble: the responsibilities of an IT professional

The preamble explains why the Code exists, and in doing so it sets out the responsibility that comes with being an IT professional. Read its ideas as a chain of reasoning:

1. Purpose. The ACS "strives to protect the public interest" through an ethical, trustworthy ICT profession.
2. The imbalance. Society depends on ICT but has limited understanding of it or control over it. Patients cannot inspect a hospital's database; pilots could not inspect MCAS.
3. Therefore, responsibility. Because professionals have specialist knowledge that others lack, they carry a responsibility for those others.
4. What makes a professional. It is how you apply your skill: professionals "promote good while working within ethical constraints".
5. Beyond the law, and not exhaustive. The Code goes beyond legal requirements, and it does not list every situation, so members must use judgement guided by its values.

Point 5 matters in the exam. No clause says "do not build a fake app for inspectors", yet the Uber case in 9.6 clearly breaches the Code. You are expected to reason from the values to the situation, not to look for a rule with the situation's name on it.

Four core values under three headings

The Code names four core values: honesty, trustworthiness, respect for others and respect for the profession. They sit under three numbered headings, 2.1 Honesty, 2.2 Trustworthiness and 2.3 Respect, and Respect is split into 2.3.1 Respect for Others and 2.3.2 Respect for the Profession. That is why the T08 quiz speaks of "three primary values" (Honesty, Trustworthiness, Respect) while the Code lists four. Both counts describe the same structure. A mnemonic for the four is H-T-R-R.

Every Clause, Letter by Letter exam

In an exam answer, "this is dishonest" earns little; "this breaches Honesty 2.1(b), not misrepresenting a capability by omission" earns marks, because it shows you know exactly which duty the facts break. So the clauses need to be at your fingertips, and you will want this page on your A4 notes sheet. The staff's practice-exam answers cite clauses as value + letter, for example "Honesty (b)" or "Trustworthiness (d)"; this site also uses the numbered form 2.1(b) and 2.2(d). Either is fine, as long as the value and the letter match the 2023 Code.

The full clauses

The table gives every clause as the guide words it, with the form to cite it in an answer. Read each value's one-line purpose first: it tells you what the clauses under it are protecting.

A few terms in the clauses deserve a gloss. Misrepresentation by omission (2.1(b)) means creating a false impression by leaving something out: demoing a dashboard without mentioning that its numbers are faked is a lie even if every sentence you say is true. A conflict of interest (2.2(b)) is a situation where your personal interest could pull against your duty, such as recommending a vendor you hold shares in. Undue influence (2.2(b)) is pressure, typically from a boss or client, to act against the Code. Intellectual property (IP) (2.3.1(g)) is creations of the mind that the law protects, such as code, designs and trademarks.

Fast lookup: from a scenario feature to the clause

When you read a scenario, you will notice features such as "the PM told them to ship it" or "the data was medical". The guide's lookup table turns each feature into the clauses to cite. The matrix draws it so that you can see at a glance which value each feature belongs to.

Older Codes and Other Codes

You will meet other ethics codes in past papers, in T08 and in readings, and it is easy to mix their headings into a 2023 answer. This section shows how the older ACS Code and the IEEE-CS/ACM code line up with the 2023 Code, so you can translate rather than confuse them.

The pre-2023 ACS Code: six values

Before 2023 the ACS Code had six values: the primacy of the public interest, the enhancement of quality of life, honesty, competence, professional development and professionalism. None of them disappeared; each one maps onto parts of the 2023 Code, as the figure shows.

T08's comparison: the IEEE-CS/ACM Software Engineering Code

T08 compares the old ACS headings (Priorities, Competency, Honesty, Social Implications, Professional Development and IT Profession) with the IEEE-CS/ACM Software Engineering Code, written jointly by the two largest international computing societies. That code has eight principles:

Despite the different headings, the codes share the same core. In all of them the public interest comes first, and all of them value honesty, competence and quality, confidentiality, learning, and supporting the profession. So if you know the ACS Code well, you already understand the others.

Three Case Studies exam

The Code is abstract until you see it broken. The W08 slides work through three real cases, and each is set out below in the same four parts: the facts, what went wrong, the breaches the slides identify (one under every value), and what professionals should have done. That four-part shape is also a good shape for your own exam answers.

Handling an Ethical Dilemma exam

An ethical dilemma is a situation where the options pull in different directions, typically your instructions or the deadline against your duty to others. Faced with one under exam time pressure, it is easy to write a vague paragraph about "being ethical". The guide's seven-step method stops that: it makes you establish the facts, find everyone affected, name each issue precisely, attach a clause, compare real options and then act. Scenario questions reward exactly this systematic approach.

Escalating in proportion: the ladder

Step 7 says "escalate proportionately". That means climbing an escalation ladder one rung at a time, starting with the mildest step that might fix the problem and going higher only if it fails. Each rung brings in someone with more power to stop the harm, at a higher cost to relationships.

Common traps

The Medic Case: A Worked Ethical Analysis

The tutorials' running case is Medic: a virtual-reality surgical simulator built for the surgeons of RVEEH, a hospital facing a shortage of quality cadavers on which trainee surgeons can practise cochlear-implant and temporal-bone surgery. Earlier Parts used it for business cases, risk and planning. Tutorial T08 adds an ethics addendum in which the project goes badly wrong, and then applies the seven-step method of 9.7 to it. This section follows that analysis step by step; it is the best model you have of a full-length answer.

Step 1: the facts, as they unfolded

Step 2: the stakeholders, and who is harmed

A stakeholder is anyone who affects or is affected by the project (Part V). The T08 analysis lists them all, and the map groups them by how they are harmed. The most important point is the first column: the people harmed most were never in any meeting.

Steps 3–4: eight issues, their clauses, and why they matter

T08 Activities 1–2 identify eight issues. Each row names one issue, the 2023 clauses it engages, and its significance, which is the "why it matters" half of step 4.

Notice issue 3: it is not only the PM who breached the Code. Team members who were overruled and then said nothing breached 2.1(c) themselves. The Code applies to every professional on the project, not just the one in charge. The Notifiable Data Breaches (NDB) scheme in issue 6 is the part of Australia's Privacy Act that requires organisations to notify affected people and the regulator of serious data breaches.

Steps 5–6: the options before delivery, and the decision

The decision is B, for four reasons, each tied to the Code:

1. Honesty (2.1(a)–(b)) requires disclosing the dashboard's true status.
2. Clauses 2.2(e) and 2.2(g) require raising the skills constraint so that scope can be renegotiated, which is ordinary agile descoping (Part VI).
3. Containing and reporting the breach at once lets RVEEH meet its notification duties and lets patients protect themselves (2.2(a), 2.3.1(a)).
4. Team members who are overruled should escalate in writing to senior management and refuse to misrepresent the feature (2.1(c), 2.2(b)).

Step 7: prevention (T08 Activity 3)

Fixing this project is not enough; step 7 asks what would stop it happening again. T08 proposes three measures.

Synthetic test data is realistic-looking data generated artificially, so a leak exposes nobody; de-identified data is real data with anything that identifies a person removed.

The Exam Answer Pattern exam

Knowing the Code is half the job; the other half is writing it down in the shape the markers reward. The official Practice Exam Guide, posted by the subject staff on Canvas, includes an ethics scenario with the staff's own example answer. Its structure is the pattern to copy, so this section takes it apart.

The SecureTrack question

The scenario concerned SecureTrack, a company supplying facial-recognition technology. The staff's example answer (with variations accepted) sets out each issue in three parts:

1. a name for the issue;
2. a description tied to the scenario, using its facts; and
3. the relevant ACS values, cited by value and clause letter, such as "Trustworthiness (d)", which is 2.2(d) in this site's numbering.

The stepper builds the staff's answer one issue at a time.

One issue written out in full

Each issue earns its marks the same way: it names a problem, proves it with a fact from the scenario, and attaches the clause that fact breaches, saying why. Written out in full, the first issue might read as follows; compare it with the weak version.

Practise the pattern

Legal and Contractual Aspects older exam topic

This material is not in the 2026 slides, but past exams of the predecessor subject (433-443) tested it, and several of their questions depend on it. It answers practical questions every developer eventually asks: who owns the code I write, can I reuse it at my next job, and what kind of contract am I on?

Copyright in software (Australia)

Copyright is the legal right to control the copying of a work. Under the Copyright Act 1968 (Cth), a computer program is a literary work, like a novel, and both its source code (what programmers write) and its object code (the compiled form) are protected.

Because copyright protects expression, not ideas, writing equivalent code independently is lawful, whereas copying a substantial part of someone's code is infringement. You may reimplement a sorting algorithm you learned at a previous job; you may not copy that job's source file. Australia also differs from the USA in two ways: it has no registration step (the US requires registration before a US author can sue), and it has the narrower "fair dealing" exceptions instead of the US's broader "fair use".

Who owns the code?

The default owner depends on the circumstances in which the code was written. The tree gives the four cases, with the sections of the Act the guide cites.

Moral rights (added as Part IX of the Act in 2000) are the individual author's personal rights: the right of attribution (to be named as author), the right against false attribution, and the right of integrity, meaning no derogatory treatment of the work. They cannot be transferred and survive even when the employer owns the copyright, although the author can give written consent to acts that would otherwise infringe them.

Contract types

When a client pays a developer to build software, the contract decides who carries the risk that the work costs more than expected. The two classic types put that risk on opposite sides.

A contingency premium is the extra the contractor adds to a fixed price to cover the risk it is taking on; a variation is a formal, priced change to a fixed-price contract's scope.