groovy & grails - lecture 5

Groovy: Efficiency Oriented Programming
Lecture 5
Master Proteomics & Bioinformatics - University of Geneva
Alexandre Masselot - summer 2011

Contents

‣ Eclipse & linux tips
‣ Debugging with Eclipse
‣ A thought on code design
‣ Object methods : a few step forwards
‣ Inheritance

A couple of linux (shell) tips

‣ Print all files named peaklist-*.mgf residing under a
given directory:
find /home/alex/tmp -name “peaklist-*.mgf”


given directory:
‣ Get “ls -l” like details by appending -ls option


given directory:
‣ You want to download a fasta file, based on a list of accession codes
acList="P41159 Q9Y5Q6 Q70Z44"
for ac in $acList; do echo "downloading $ac" ; wget
--quiet -O $ac.fasta http://uniprot.org/uniprot/$ac.fasta;
done


given directory:
‣ You want to download a fasta file, based on a list of accession codes
acList="P41159 Q9Y5Q6 Q70Z44"
for ac in $acList; do echo "downloading $ac" ; wget
--quiet -O $ac.fasta http://uniprot.org/uniprot/$ac.fasta;
done
‣ The same, in multi-line version:
for ac in $acList
do
echo "downloading $ac"
wget --quiet -O $ac.fasta http://uniprot.org/uniprot/$ac.fasta
done

A couple of eclipse tips

‣ launches the last executed program (or test)
- <ctrl>-<shift>-F11
- configure through
preferences > run/debug > launching > launch operation
- possible to run a whole directory as junit test

A couple of eclipse tips

‣ launches the last executed program (or test)
- <ctrl>-<shift>-F11
- configure through
preferences > run/debug > launching > launch operation
- possible to run a whole directory as junit test
‣ It is possible to hide/show the current method / editor block
- little +/- sign in the margin to toggle show/hide
- shortcut <numpad> /

Eclipse: debugging

‣ 90% of a developer's time is spent debugging his code

Eclipse: debugging

‣ Old fashion way: add println statement
- enhance println of object defined by you through defining a String
toString() method
- damned tedious: define println details, comment in/out, pollutes the
code

Eclipse: debugging

‣ Old fashion way: add println statement
- enhance println of object defined by you through defining a String
toString() method
- damned tedious: define println details, comment in/out, pollutes the
code
‣ Configurable logger (log4j)
- print on console, but with different level of details (debug/info/warn/error)
- cleaner in code
- no need to comment in/out
- we will see this functionality later

Eclipse: debugging (cont’d)

‣ Debugging consists in three major aspects:


‣ Breakpoints
- a breakpoint is a “flag” positioned at a given line in the source code
- at execution time, the program will halt when reaching the break point
- possible to move on step by step (into, over or return) or to next
breakpoint


‣ Breakpoints
breakpoint
‣ Displaying objects
- when the program is halted, objects available in the current scope can
be analyzed
- it is possible to dig in the object fields


‣ Breakpoints
breakpoint
‣ Displaying objects
- when the program is halted, objects available in the current scope can
be analyzed
- it is possible to dig in the object fields
‣ Call stack
- The stack of method calls at the current position


‣ Launching in debug mode
- instead of “run as...”, call “debug as...”
- <ctrl>-F11


‣ Launching in debug mode
- instead of “run as...”, call “debug as...”
- <ctrl>-F11
‣ Eclipse open the debug perspective, with different windows for
- variables
- breakpoint list
- call stack
- current code
- menu for stepping or resuming execution

execution control
debug mode

8

execution control
debug mode

call stack

8

execution control
debug mode

call stack

break point

8

execution control
debug mode

call stack

current code line

break point

8

execution control
debug mode

call stack variable

current code line

break point

8

A thought on code design

‣ Writing a script with all in one to answer a (lab) question is only code
writing


writing
‣ Architecting a problem into a piece of software is also a matter of breaking
the problem
- into classes achieving independent functionalities (test, change a sub
part)
- offer the possibility to re-use functionalities


writing
the problem
part)
‣ But do not over-architect a software at start; prefer to make it evolve
constantly (think agile)


writing
the problem
part)
‣ For example, the practicals Protein class should not contain the
download/readFromFasta (what will happen when reading from xml?)


writing
the problem
part)
‣ For example, the practicals Protein class should not contain the
download/readFromFasta (what will happen when reading from xml?)
‣ Your motto : “I want to understand my own code in 6 months”

OOP: more depth

‣ Several aspects of OOP
- creating a new class
- fields
- static fields
- constructors
- methods
- unit testing
- overriding operators
- method or closures?
- inheritance

OOP: Making a new class

‣ By convention, class name starts with an upper case (when variable usually
start with lower case)


‣ Within a source directory, create a package (a subdirectory structure,
where ‘.’ is a directory path separator), for example
unige.mpb.lec5.example


‣ In eclipse File -> new -> package (<ctrl>-N package)


‣ Within this package, create a class : File -> new -> groovy class and set
name Person.


‣ Within this package, create a class : File -> new -> groovy class and set
name Person.

‣ A Person.groovy file is create with
package unige.mpb.lec5.examples
class Person{
...
}

OOP: making a new class (cont’d)

OOP: making a new class (cont’d)

class Person{

String name // field of type String

Date birth // field of type Date

int age(){ // a method returning an int

return (new Date()).year - birth.year

}
}

one field : one property link to one instance

13

Class: fields

‣ Fields are properties of a class, they can be dynamically or statically typed
(of any existing type (Integer, List, Map, etc...)

Class: fields

‣ Field are by default associated to an instance of the class (an object
generated by new Person())

Class: fields


‣ They can be changed directly from outside the class (GBean)
guy.name = ‘Jimmy‘
guy.setName(‘Jimmy’)

Class: fields


‣ Or read
println guy.name
println guy.getName()

Class: fields


‣ Or read
println guy.name
println guy.getName()
‣ Inside a method, the instance properties are directly used by their name
int age(){return (new Date()).year - birth.year}

one static field: one property linked to the class

15

one static field : the same for all instances

16

Class: static fields

‣ Fields can also be static i.e. a global value, shared by all instances of the
class (by convention upper case).


‣ If we come back to our previous Person example, we want
static int AGE_LIMIT = 18
boolean canDrive(){return age() >= AGE_LIMIT}


‣ If we come back to our previous Person example, we want
static int AGE_LIMIT = 18
boolean canDrive(){return age() >= AGE_LIMIT}

‣ We can change this value at once for all Person instances
Person.AGE_LIMIT = 16

Constructor

‣ Thanks to the scripting spirit, there is no need to declare constructor (the
function to instantiate an object)

Constructor

‣ Field can be filled with a map structure
Person girl=new Person(name:‘Marylyn’)

Constructor

‣ It is not compulsory to set all the field

Constructor

‣ It is not compulsory to set all the field
‣ To set default value to a field, you can define it in the property declaration
String name=‘John Doe’

Methods

‣ Methods are functions, with are called within the context of an object
instance

Methods

instance
‣ All properties of the instance are accessed directly

Methods

instance
‣ It is possible to modify the instance, directly addressing the instance fields

Methods

instance
‣ It is possible to pass argument to the function

Methods

instance
‣ It is possible to pass argument to the function
‣ It is possible to return a value (of whatever type)

OOP : methods

‣ A method is a function called in the context of an object instance

OOP : methods

‣ All fields of the object can be addressed directly from within a method

OOP : methods

‣ All fields of the object can be addressed directly from within a method
‣ Methods are functions: lecture 2 about function apply:
- dynamic/static types for arguments
- arguments can be named
- arguments can have default values
- if multiple functions are defined with the same name but different list/
type of arguments, the call context will choose the correct one

Methods: setter and getter

‣ Protein field can be accessed in two equivalent manner
prot.sequence
prot.getSequence()


prot.sequence
prot.getSequence()
‣ Or set via two manners
prot.sequence=‘ACDEFG’
prot.setSequence(‘ACDEFG’)


prot.sequence
prot.getSequence()
‣ In fact reading or setting the field via the field calls the getter/setter
implicitly (methods are generated automatically by the groovy compiler)


prot.sequence
prot.getSequence()
‣ In fact reading or setting the field via the field calls the getter/setter
implicitly (methods are generated automatically by the groovy compiler)
‣ By default, a setSequence method is defined
void setSequence(sequence){ //void means no value returned
this.sequence=sequence
//this is the current object
// we could have name the argument with ‘seq’
}

Methods: setter and getter (cont’d)

‣ Imagine we want to get the protein mass, computed from the sequence
def mp = prot.mass


def mp = prot.mass
‣ Their is no explicit mass field, but a static MassCalculator is attached
to class Protein
static MassCalculator MASS_CALCULATOR


def mp = prot.mass
to class Protein

‣ We can define a getMass method
double getMass(){
return MASS_CALCULATOR.sequenceMass(this)
}


def mp = prot.mass
to class Protein

‣ We can define a getMass method
double getMass(){
return MASS_CALCULATOR.sequenceMass(this)
}
‣ Problem with the current solution: we recompute mass at each time we
call it (think of sorting a long list of protein on their mass)


‣ We could therefore have a mass field to Protein and set it with the
correct value the first time we ask for it
double mass = 0
...
double getMass(){
if(!mass)
mass = MASS_CALCULATOR.sequenceMass(this)
return mass
}


double mass = 0
...
double getMass(){
if(!mass)
return mass
}

‣ We consider the mass field as a cached value


double mass = 0
...
double getMass(){
if(!mass)
return mass
}

‣ We consider the mass field as a cached value
‣ Problem: what happen if we change the protein sequence?


‣ Solution : reset mass when we set the sequence
def setSequence(sequence){
mass=0
}


‣ Solution : reset mass when we set the sequence
def setSequence(sequence){
mass=0
}
‣ If we need (e.g. at testing time) to access directly to the field, without
going through the getMass() method, we still can
my_prot.@mass

Unit testing

‣ Each method of a class must be tested, to ensure it fulfills the intended
goals

Unit testing

goals
‣ One class file = one test file
- in another directory (src/test)
- same package name
- MyClass.groovy => MyClassTest.groovy

Unit testing

goals
‣ One class file = one test file
- in another directory (src/test)
- same package name
- MyClass.groovy => MyClassTest.groovy

‣ Eclipse/groovy offers a integrated environment for that purpose

Unit testing (cont’d)

‣ In another source folder (typically src/tests/groovy), test will be
generated:
- select a class
- File -> new -> Groovy Test Case
- select the other src/test/groovy source folder
- select junit 3 (better for later use of grails for the moment)
- next -> select methods to be tested


generated:
- select a class
‣ In junit 3, any method with name starting with test* will be used as test


generated:
- select a class

‣ right button -> run as -> junit test (<ctrl>-<alt>-X-T)


generated:
- select a class

‣ right button -> run as -> junit test (<ctrl>-<alt>-X-T)

‣ Customize show view (<ctrl>-<alt>-Q-U + down arrow and tab)

Methods: overriding operators

‣ In lecture 1 (or “Groovy in Action”, chap. 3.3) we saw several operator (+,
*, /) and how those operators are tight to a method name



‣ For example, we like to write the cleavage of a Protein by an Enzyme
List peptides=my_prot/trypsin
//in Protein.groovy
def div(enz){
return enz.cleav(this) //this is the current object
}



‣ For example, we like to write the cleavage of a Protein by an Enzyme
List peptides=my_prot/trypsin
//in Protein.groovy
def div(enz){
return enz.cleav(this) //this is the current object
}
‣ Do not abuse of overriding operator (think that you want to understand
your code in 6 months)

Override spaceship: making objects comparable

‣ A very common need is to make relevant the operators <, <=, ==, > and >=



‣ It is equivalent to override the spaceship operator <=>



‣ First step: make your class implements the Comparable interface
class MyClass implements Comparable{
...
}



...
}
‣ Second step: code the logic of the spaceship (< return negative, == returns
0, and > returns positive integer)
def int compareTo(other){
...
}



...
}
‣ Second step: code the logic of the spaceship (< return negative, == returns
0, and > returns positive integer)
def int compareTo(other){
...
}

‣ See practicals for an example on Protein

Method or closure?

‣ “A closure is a piece of code wrapped up as an object[...]. It’s a normal object
in that you can pass a reference to it around just as you can a reference to any
other object”

(Groovy in Action - 5.1 A gentle introduction to closures)

Method or closure?

other object”

‣ From the caller point of view, method or closure at very similar

Method or closure?

other object”

‣ However, we can modify a closure, thus modify the behavior of an action
on an object, from outside the class

Method or closure?

other object”

‣ From the coding point of view, you can add closure in your class
def myAction = { arg1, arg2 ->
...
}

Method or closure?

other object”

‣ From the coding point of view, you can add closure in your class
def myAction = { arg1, arg2 ->
...
}
‣ Then call it
myObj.myAction(12, ‘abc’)

Method or closure? (cont’d)

‣ In Protein.groovy, consider the static method that turn ac into a url
static def UNIPROT_AC_URL(ac){
return “http://www.uniprot.org/uniprot/${ac}.fasta”.toURL()
}


}
‣ Problem : “I have no network (and that’s ok for testing purpose for example)
and I want to modify the behavior without modifying Protein class itself. I
have downloaded a list of fasta ﬁles in a local directory”


}
‣ A) turn the method into a closure
static def UNIPROT_AC_URL={ac ->

return “http://www.uniprot.org/uniprot/${ac}.fasta”.toURL()}


}
‣ A) turn the method into a closure
static def UNIPROT_AC_URL={ac ->

return “http://www.uniprot.org/uniprot/${ac}.fasta”.toURL()}
‣ B) modify it (in ProteinTest.groovy setup() for example)
Protein.UNIPROT_AC_URL = {ac ->
return (new File("src/practicals/data/fastas/${ac}.fasta")).toURL
}

OOP: inheritance

‣ In the practicals from lecture 4, an Enzyme cleaves a Protein and
produces a List<String>

OOP: inheritance

‣ In the practicals from lecture 4, an Enzyme cleaves a Protein and
produces a List<String>

‣ Let’s consider it should produces a List<Peptide> where Peptide
consists in
- field String sequence

- field Protein parentProtein
- field int startPosition
- method int getLength()

- method double getMass() (with the same caching as for the Protein)

Inheritance (cont’d)

‣ Solution A: create a file Peptide.groovy strongly copied from
Protein.groovy


Protein.groovy
‣ Problems:
- lot of code is duplicated, thus bugs and test
- not easy to read
- modifying a functionality (think of getMass() caching) should be done


Protein.groovy
‣ Problems:
- not easy to read

Protein Peptide
accessionCode sequence
sequence parentProtein
downloadFasta(ac) startPosition
getLength() toString()
getMass() getLength()
compareTo(o) toString() getMass()
compareTo(o)


Protein.groovy
‣ Problems:
- not easy to read

Protein common part Peptide
accessionCode sequence parentProtein
downloadFasta(ac) getLength() startPosition
toString() getMass() toString()
compareTo(o) compareTo(o)


‣ Instead of having two classes, we can have a third one
class AminoAcidSequence implements Comparable{
String sequence
int getLength(){...}
double getMass(){...}
int compareTo(o){...}
}


‣ Instead of having two classes, we can have a third one
class AminoAcidSequence implements Comparable{
String sequence
int getLength(){...}
double getMass(){...}
int compareTo(o){...}
}
‣ Then create Protein & Peptide classes that will inherit from
AminoAcidSequence + add their own field & methods
class Peptide extends AminoAcidSequence{
Protein parentProtein
int startPosition
String toString(){...}
}


‣ All the methods of the parent class are visible by the a derived class
instance
Peptide pept
...
double m = pept.mass
println pept.startPosition


instance
Peptide pept
...
‣ If a method is redefined by a derived class, it takes the precedence (e.g.
toString())


instance
Peptide pept
...
‣ If a method is redefined by a derived class, it takes the precedence (e.g.
toString())
‣ We can access to the ancestor class method: e.g. compareTo(o), from
the Protein point of view, takes into account the accessionCode, which
to do not exist at AminoAcidSequence Level:
def int compareTo(o){
return super.compareTo(o)?:
(accessionCode <=> o.accessionCode)

groovy & grails - lecture 5

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to groovy & grails - lecture 5

Similar to groovy & grails - lecture 5 (20)

More from Alexandre Masselot

More from Alexandre Masselot (8)

Recently uploaded

Recently uploaded (20)

groovy & grails - lecture 5

Editor's Notes