FIT9017: Week 6

A bit of a late entry for last weeks classes. The lecture was once again presented by Michael Smith and this week we ran through a number of Java (and programming) basics.

  • Library Classes – Java API, API documentation is generally the first google results when you search a method/data type + ‘JAVA’
  • Collections – Arrays and ArrayLists is a types of collection
  • Dynamic Arrays – called ‘ArrayList ‘ in Java (there may be other collections in Java? but ArrayList the only one I know of). Much better than arrays in that the size is dynamic and objects can be stored and all iteration and sorting is pretty much already optimized. Java’s for-each loop – for(Elementtype element : collection) – for (String note : noteBook)
  • Loops – Some types of loops in Java
    • for(i = 0; i < isbn.Length(); i++) {}
    • while (scanner.hasNext()) {}
    • do {} while (inChar != ‘X’);
    • for (String note : noteBook) {}


FIT9018: Week 6

Process Management was the theme of Andy’s lecture this week. Specifically, a definition of processes and how they intersect with the CPU, Process Control and Process Scheduling Algorithms.

  • Processes – Simply a program execution.
  • Process Control –  an import part of a multi-tasking O/S (modern O/S’s and CPUs enable multithreading)
  • Information about processes is store in the Process Table by the O/S

The lecture glazed over the process management system stopping at:

FIT9019: Week 6

Manoj presented a lecture focused on the Structured Query Language [SQL] upon our return from the easter break.  The tutorial was closely tied to the lecture enabling us to work through the code examples shown. With that in mind, shown below are the types of queries covered in the lecture and tutorial with an example and description:

CREATE – create tables (or Databases), specifying the table name and column values. Constraints can be applied to the attributes such as Primary Key, Foreign Key, Default value and Not Null however it is probably easier to add constraints using the ‘ALTER TABLE’ query. CREATE is part of DDL.


FIT9030: Week 6

After a weeks break David presented an introductory lecture on the Object Oriented Analysis Phase [PADIS]. As we had already covered Class Diagrams in the previous lecture we moved straight into Use Case Modeling. All of the diagrams used in the Object Oriented Analysis phase (and discussed in this week) are members of the Unified Modeling Language:

Source: Paulo Merson

The Diagrams/Models covered in the Object Oriented Analysis phase are: (more…)

FIT9017: Week 5

This weeks lecture was presented by Michael Smith and targeted an introduction to testing and debugging. Initially was discussed when testing should begin in the Software Development process, the Design phase. As soon as the solution has been designed then tests for that solution can and should also be designed. During the implementation phase testing should be conducted as soon as compilation is complete. Documentation was also recognized early in the lecture as a key aspect of testing and debugging.

Pearl Of The Week: Types of errors in Programs:

  • Syntax Errors -> Mistakes in spelling or unclosed parenthesis etc. Compiler will find these errors, preventing completion of compilation until they are amended.
  • Execution/Run Time Errors -> Null Pointer Exceptions, Attempting to access arrays outside of bounds. Occurrence of these errors in Java will result in relevant exceptions thrown.
  • Logic Errors -> Project has been compiled and runs without error but behavior is not as expected.

We then explored some examples of how important testing and debugging is by reviewing some examples where the process was not done correctly.


FIT9018: Week 5

5th Week Lecture – Virtual Memory

Andy Cheng’s lecture this week was a whirlwind tour over the definition and major issues of Virtual Memory.


Virtual Memory enables programs running on an O/S to interact with what to them is a contiguous memory source. That is, program instructions and resources can be loaded to Virtual Memory addresses and a program can easily access them with logical addresses. The illustration above shows a simplified concept of Virtual Memory.

There are two major implementations for Virtual Memory:


FIT9019: Week 5

Database Design III – Boyce Codd Normal Form, presented by Manoj Kathpalia, alerted me to the value of revising the text book. It seems I do not have a clear grasp of some of the characteristics of each Normal form. Must ensure to remember that for a relation to be in BCNF every functional dependency must be a candidate key, this is best illustrated graphically:

source: Database Systems, Cornell and Rob, 2009

So, although the iPhone pic of the text book is a bit blurry, it can be seen that a sneaky dependency from a non-candidate key attribute to another attribute will cause update anomalies and refrain the table from achieving BCNF.

Most of the lecture was focused on ensuring that everyone understood the process of 1NF -> 2NF -> 3NF -> BCNF. I have already made a detailed post on this process which can be viewed here.

Our tutorial was 2 hours of toying with MicroSoft Access. I came into it with an open attitude, but after about 90 minutes I was lost in the world of GUI fluff that is Access. I am sure that with time it is something that one could learn to use with more efficiency, but with superior performing Open Source alternatives (ie: LAMP bundle) I cannot ever see myself working on an Access database by choice.

Pearl of the Week: Avoid Microsoft Access.

I plan to review the text book over the next week to ensure that my current perception of each aspect of the subject is in fact valid. Particularly important is to rote learn definitions for 1NF, 2NF, 3NF, BCNF, Functional Dependency, Transitive Key Dependency(3NF), Partial Dependency (2NF) and Non-Key Partial Dependencies (BCNF).

FIT9030: Week 5

Week 5 is here and we started the week with the lecture, tutorial double of Systems Analysis and Desgin(by David Grant). I missed the first 10 minutes of the lecture, which I guess involved some revision of the previous weeks lecture on Analysis Models.

The week 5 lecture titled “Traditional or Structured Approach to Analysis”… I think the title should be amended to ‘Structured or Object-Oriented Approach to Analysis“.

Source: FIT9030 week 5 lecture slide


FIT9017: Week 4

Week 4’s lecture by Judy got slightly deeper into the concept, design and implementation of objects. Again, I am finding that these lectures are moving very slowly and feel that prospective students should be given a chance (if they want) to demonstrate that they are not complete novices. However, this from an administrative point of view would probably be impossible and running through an introductory class will ensure that all the basic concepts (and more importantly, conventions) are clearly understood. So the only thing to do is get good marks and have a point to argue from for next semester.

The lecture started of defining the terms Abstraction and Modularization referencing their relevance to programming with a simple clock program. I felt this was valuable but could have been so much more valuable if we had gone a few steps further and show the practical applications for modularization and decoupling by making the clock program work and re-using the modules in different examples. In this example, Class Diagrams and Object Diagrams where covered (straight out of bluej).

Next came Primitive Types vs Object Types, specifically the differences in memory allocation (objects reference). I guess this will be a more interesting point when programming in C and the Garbage collector does not destroy unreferenced variables. Formal Parameters, Actual Arguments, Internal and External method calls followed, these were all consistent with what I have seen previously  and now feel very intuitive. The only point where I felt uncomfortable was where methods contained local variables with the same name as their Formal Parameters, necessitating the need for this.variable = variable notation. Seems much easier to me to avoid double naming.

The really key topic covered in the lecture and in the tutorials was the coding conventions:

I need to update my existing habits to meet these standards (definitely a good thing).. means alot more indenting.

I will start reading through the text book more for this subject and continuing my own Java development. This should suffice until next semester or the 3rd when I hope we have the chance to do some challenging implementations.

Pearl of the Week: My first attempt at using Java Objects and a MySQL DB, hope to learn how wrong it is in the near future.

Constructs a Book with bookID.
@param ID the Book ID number

public Book(int ID)
throws SQLException, IOException, ClassNotFoundException
Connection conn = SimpleDataSource.getConnection();
stat = conn.prepareStatement("SELECT * FROM books WHERE book_ID = ?");
stat.setInt(1, ID);
ResultSet rs = stat.executeQuery();;
title = rs.getString("title");
author = rs.getString("author");
total = rs.getInt("total_pages");
current = rs.getInt("current_page");
path = rs.getString("path");
date = rs.getString("date");
genre = rs.getString("genre");
notes = rs.getString("notes");

Haha there already a few bit there that are breaking format conventions already…. D:

Note, for some reason the code box is automatically removing indentation. The code box was made using a WordPress plugin:

FIT9018: Week 4

This weeks lecture was a continuation of ‘Operating System II: File Management”. Most of the concepts covered in this weeks lecture I had looked at in last weeks review.

Some of the new points introduced were:

  • When a file is accessed it has four id’s (I assume an example is real and sudo):
    • a real user id
    • an effective user id
    • a real group id
    • an effective group id
  • Standard Input, Output, Error – Every time a shell is started. 3 files are opened automatically:
    • stdin, (keyboard), 0
    • stdout, (screen), 1
    • sterr, (screen), 2
  • Example of how inode numbers and logical directory structures work.
  • How rwx Permissions work with directories: (Pearl of the Week)
    • Read- Processes can list names and subdirectories within directory
    • Write- Processes can alter the directory (create and remove files). To modify files write permission must be applied to the file.
    • Excecute- Allows the user to cd into the directory. To open a file or excerpter a program a user must have execute permission on all directories leading to the files absolute path name.
  • Hard and Soft(Symbolic) Links
  • Locks (not covered in detail yet)

Pearl of the week: vi/vim text editor

In the tut we worked with vi/vim text editor which is a tool I had struggled with before and had never bothered to read the tutorials on.

It turns out that it is a damn good editor as it is very very quick and easy once one becomes even moderately sufficient (2-3 hr tutorial). One of the primary advantages is that it runs within a command prompt environment so can be used via SSH with ease.

Some of the handy commands learnt in the tutorial are:

  • i -> insert mode
  • : -> comand mode
  • esc -> back to normal mode
  • CTRL + G -> End of the doc
  • /prase -> find phrase
  • n -> next phrase down
  • N -> next phrase up
  • :%s/word1/word2/gc -> replace all word1 with word2, gc adds confirmation for each occurance
  • u -> undo
  • d -> delete
  • put -> put was what just deleted
  • v -> visual select
  • w -> word (dw -> delete word)
  • $ -> end of line (d$ delete from cursor to end of line)
  • :set tabstop=2 -> set tab distance to 2
  • :set number -> show line numbers
  • :set nonumber -> hide line numbers
  • :1,4d -> delete lines 1,2,3,4

There are a great deal many useful examples of these which i shall add in as I use them.