units

FIT1008

Faculty of Information Technology

Monash University

Undergraduate - Unit

This unit entry is for students who completed this unit in 2013 only. For students planning to study the unit, please refer to the unit indexes in the the current edition of the Handbook. If you have any queries contact the managing faculty for your course or area of study.

print version

6 points, SCA Band 2, 0.125 EFTSL

To find units available for enrolment in the current year, you must make sure you use the indexes and browse unit tool in the current edition of the Handbook.

LevelUndergraduate
FacultyFaculty of Information Technology
OfferedClayton First semester 2013 (Day)
Clayton Second semester 2013 (Day)
Sunway Second semester 2013 (Day)

Synopsis

This unit introduces students to core problem-solving, analytical skills, and methodologies useful for developing flexible, robust, and maintainable software. In doing this it covers a range of conceptual levels, from high level algorithms and data-structures, down to abstract machine models and simple assembly language programming. Topics include data structures; algorithms; object-oriented design and programming; and abstract machines.

Outcomes

At the completion of this unit, students will have

Developed the ability to:

  • understand abstract data types and, in particular, data structures for stacks, queues, lists, trees, and heaps, as well as the associated algorithms for creating and manipulating them. Evaluate the appropriateness of different data structures for a given problem;
  • understand basic searching and sorting algorithms, analyse their properties and be able to implement them. Understand the concept of algorithmic complexity. Analyse the complexity of these searching and sorting algorithms as well as other basic algorithms. Compare the complexity of different algorithms for solving a given problem;
  • analyse different implementations of abstract data types and determine their implications regarding complexity, functionality, and memory usage;
  • understand the uses of recursive algorithms and data structures, their advantages and disadvantages. Analyse the complexity of simple recursive algorithms, and their relationship with iteration. Understand basic recursive algorithms for lists and trees, and develop new ones;
  • understand the different compilation targets, including abstract machine code, assembly language, object code, and machine code. Understand the relationship between simple code in a high level imperative language and its low level translation into assembly code;
  • learn the structure and design of a particular processor simulator. Analyse the execution in this simulator of simple iterative algorithms learned before, thus gaining a deeper understanding of the connection between software and hardware, between an algorithm and its execution;
  • understand how the simulator implements function calling, and use it to reinforce the connection between recursion and iteration.

Developed attitudes that enable them to:

  • conform to programming standards when writing software;
  • use good design principles when constructing systems;
  • take a patient and thorough approach to testing;
  • acknowledge any assistance they have received in writing a program;
  • search for information in appropriate places when necessary.

Developed the skills to:

  • implement their own data-structures. Design and implement programs using a variety of data structures and algorithms;
  • construct a test harness for testing a program;
  • debug and modify an existing program (written by somebody else);
  • use an Integrated Development Environment when developing their programs.

Demonstrated the communication skills necessary to:

  • document a program correctly;
  • explain how parts of a program work.

Assessment

Examination (3 hours): 70%; In-semester assessment: 30%

Chief examiner(s)

Contact hours

3 hrs lectures/wk, 3 hrs laboratories/wk, 1 hr tutorial/wk

This unit applies to the following area(s) of study

Prerequisites

Prohibitions

CSE1303, CSC1030, FIT1015
Students beginning FIT1008 are assumed to be able to: Identify the main components of an algorithm (variables, operators, expressions, etc), and write the algorithm associated to the specification of a simple problem. Be able to translate a simple algorithm into a program containing variable declarations, selection, repetition, and lists and/or arrays.

Additional information on this unit is available from the faculty at: