Programming Principles: Loops and Arrays

In this session we look at the different types of loop in the Java language, and see how they can be used to iterate over Arrays.

Programming Principles: Collections and Iterators

In this session we look at how we can use collection objects like ArrayList as a more advanced type of array. We also introduce the idea of generics (forcing a collection to hold a particular type) and see how Java handles the autoboxing and unboxing of primitives. Finally we look at Iterators, a common design pattern for dealing with iteration over a collection.

Programming Principles: Testing and Debugging

In this session we look at the sorts of errors that occur in programs, and how we can use different testing and debugging strategies (such as unit testing and inspection) to track them down. We also look at error handling within the program and at how we can use Exceptions to manage errors in a more sophisticated way. These slides are based on Chapter 6 of the Book 'Objects First with BlueJ'

Programming Principles: Software Design

In this session we look at some of the basics of good code design, including avoiding duplication and designing for loose coupling and high cohesion.

Programming Principles: Super and Sub-classes

In this session we introduce inheritance - one of the cornerstone concepts of object oriented programming. We look at how to define super and sub-classes, how to maintain encapsulation using the super() constructor, and why it is useful to use substitution to hold references to sub-classes in references typed as their super-class.

Programming Principles: Polymorphism

In this session we build on inheritance and look at overriding methods and dynamic binding. Together these give us Polymorphism - the third pillar of Object Oriented Programming - and a very powerful feature that allows us to build methods that deal with superclasses, but whose calls get redirected when we pass in sub-classes.

Programming Principles: Abstract Classes and Interfaces

In this session we look at how to use Abstract Classes and Interfaces in Object Oriented Design - especially as a way to get all the advantages of multiple inheritance without any of the problems.

Programming Principles: Designing Applications

In this session we look at the how to use noun verb parsing to try and identify the building blocks of a problem, so that we can start to create object oriented solutions. We also look at some of the challenges of software engineering, and the processes that software engineers use to meet them, and finally we take a look at some more Design Patterns that may help us reuse well known and effective solutions in our own designs.

Programming Principles: Conclusions

This is the revision session for our Programming Principles course. We take a whistle-stop tour of the topics covered in the course, look at the three pillars of object oriented programming, and look ahead to the exam.

COMP1004 Programming Principles

These are the resources used for the Computer Science course Programming Principles, designed to teach students the fundamentals of computer programming and object orientation via learning the Java language. We also touch on some software engineering basics, such as patterns, software design and testing. The course assumes no previous knowledge of programming, but there is a fairly steep learning curve, and students are encouraged to practice, practice, practice!

Java path setting batch file

This is a batch file written to help students on ECS' Programming 1 course (COMP1202) using iSolutions machines which have the JDK, but do not add it to the PATH variable, making compilation from the command line difficult. It attempts to find the JDK directory and add it to the Windows PATH. The code is as follows: @SET JAVA_HOME=C:\Program Files\Java @FOR /F %%G IN ('DIR /B "%JAVA_HOME%\JDK*"') DO @SET JDK_HOME=%JAVA_HOME%\%%G @SET PATH=%JDK_HOME%\bin;%PATH% @javac -version @echo. @echo %JDK_HOME%\bin successfully added to Windows PATH @echo. @echo Now type 'javac'. @echo. @echo. @echo. @CMD

An exploratory study of the effect of aspect-oriented programming on maintainability

In this paper we describe an exploratory assessment of the effect of aspect-oriented programming on software maintainability. An experiment was conducted in which 11 software professionals were asked to carry out maintenance tasks on one of two programs. The first program was written in Java and the second in AspectJ. Both programs implement a shopping system according to the same set of requirements. A number of statistical hypotheses were tested. The results did seem to suggest a slight advantage for the subjects using the object-oriented system since in general it took the subjects less time to answer the questions on this system. Also, both systems appeared to be equally difficult to modify. However, the results did not show a statistically significant influence of aspect-oriented programming at the 5% level. We are aware that the results of this single small study cannot be generalized. We conclude that more empirical research is necessary in this area to identify the benefits of aspect-oriented programming and we hope that this paper will encourage such research.

Nested parallelism for multi-core HPC systems using Java

Since its introduction in 1993, the Message Passing Interface (MPI) has become a de facto standard for writing High Performance Computing (HPC) applications on clusters and Massively Parallel Processors (MPPs). The recent emergence of multi-core processor systems presents a new challenge for established parallel programming paradigms, including those based on MPI. This paper presents a new Java messaging system called MPJ Express. Using this system, we exploit multiple levels of parallelism - messaging and threading - to improve application performance on multi-core processors. We refer to our approach as nested parallelism. This MPI-like Java library can support nested parallelism by using Java or Java OpenMP (JOMP) threads within an MPJ Express process. Practicality of this approach is assessed by porting to Java a massively parallel structure formation code from Cosmology called Gadget-2. We introduce nested parallelism in the Java version of the simulation code and report good speed-ups. To the best of our knowledge it is the first time this kind of hybrid parallelism is demonstrated in a high performance Java application. (C) 2009 Elsevier Inc. All rights reserved.

Upgrading a TCABR data analysis and acquisition system for remote participation using Java, XML, RCP and modern client/server communication/authentication

The TCABR data analysis and acquisition system has been upgraded to support a joint research programme using remote participation technologies. The architecture of the new system uses Java language as programming environment. Since application parameters and hardware in a joint experiment are complex with a large variability of components, requirements and specification solutions need to be flexible and modular, independent from operating system and computer architecture. To describe and organize the information on all the components and the connections among them, systems are developed using the extensible Markup Language (XML) technology. The communication between clients and servers uses remote procedure call (RPC) based on the XML (RPC-XML technology). The integration among Java language, XML and RPC-XML technologies allows to develop easily a standard data and communication access layer between users and laboratories using common software libraries and Web application. The libraries allow data retrieval using the same methods for all user laboratories in the joint collaboration, and the Web application allows a simple graphical user interface (GUI) access. The TCABR tokamak team in collaboration with the IPFN (Instituto de Plasmas e Fusao Nuclear, Instituto Superior Tecnico, Universidade Tecnica de Lisboa) is implementing this remote participation technologies. The first version was tested at the Joint Experiment on TCABR (TCABRJE), a Host Laboratory Experiment, organized in cooperation with the IAEA (International Atomic Energy Agency) in the framework of the IAEA Coordinated Research Project (CRP) on ""Joint Research Using Small Tokamaks"". (C) 2010 Elsevier B.V. All rights reserved.

JCML: A specification language for the runtime verification of Java Card programs

COSTA, Umberto Souza; MOREIRA, Anamaria Martins; MUSICANTE, Matin A.; SOUZA NETO, Plácido A. JCML: A specification language for the runtime verification of Java Card programs. Science of Computer Programming. [S.l]: [s.n], 2010.