Programming for Geographical Information Analysis:

Core Skills

Lecture 11: Coding for Real

Dr Andy Evans and Dr Kirk Harland

This lecture

The development processStructuring codeTesting

Development ProcessesConsiderable debate around how best to manage software development.Most proposed ‘processes’ have a parentage in the ‘Waterfall Model’; roughly:

RequirementsDesignCodingTestingInstallationMaintance

Like a good many parents who try their best, its children have nothing good to say about it.

Critiques

Largely focused on the fact that software was never fully completed, but always being re-visited at different scales. In particular, it is unhelpful not to go back to users and consult once a basic system is drafted.

Popular alterative is Iterative and Incremental development, where, after initial Requirements are outlined, there is a cycling through the development units, taking important and high-risk elements first.

This is sometimes combined with the Waterfall model as the ‘Iterfall model’. Experience suggests the broad sweep of this matches with beginner’s natural inclinations.

New processes

Based on the Iterative and avoiding the over-management of the Waterfall method: Agile software development processes include:

Rational Unified ProcessExtreme ProgrammingKanban and SCRUM for communication Short development sprintsContinuous Integration

Main issue is to concentrate on user needs.

UML

An intrinsic part of the development process.

From: Use CasesThrough: Class DiagramsTo: Activity Diagrams

Development stagesRefining user requirements.Dividing code (e.g. by important high-risk functions first).Keeping users informed.Development.Usability testing.Bug hunting.Refactoring.Alpha and Beta testing.Releases.Deciding on the next set of functions to tackle.

Increasingly releases tackle a few functions on a short timescale rather than major releases with a longer gap (“RERO”).

Licensing

Different options on a spectrum:

Open source.Maintenance contracts.Open standards.Community built.Freeware.Adware.Commercial.

Computer Ethics

Rapidly growing field:Traditional elements:

Privacy and data protectionCopyright and PiracySoftware supplier responsibilities

Newer:Big Data useRobotic ethicsControl by computersIntegrating computers into our worldview

A good starting point for the newer stuff is Floridi et al.:

Installing

Three parts to installation…Get the files to them.Check they have the JDK.Let them run the program.

Ideally we want to let them run by double-clicking a name or icon…

Can get them to set this up as a shortcut themselves.Can compile as a .exe.Can use a self-executing jar file.Can use a .bat file or wrapping exe.

Summary

Getting a strong project outline at the start will help you resource a project, as will having a clear delimitation of coding activities.

However, project frameworks need to have flexibility built in to cope with project evolution. Start with an ordered list of functionalities, but consult with users frequently.

Look into formal software development processes if you have to work with teams.

This lecture

The development process

Structuring codeTesting

Structure we’ve seen

BlocksException handlingMethodsClassesPackages

How do we judge where code should go?

Coupling and Cohesion

Good OO design calls for LOOSE coupling and HIGH cohesion.Coupling is the degree to which two classes 'know about each other'.

Just uses public interface methods: low coupling.Uses internal code, e.g. internal variables: high coupling.

Cohesion is the purpose of the class. Is it well focused?

Coupling

Close coupling causes issues for code maintenance.Enhancement or bug fixes to a class should be possible without impacting the interface it presents.Assumption is that changes will not impact anywhere else, why should it if the interface has not changed.A close coupled class means if part of the code changed, the alteration has an undetected impact.

Close coupling limits code reuse because you can’t just separate off one class.

Cohesion

A class with high cohesion has a well defined purpose.Classes designed with high cohesion are:

Easier to maintain.Less likely to require frequent changes.Easier to reuse in multiple projects / applications.Tend to be simpler to follow for other developers.Generally have a well defined interface.

High Cohesion Loose Coupling

Remember when designing a class:Define the purpose and don't let that creep.Keep the inner functions of the class private.Think about how you want other classes to interact with this class and define its interface accordingly.Ask yourself, how easy would this class be to reuse in another project?

Structure we’ve seen

BlocksException handlingMethodsClassesPackages

Others we haven’t: threads, parallelisation, other programs

Getting processor time

Usually a program will take over the processor once and run through the code a line at a time in one go.

However, you can force the processor to split up and run several copies of the same bit of code.

Each runs in its own processor “thread” of execution.

For example, you might want a web server to have one thread for each person accessing files so you can send the right file back to the right person, even though lots of requests are being made simultaneously.

Threads

Implement java.lang.Runnable interface and make a Thread object inside the class.

Extend java.lang.Thread class – this implements Runnable.

Either way you need a Runnable object and a Thread object

You need to call the Thread’s start() method. This will look in the Runnable object for a run() method.

synchronized

The synchronized keyword stops more than one Thread / method at a time using the code.

Can be applied to methods and blocks.

The latter means you can synchronize object methods, even if you didn’t write the class.

synchronized(theirObject) {

theirObject.theirMethod();

}

Parallel Supercomputing

Split up a program so it runs on multiple computers.

For example, each computer does the calculation for a different geographical area.

Starting other programs

The environment the program is running in is encapsulated by a java.lang.Runtime object.

The current Runtime can be got with a static method. Runtime rt = Runtime.getRuntime();

Runtime has methods to:Deal with the computer memory.Interact with the JVM interpreter.Run other programs.

Starting other programs

Other programs can be run by the JVM. They are encapsulated in a java.lang.Process object.

These can be got using the current Runtime.Process processObject = runtimeObject.exec(“programlocation”);

If the OS knows where a program is (i.e. it’s in the PATH), we can just use a name.

Also a version of exec that takes in this and an array of arguments, as if the program was running at the command line.

Interacting with other Programs

Once started you can use Process methods to drive the programs.

Reading from Processes…processObject.getInputStream()

Writing to Processes…processObject.getOutputStream()

Stopping Processes…processObject.destroy()

Structure we’ve seenBlocksException handlingMethodsClassesPackagesThreads / ParallelisationOther programs

Where do we get advice?

Patterns

“Patterns” are standard ways of solving a software problem that people come across again and again. They aren’t specific to Java, or any other language.

They save us having to reinvent solutions.

The most influential book in the field was Design Patterns – Elements of Reusable Software by the “Gang of Four” Gamma, Helm, Johnson and Vlissides (1995).

The Gang of Four Patterns

They gave 23 patterns with C examples.

Creational Patterns – classes to make stuff.The Factory, Abstract Factory, Singleton, Builder, and Prototype.

Structural Patterns – software architecture.The Adapter, Bridge,Composite, Decorator, Façade, Flyweight and Proxy.

Behavioural Patterns – which classes do what.The Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template, and Visitor.

Patterns we’ve seen

Observer : Listeners.Model-View-Controller: Swing.Adapter Pattern: AWT.Iterator

Why Use Patterns?

Industry standard methods of doing something, therefore other programmers will understand your code.

They encapsulate solutions so you can get on with more tricky things.

They’ll give you a deeper understanding of why Java is the way it is.

They’re the advice of top experts with years of experience – they’ll teach you a lot about good Object Orientated software design.

Book

Summary

Good Object Orientated code structure encourages robust and reusable software.

Read up on patterns: they’ll teach you about good program style, and help solve major issues.

This lecture

The development process

Structuring code

Testing

Timing a program

Get the current time in various places and print it out.long time = System.currentTimeMillis()

Where milliseconds is since January 1, 1970, 00:00:00 GMT.

If you want to see this as a proper date, use a java.util.Date objectnew Date(long milliseconds)

Methods to find if a date is before or after a Date, or set the date in it.

Checking memory

Computers store most of the information they need to do processing in a memory chip.

If the space available is exceeded by the data, most write to Virtual Memory – this is part of the harddrive and acts as if it’s “real” memory.

Using Virtual Memory is slow, because it uses magnetic media that are slow to write to.

If the Virtual Memory is exceeded, processing will become very slow, and the system unstable. Java therefore has built in memory limits.

Finding out about the computer

Remember, the environment the program is running in is encapsulated by a java.lang.Runtime object.

The current Runtime can be got with a static method. Runtime rt = Runtime.getRuntime();

Runtime has methods to Deal with the computer memory.Interact with the JVM interpreter.

Computer memory

Java copes with memory well, but occasionally we may want to check it.

For example, if a file is much larger than the real memory, we may want to only read in small chunks at a time.

runtimeObject.freeMemory()runtimeObject.totalMemory()

These return the free and total memory available in the computer.

Garbage Collection

Garbage Collection is a general computing term for clearing up objects we no longer need from memory.

Objects will stay in memory until collected, even if not used.

Java does automatic Garbage Collection, when memory gets low, but you may want to force it.

runtimeObject.gc();

Unit Testing

A way to ensure that methods have the desired ‘behaviour’

Decide on behaviourWrite testsWrite code to satisfy tests

Time consumingProduces robust codeFuture maintenance is easier

Other tests

Stress testingAlpha/Beta releasesUsabilityRegression testingSoftware testing

Summary

Good code structure centres on building to interfaces: are the inputs and outputs to methods and classes reliable, and do they respond well if things go wrong.

Get this right, and you’ll minimise bugs.

Unit testing formalises this.

However, also test usability and go through alpha and beta test releases.

This lecture

The development processStructuring codeTesting

The End

Core language elements

Java 1.5 additionsOther core elementsLanguage forms

Variable method arguments“…” to send in an undefined number of method params.

EnumerationsSet up sequences, eg. WHITE, YELLOW, RED, BLUE, BLACK

Autoboxing Wrappers to primitives. E.g. vector.add(myInt++);

Static importsJust import the static parts of classes.

Annotations@ markup, but can be accessed programmatically.

Java 1.5 additions

Other core elements

CloningAutomatically copying entire objects.

ImageFiltersUsing streams to convert pixels on the fly.

Language forms

JavaBeansHave drag-and-drop interface. Set and Get methods key to getting these working.Servlets Programs that can be started and run by a web server by requesting them as a webpage.Java Server Pages (JSP)Webpages that contain small programs – when the pages are sent out, the output from the programs generates HTML.

Other languages

C++VB.NetJavascriptPython

Advanced course: “advanced” as in “progress”, not “difficulty”.

Programming ArcGISDatabase connectivityUsing analysis librariesVisualising dataSupercomputingBuilding an artificial intelligence for predictive modelling.

Further information

The GEOG5990 website for subjects we’ve covered: All the lectures. All the handouts.Examples, practice pieces, and useful links.

The book recommendations.UML, Cookbook, and Patterns books are a definite “must have” if you go on to code professionally – they’ll teach you good coding practise as well as industry standards.

The Java website.

Main thing

Practice

Assessment 2

Sign up

Practical

Tank battle