Rails Scala Citec Presentation

Experiences with
Languages other than Java

Kristian Domagala
CITEC Technology Day
10th October, 2008

Experiences with languages other than Java 1

© Workingmouse Pty Ltd 2008. All rights reserved

Background
Technology
●

Java/J2EE
–

Web client/server
–

WS*/XML/XSD
–

Processes
●

Agile
–

TDD
–



What is Ruby?
Dynamically typed
●

Interpreted
●

Object Oriented
●

Supports common functional idioms
●

Meta-programming
●

Promotes testing to replace type safety
●



Object Oriented
class Person class Employee < Person
attr_reader :name def initialize(name,email,salary)
def initialize(name,email) super(name,email)
@name = name @salary = salary
@email = email end
end def increase_salary(pct)
def email @salary *= pct
@email end
end end
end

emp = Employee.new(quot;Fredquot;,quot;f@xyz.comquot;, 50000)
puts emp.name + quot;: quot; + emp.email
emp.increase_salary(1.05)



Dynamic typing
class Person class Business
... ...
def email def email
@email @email
end end
end end

def spam(obj)
send_spam_to(obj.email)
end
spam(person)
spam(business)



Mixins (multiple inheritance)
module Payable
def pay(amount)
account.deposit(amount)
end
end

class Employee < Person class Business
include Payable include Payable
attr_reader :account attr_reader :account
... ...
end end
employee.pay(1000)
business.pay(100)



Meta-programming
Redefine class/method behaviour at runtime
●

method_missing
–

eval
–



RSpec
describe quot;Sending spamquot; do
it quot;should send to the person's email addressquot; do
person_mock = mock(quot;personquot;)
person_mock.should_receive(:email)
.and_return(quot;fred@xyz.comquot;)
spammer.should_receive(:send_spam_to)
.with(quot;fred@xyz.comquot;)
.and_return(true)

spammer.spam(person_mock).should == true
end
end



What is Rails?
Web application framework featuring
●

MVC
–

Active record
–

Template engine
–

Web server
–

Code generators
–

Extensible through plugins
●

Open source since 2004
●



Convention over Configuration
Controllers
●

public methods -> actions -> views
–

Model
●

class-name -> table, attribute -> column
–

auto fields like id, created_at, version
–

Minimal configuration required
●

Conventions can be overridden
●



Rails projects at Workingmouse



Experiences
Code base not very discoverable
●

Difficult to locate references and definitions
–

Unsure what effect code changes will have until
–
runtime



Experiences
Upgrades to framework/plug-ins risky
●

Test coverage not always adequate
–

Introduction of plug-ins risky
●

Can break assumptions on both sides
–



Experiences
Things aren't always what they appear to be
●

Item.tags
–

Array of Tag?
●

Array of tag names?
●

Comma separated list of tag names?
●



Experiences
Few “best practices” universally agreed on
●

Rails is very accessible
–

Strong, sometimes highly opinionated, community
–

Plethora of tutorials/blogs
–

difficult to sieve through
●

not always good advice!
●



Common rebuttal
Not enough tests!
●

Where do you stop?
–

TDD process doesn't catch all bugs
●

Maintaining tests
–

Language doesn't force tests
–

Code coverage tools not always adequate
●



Experiences
Still, able to get something up and running
●

quickly



IDE support
Eclipse/IDEA
●

syntax highlighting
–

some code-completion
–

some search capabilities
–

limited to ability due to dynamic language features
–

Interactive Ruby/Rails shells
●

Read Evaluate Print Loop capability
–



Appropriateness
Can be good for
●

“green-fields” small project development
–

prototyping
–

Had issues with
●

long running and non-trivial projects, especially
–

maintenance
●

unfamiliarity of code
●



Tips for starting
Up front study & experimentation
●

Books
–

Agile Web Development with Rails (tutorial)
●

The Rails Way (reference)
●

Communication
●

Pairing/spending time with experienced people
–

Research
●

Investigate basis of claims
–

Get both sides of the story
–



Questions?



What is Scala?
Statically typed
●

Object Oriented
●

Functional
●

Compiles to JVM byte code (.class files)
●

Open source
●

First release in 2003
–

2.0 released in 2006
–



Relation to Java
By design, Scala can do virtually everything that
●

Java can do
classes, methods, interfaces, statics
–

no forced exception handling
●

call Java APIs
–

Even the (arguably) bad stuff
●

nulls, down-casting, reflection
–



Example
class Person(
val firstName:String,
val lastName:String,
val birthYear:Int,
private var height: Int) {

val name = firstName + quot; quot; + lastName

def age(year: Int) = birthYear + year
def debug {
println(name + birthYear + height)
}
}



Language features
Type inferencer
●

First class functions and closures
●

XML literals
●

Type-safe tuples (allows multiple return values)
●

Traits (allows multiple inheritance)
●



XML literals
val bookElt =
<book title=quot;Scala for dummiesquot; year=quot;2008quot;>
<author>Martin Odersky</author>
<author>Tony Morris</author>
</book>

println(quot;Title: quot; + bookElt.attribute(quot;titlequot;))
(bookElt quot;authorquot;).foreach{a => println(a)}



Type-safe tuples
def nameAndYear(person:Person) =
(person.name, person.birthYear)

val ny = nameAndYear(person)
val firstInitial = ny._1.charAt(0)
val genX = (1968 until 1979).contains(ny._2)



Multiple inheritance
trait Payable {
def account:Account
def pay(amount:Int) {
account.deposit(amount)
}
}

class Employee extends Person class Business
with Payable { extends Payable {
def account = ... def account = ...
} }
employee.pay(1000)
business.pay(100)



Type system
Useful for detecting common bugs
●

Simple things like NullPointerExceptions
–

Through to enforcing concurrency constraints
–

Constraints can be better implied with types
●

Removes some of the need for defensive
●

programming
fail fast often done at the compiler
–



Scala projects at Workingmouse
Scoodi Ads engine
●

Scoodi online help webapp
●

Slinky web application framework
●



Experiences
To get full benefit, need to change the way you
●

think
Functional programming concepts difficult to get
●

a grasp of, but very powerful once understood



Experiences
Easy to trace code definitions and usage
●

Type system helps find dead code and prevents
–
invalid changes and assumptions
Sometimes difficult to get compiling
●

but more often than not, once it compiled it was
–
correct



Experiences
Scala to Java integration is practical
●

sometimes more type annotations and down-
–
casting required
Java to Scala integration theoretically possible
●

practical implications can make it infeasible
–



Java integration example
import javax.servlet.http._

class MyServlet extends HttpServlet {
override def service(
req: HttpServletRequest,
resp: HttpServletResponse) {

val name = req.getParameter(quot;namequot;)
...
}
}



IDE support
Eclipse/IDEA
●

primitive support (syntax highlighting)
–

plug-ins actively developed (esp IDEA)
–

buggy for our use
●

Interactive Scala shell
●

REPL capability
–

Can also use for invoking Java libraries
–



Appropriateness
Can be used anywhere that Java is used
●

Added benefits
●

better expressiveness with 1st class functions
–

safer code with type system and APIs that
–
encourage immutability
better rate of code reuse with higher kinds
–

less verbosity with syntax and inferencer
–



Tips for starting
Workingmouse Scala training course :-)
●

Start by imitating Java
●

Explicitly specifying types will help most compilation
–
issues
Full benefit of functional aspects made easier
●

by learning a pure functional language as well



Questions?



Thanks!

http://workingmouse.com
http://wiki.workingmouse.com



Rails Scala Citec Presentation

Recomendados

Recomendados

Más contenido relacionado

Similar a Rails Scala Citec Presentation

Similar a Rails Scala Citec Presentation (20)

Último

Último (20)

Rails Scala Citec Presentation