COMP220

Software Development Tools

Aims

To introduce students to a range of techniques and tools, beginning to be used in modern, large-scale industrial software development.

To provide coverage of tools already being used in industrial settings.
​​To describe how the development and deployment of high quality, robust products is supported through software development tools.​

Syllabus

The module will cover the following aspects of modern contemporary software engineering. Each one will be analysed in terms of its utility in software development, its implementation in a specific software tool. (Note that this list of topics is indicative only.)

  1. Introduction and general methodological questions (2 lectures)
    • EXtreme Programming Methodology
    • Automated Testing and Continuous Integration
    • Types of automated testing
    • Brief overview of some testing tools (Junit, Cactus, HttpUnit, etc.)
  2. Eclipse and Java (3 lectures)
    • General description of Eclipse
    • The Java quick tour in Eclipse
    • Creating in Eclipse a Java project, Java Class and running Java programm
    • Working with syntax errors in Eclipse Java Editor
    • Preferences and other settings
    • Code-completion/code-generation features
  3. Eclipse and JUnit (3 lectures)
    • Creating and running a JUnit test case in Eclipse
    • JUnit wizard in Eclipse
    • Running the JUnit tests in Eclipse
    • Example of test driven programming in Eclipse
  4. Introducing Ant (4 lectures)
    • Getting Started: running you first build
    • Ant and XML
    • Ant targets and tasks; target dependencies
    • Structured Build in Ant: Laying out the source directories and source files
    • Compiling and running Java programs ftom command line vs from inside Ant
  5. Ant: Datatypes and Properties (5 lectures)
    • Datatypes: filesets, paths, filtersets, mappers
    • Properties: property (paramenter) handling mechanism; various ways of setting and using properties; built-in properties, property files; immutability of properties
    • Mechanism of referencing to datatypes
    • Setting properties by tasks <available>, <uptodate>, <condition>
    • Setting properties from command line
    • Using properties for conditional target execution with if/unless
    • Using properties for conditional patternset inclusion/exclusion
  6. Ant: Nested Builds (1 lecture)
    • Using <ant> task for building subprojects into a bigger project
    • Passing properties to subprojects
  7. More on Testing and JUnit (3 lectures)
    • JUnit Primer
    • Invoking JUnit test runner from Ant
    • Asserting desired results
  8. Ant, Testing and JUnit (3 lectures)
    • Running a test case with setUp() and tearDown()
    • Ant''s task <junit>
    • General Ant build process related to JUnit testing
  9. Ant: Capturing JUnit test results (3 lectures)
    • Test result formatters
    • Running multiple tests under <batchtest>
    • Generating (HTML) test result reports by using <junitreport> Ant task
    • Outline of test-driven programming   
  10. Eclipse and Ant (3 lectures)
    • How  Ant works  in the framework of Eclipse
    • Creating the build directory structure
    • Separating  the source and build directories in a new or existing project
    • Ant script editor: code-completion and other useful features
    • Running Ant from inside of Eclipse
    • Importing  Existing Ant Project into Eclipse with source folders corresponding to specific output folders

Recommended Texts

  • E. Hatcher and S. Loughran: Java Development with Ant. Manning Publications (most recent edition) or
  • S. Loughran and E. Hatcher: Ant in Action. Manning Publications (most recent edition).
  • D. Gallardo, E. Burnette and R. McGovern: Eclipse in action : a guide for Java developers. Manning Publications (most recent edition).
  • P. Tahchiev, F. Leme, V. Massol and G. Gregory: JUnit in Action. Manning Publications (second or most recent edition).​


Further reading:
  • R. Hightower and N. Lesiecki: Java Tools for Extreme Programming. Wiley (most recent edition).
  • K. Beck: Test Driven Development. Addison-Wesley (most recent edition).

Learning Outcomes

Express the general ideas, advantages, and methods of using software development tools​

​​Use Ant, JUnit and Eclipse both individually and jointly as tools for Automated Testing, Continuous Integration and Test Driven Programming
Solve problems related to Automated Testing, Continuous Integration and Test Driven Programming using software development tools JUnit, Ant and Eclipse.

Learning Strategy

Lecture

Practical

Formal Lectures: In a typical week, students will be expected to attend three lectures for the duration of the module. Formal lectures will be used to introduce students to the concepts and methods covered by the module.

Practical Sessions: In a typical week, students will be expected to work for one hour in a supervised computer laboratory practical session under the guidance of demonstrators. These sessions will include exercises providing the students with formative feedback concerning their understanding of the material.

Private Study: In a typical week students will be expected to devote six hours to unsupervised time to private study. Private study will provide students with time to deepen their understanding of the material using the lecture notes, to solve additional exercises, to read recommended texts in the area of software engineering, and to complete those aspects of the assessments tasks that do not involve supervised computer laboratory work.

Assessment: A lab-based assessment will be used to test to what extent practical skills have been learnt. In addition, a class test will be used to provide early formative and summative feedback on the academic achievement during the semester. A final examination at the end of the module will assess the overall academic achievement of students.