groovy & grails - lecture 1

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

?EOP : goal of the course

• Biological experiments produce huge amount of data (proteomics => TB)


• Excel/mouse data handling is the best path to psychiatric hospital


• Powerful computers (or even small clusters) are becoming more affordable


• Programming languages and frameworks more popular (scripts, web
applications, relational databases)


• Code is shared (open source culture)


• Code is shared (open source culture)

Goal of the this course:
make you efficient in the lab,
with a computer at you fingertips

?EOP: topics of this course

• Fall: Programming for Bioinformatics I for programming fundamentals



• Spring: get some independence and meet real life challenges



• By the end, you should be able to
• deploy your own development environment,
• write scripts to analyze data and give the scientist an answer,
• interact with other libraries,
• build a web application,
• build a relational DB model,
• have basic skills in software development methodologies.



• By the end, you should be able to
• deploy your own development environment,
• write scripts to analyze data and give the scientist an answer,
• interact with other libraries,
• build a web application,
• build a relational DB model,
• have basic skills in software development methodologies.

Just another tool in the box
(yet damned powerful!)

Efficiency Oriented Programming

• Efficiency = Result/Time


• Time:
• time spent in programming the tool
• time invested in learning the technology
• not only computing time (although it is important)


• Time:
• time spent in programming the tool
• time invested in learning the technology
• not only computing time (although it is important)
• Result:
• complexity of the produced code
• quality (functionalities, evolution etc.)
• versatility

EOP: why not Perl (this year)?

• “Perl is a language to get your job done” Larry Wall


• “Perl is a language to get your job done” Larry Wall

• To maximize efficiency, Perl has been perfect candidate:
• from eighties until now, a constant evolution,
• rich and direct syntax,
• dynamic community: >7’000 of public modules, often maintained, hight
quality (http://search.cpan.org),
• free (speech & beer),
• almost 100 OS supported (http://www.cpan.org/ports/index.html),
• perl is anarchist (and even poetic).


• Language are species following evolution patterns (no creationism)


• Thousands of languages exist (http://en.wikipedia.org/wiki/
List_of_programming_languages)


• Thousands of languages exist (http://en.wikipedia.org/wiki/
List_of_programming_languages)
• Recent trends for high level languages:
• syntax become more compact (and efficient),
• scripting is not incompatible with classic “structured” code (writing and
running),
• features, culture: cross-over between languages,
• language cooperation becomes a standard (parrot, .net)


For general purpose bioinformatics, several nominees:


• perl 5 : a historical choice, anchored in the community (bioperl etc.),


• java : structured, safe, heavy,



• python : a versatile language, allying strength from scripts up to object-
oriented models



oriented models
• perl 6 (rakudo) : a total re-designing of perl, by its original authors, a very
appealing option, but not yet a standard



oriented models
• perl 6 (rakudo) : a total re-designing of perl, by its original authors, a very
appealing option, but not yet a standard
• groovy (+grails) : a recent (2003) initiative, with powerful scripting manners
& tight links with java; grails offer a very light (although powerful)
framework for web development, RDBMS and Spring integration


There is no “one best language” for everyone and all situations,
but our winner (this year) is:

•compact syntax, either “free” or “controlled”, structured or object-oriented,
•modern web applications
•data naturally stored in relational database
•good software development practices are encouraged (agile)
•powerful IDE available



Groovy and Grails
•powerful IDE available



Groovy and Grails

Groovy+grails : setup

• integrated solution:
• install java 6 (sun) sdk
• install SpringSource Tool Suite (eclipse) http://www.springsource.com/
products/sts
• start STS
• help>dashboard,
• tab extensions

• install groovy and grails
• Launch trials environments, with either:
• groovysh
• groovyConsole

Groovy: a first script + string evaluation


Subroutines calls, parenthesis and ;
println (“hello world”); //java-like
println “hello world”; //end line with ;
println “hello world” //slim fast


Subroutines calls, parenthesis and ;
println (“hello world”); //java-like
println “hello world”; //end line with ;
println “hello world” //slim fast
String evaluation
/*
double quotes allow string evaluation
single quote no evaluation
looks perlish, huh?
*/
def name=‘Mickey Mouse’
println “hello $name” //=> hello Mickey Mouse
println ‘hello ‘+name //=> hello Mickey Mouse
println ‘hello $name‘ //=> hello $name

Defining variable: to type or not to type?

It is possible to define variable, without specifying their type
def x= 42.4 //dynamic type variable x,
//initialized with a float
x= ‘ola chico‘ //a string is assigned to the same x
x=[‘aa’, ‘bb’, ‘c’] //now an array...

Defining variable: to type or not to type?

It is possible to define variable, without specifying their type
def x= 42.4 //dynamic type variable x,
//initialized with a float
x= ‘ola chico‘ //a string is assigned to the same x
x=[‘aa’, ‘bb’, ‘c’] //now an array...

It is generally better to assign a type to a variable (security & readability)
int x=42 //static type set to integer
x=12.34 // => x=12 (implicit conversion)
x=[1, 1, 2, 3, 5] // => error: cannot convert
// (GroovyCastException)

More on implicit casting

Whenever possible groovy compiler tries to cast variable.


Why is the following correct (from the compiler point of view)?
String x=‘ola chico’
x=23.14
x=[‘a’, ‘b’, ‘c’]


x=23.14
x=[‘a’, ‘b’, ‘c’]
To know the class (the type) of a variable
println x.class


x=23.14
x=[‘a’, ‘b’, ‘c’]
To know the class (the type) of a variable
println x.class
What will produce the following statements?
int x=1
println x+2
String y=1
println y+2

And even more on type conversion

Casting can be called explicitly (TIMTOWTDI)
def my_str=‘123’
int x=my_str.toInteger()+10000
x=Integer.parseInt(my_str)
x=my_str as Integer
x=my_str //error!!!

And even more on type conversion

Casting can be called explicitly (TIMTOWTDI)
def my_str=‘123’
int x=my_str.toInteger()+10000
x=Integer.parseInt(my_str)
x=my_str as Integer
x=my_str //error!!!
Or back to String
String other_str=x.toString()
other_str=x as String
other_str=’’ + x //’’ force the casting
other_str=”$x”

Test the parameters type

Imagine we have not statically defined a variable type (argument to function)
x=23
if(x in Integer){ // true
...
}
23.45 in Double // false
23.45D in Double // true
23.45 in BigDecimal // true

‘pipo’ in String // true


x=23
...
}

More generally, we can detect numerical values
x in Number


x=23
...
}

More generally, we can detect numerical values
x in Number
and later
x in Map; x in List

Some available scalar types

Most commons types
int //or Integer
double //or Double
String
boolean //boolean b=true

Some available scalar types

Most commons types
int //or Integer
double //or Double
String
boolean //boolean b=true
And more
char //single character (‘a’)
byte //8 bit signed integer 0..255
short //16 bit signed integer
long //64 bit signed integer (123L)
float //32 bit floating point (1.23F)
double //64 bit floating point (1.23D)
BigInteger //large integer (123G)
BigDecimal //large float (1.23G)

Primitive type or Object?

In java, there is a distinction between int and Integer



In groovy, everything is Object



So we can call methods
String name=‘Mickey Mouse’
println name.length() // => 12
println name.substring(0,4) // => ‘Mick’
println name.endsWith(‘use’) // => true




“Hidden” methods
println name[5] // name.getAt(5)
println name[3..5] // name.substring(3,6)




“Hidden” methods
println name[5] // name.getAt(5)
println name[3..5] // name.substring(3,6)

The total list: in groovyConsole, launch Inspector on last evaluated
variable with ctrl-I -> methods tab (or http://groovy.codehaus.org/groovy-
jdk/, or google)

Operators

Some common operations can be written via operators
a+b a.plus(b)
a/b a.div(b) // 16/3 -> 5.33333333
a%b a.mod(b) // 16%3 -> 1
a++ a.next() // difference with ++a ?
a**b a.power(b) // 15**2 -> 225
a>>b a.rightShift(b)
a|b a.or(b) // 5|6 -> 7 (101|110 -> 111)

Operators

Some common operations can be written via operators
a+b a.plus(b)
a/b a.div(b) // 16/3 -> 5.33333333
a%b a.mod(b) // 16%3 -> 1
a++ a.next() // difference with ++a ?
a**b a.power(b) // 15**2 -> 225
a>>b a.rightShift(b)
a|b a.or(b) // 5|6 -> 7 (101|110 -> 111)
Later, we’ll see how these operators can be overridden

Exercise 1 : string for fun

• Initialize a String with ‘my funny valentine’
• what is the length of this string?
• assign a boolean to store if ‘fun’ is a substring

• replace ‘funny’ by ‘happy’
• convert this string to upper case
• split this string into a list, with one word per element ([‘MY’, ‘HAPPY’,
‘VALENTINE’])

• reverse this list ([‘VALENTINE’, ‘HAPPY’, ‘MY’])

Exercise 2 : integer and bit representation

• Touching the integer limit
• initialize an integer with 123
• what is the maximum value for Integer? the minimum value?
• replace it by itself to the power 3
• do the same thing once more. What do you observe?
• bit representation
• initialize an integer with 103 (binary 1100111)
• shift the binary representation by two steps on the right. What operation
is it equivalent two?
• shift it back to the left. What do you observe?

static method

Method can be bound to a object instance, e.g. :

String name=‘pipo’;
name.length()
They can also be bound to the class itself:
String str=‘23.45’
double b=Double.parseDouble(str) // 23.45D

Integer.bitCount(103) // 5

Other classes?

Beside intrinsic scalar value, there are millions of classes defined, and
thousands of them are available more or less by default.
Example : Random
Random my_rnd // -> null
my_rnd=new Random() // not null anymore
println my_rnd.nextDouble() // pseudo random in [0,1[
10.times{println my_rnd.nextBoolean()}

Exercise 3 : going random

• More with Random class
• is it possible for your computer to draw random numbers?
• what happen if your print my_rnd?
• draw 6 number with a gaussian distribution (µ=0, σ2=1)
• draw 6 number with a gaussian distribution (µ=170, σ2=25)
• draw a classic dice 10 times
• draw the sum of two dice 10 times
• what happen is you reproduce the same experiment many times? is the
results the same? how could have reproducible results?

Exercise 4 : have a date

• Using the Date class
• assign to a variable the current date
• print the just the second (60 seconds per minute) value of the current
date
• assign your variable with one week ago
• get the month of one week ago as an integer
• is now after yesterday? (this is a boolean question, not an existentialist
one)
• is now equals to now? always? (how date is coded?)

Collective types : List & Map

Dynamic typing is still possible


For List (or array)
def fibonacci=[1,1,2,3,5,8,13]
fibonacci=[] //empty list


For List (or array)
def fibonacci=[1,1,2,3,5,8,13]
fibonacci=[] //empty list
Or Map (or HashMap, or associative array)
def medals = [us:36, germany:30, canada:26, norway:23]
medals = [:] //empty map
def medalsDetails=[
us:[gold:9, silver:15, bronze:13],
germany:[gold:10, silver:13, bronze:7],
canada:[gold:14, silver:7, bronze:5],
norway:[gold:9, silver:8, bronze:6],
]

Collective types (cont’d)

Or static type
List<Integer> fibonacci
Map<String, Integer> medals
Map<String, Map<String, Integer>> medal_details


Or static type
List access
fibonacci[0] // first element
fibonacci[-1] // fibonacci[fibonacci.size()-1]
fibonacci[2..4] // [2, 3, 5]


Or static type
List access
fibonacci[0] // first element
fibonacci[-1] // fibonacci[fibonacci.size()-1]
fibonacci[2..4] // [2, 3, 5]
Map access
medals.canada == medals[‘canada’]
medal_details.norway.gold ==
medals_details[‘norway’][‘gold’]


Add or modify
fibonacci[7]=21 //add a new element
medals.canada.gold=97 //modify
medals.us.gold-- //anti doping control...


Add or modify
Other methods
fibonnacci.size()
medal_details.germany.size()
medal_details.remove(‘germany’)


Add or modify
Other methods
fibonnacci.size()
medal_details.germany.size()
medal_details.remove(‘germany’)
Operators are also available
fibonacci << 34 //push 34 at the end
fibonacci - 1 //remove all values 1

Exercise 5: arrays

• fills an array with a few values
• what is the difference between array+12, array<<12 and array+=12?
• print the sum, the maximum value
• store the reversed array into another one
• sort the array with increasing values. With decreasing values.
• A last little one
• remember the 10.times{...} syntax we saw previously
• put [1, 1] in a fibo array, then fill this array with the 20 next value os
a Fibonacci suite, where fibo[n+1]=fibo[n]+fibo[n-1]

groovy & grails - lecture 1

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (15)

Ähnlich wie groovy & grails - lecture 1

Ähnlich wie groovy & grails - lecture 1 (20)

Mehr von Alexandre Masselot

Mehr von Alexandre Masselot (6)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

groovy & grails - lecture 1

Hinweis der Redaktion