Summaries

Lists of things to remember

The Study Design's Dot Points and Glossary define a lot of lists of things that are reasonable, but specific to this course.

Problem Solving Methodology [PSM]

Order matters, so just learn it! ADDE, not DEAD!

• Analysis - Requirements, Constraints, Scope

• Design - Solution Design, Evaluation Criteria

• Development - Manipulation, Validation, Testing, Docs

• Evaluation - Strategy, Report

Information System [Glossary]

The following list are the things that interact to create, control and communicate ideas and data in digital solutions

• hardware

• software

• network components (digital systems)

• data

• processes

• people

Development Model Approaches [U3O2]

AKA Software Development Life Cycle (SDLC). In our study design:

• waterfall - proceed through the PSM in a linear fashion. Good for large & well defined projects. Risky because inflexible, hard to go back and change requirements or design while developing.

• agile - acknowledge requirements are hard to determine, quick to release first version, cycle quickly though stages, continually get feedback from actual users and usage. Does not provide clear timeline for production ahead of time.

• spiral - cycle through stages with a focus on stability and security. More expensive than agile, good for ongoing evolution of critical software.

Measures of Effectiveness [Glossary]

This list is for a digital solution (measures for information management strategies and networks are slightly different). Note, there are other measures, this is just the listed ones by VCAA

RU A CAR CAT? - thanks to Vic Farrell for the Mnemonic!

• readability / clarity [combined]

• usability [note the e dropped in 2020...]

• attractiveness

• completeness

• accessibility

• relevance

• communication of message

• accuracy

• timeliness

Summaries

Effectiveness vs Efficiency [Everywhere!]

See the Glossary for official VCAA definitions

• Effectiveness is how good a solution/plan is at doing what it is meant to do

• Efficiency is about how much ____ it takes doing it

  • time (processing time or user time),

  • space (memory, hard-disk, etc...),

  • cost (money, effort or other resources)

• Effectiveness & Efficiency is a concern for

  • Evaluating Designs U3O2KK7

  • User Experience (incl User Interfaces) U3O2KK12

  • Algorithms & Software Solutions U4O1KK6, U4O1KK12

  • Planning U4O1KK11, U4O1KK12

Functional vs Nonfunctional Requirements [U3O2]

• Functional Requirement = What the solution does

• Nonfunctional Requirement = How the solution does it

• Use Cases and Functional Requirements are similar, but UCs are from the user's point of view and FRs from the solution's point of view and include things that are done by the system to support the UCs.
• Nonfunctional Requirements and Evaluation Criteria are similar. NFRs ... hmmm

Linear vs Binary Search [U3O1]

• Linear: steps through a data structure checking each element

• Binary: Requires data to be sorted. Checks middle element and "discards" half that doesn't contain the element. Repeat

• Pros/Cons

  • Linear will work with unsorted data, but time grows proportional to the size of the data set (8x size → 8x time)

    • Worst case: # Comparisons = len(data) = n

  • Binary grows only logarithmically (8x size → 3x time), but requires data to be sorted (slow)

    • Worst case: # Comparisons = ⌈log₂(n+1)⌉ = ⌊log₂(n)+1⌋

  • Linear for one-off search. Sorting+Binary is worth investment only for multiple searches.

  • Linear search also better for small data sets - less setup cost

Selection Sort vs Quicksort [U3O1]

Other sorts exist & in real life, most algorithms are hybrid

• Selection Sort: Linearly finds smallest(largest) element and swaps into left(right)-most position & locks it in place. Repeat with remaining elements until all sorted.

• Quicksort: Chooses pivot and makes swaps to move all smaller elements to left and greater to the right. Repeat on left & right partitions until everything is sorted.

• Pros/Cons

  • Selection sort has a low overhead, so good with small data

  • Selection sort grows quadratically (8x size → 64x time)

  • Quicksort grows log-linearly (8x size → 3x8x time)

XML vs CSV & other "plain text" formats [U3O1]

• XML = eXtensible Markup Language

• CSV = Comma Separated Values (TSV & DSV for Tab & Delimiter separated values)

• JSON (not in study design) = JavaScript Object Notation (looks like a Python dict or a list of dicts)

• Advantages of XML [See slides for more]

  • Clearly linked field names (tags) and data in individual elements

  • Easy to add and remove elements without breaking the file structure (especially compared with DSV)

  • Clean separation of data from metadata (content of elements vs attributes & comments)

  • Naturally Nestable Data Structure. Can be thought of and accessed as a Tree

  • Human readable Plain Text format (c.f. binary formats)

• Disadvantages of XML

  • "Angle bracket tax" makes it slower to parse for both computers and humans. Also makes files larger which affects their storage and transmission.

  • JSON (& similar formats, e.g., YAML) have most of the advantages of XML without the angle brackets

Data Types and Data Structures [U3O1]

• Types: "atoms" of data (made out of the "subatomic" bits)

  • Numeric: Integer, Floating Point Numbers

  • Text: Character, String

  • Boolean

  • (Others: Date, Date-Time, Decimal, etc...)

• Structures: "Molecules" or "Crystals" of the "atoms" of data

  • Array [U3O1]

    • fixed number of elements of a single type indexed by their position: 0, 1, 2, ...

    • In Python we usually use a List (which is actually a Dynamic Array of Object References) although C Arrays and Numpy Arrays are available.

  • Queue [U3O1]

    • A First-In-First-Out data structure based on an array

    • Used in things like task queue, print queue, graph and expression parsing algorithms.

  • Stack [U3O1]

    • A Last-In-First-Out data structure based on an array

    • e.g., undo/redo stack, call stack in running programs, stacks in algorithms such as evaluating stack-based languages such as Reverse Polish Notation and BibTeX Style Language.

  • Linked List [U3O1]

    • An alternate way of storing a sequence of data

    • Traditionally faster at insertion and deletion than arrays, but lose the ability to quickly read any element.

    • [Item 0: Link to 1] [Item 1: Link to 2] ... [Item n: Null]

  • Record [U3O1]

    • varying data types, field index

    • (Named tuples in Python, or a list/dict/object with agreed conventions, or the newer data class)

    • An array of records is like a database table

  • Associative Array [U3O1, used to be in U4O1]

    • values indexed by a key

    • Like a dictionary in Python

    • Usually implemented as a hash table

• Objects

  • Objects are a data structure contain both Attributes (data) and Methods (functions/procedures)

  • In Python everything is an object (think about the string & list methods, turtle instances, GUI elements, etc...) even int!

  • Objects are usually instantiations of some Class (template)

    • "Classes are the cookie-cutters, objects are the cookies."

  • In our course, we only created new classes for GUI elements

• Database

  • Not explicit in SofDev course, but records are in the course

  • DB = a group of tables. Each table is made out of a number of records (rows) that contain a fixed set of fields (columns)

  • Fields are things like ID, Name, Age, etc... (usually fixed size)

  • A record is the data in these fields that pertain to one object/person. C.f. a person's medical or criminal record

  • Compare to a spreadsheet. It can have multiple sheets (tables). The Columns (fields) contain one type of data and the Rows (records) contain the data relating to one object

  • The tables are often cross referenced to form a relational database. This reduces duplication increasing storage efficiency.

  • The data is often indexed to further increase speed

  • Databases have account protected levels of access, backups and sometimes encryption as measures of data security

Network Technology

• switch vs hub vs router vs modem

• The TCP/IP stack

• HTTP vs HTTPS (the S is still in the curriculum)