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

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Ähnlich wie Rails Scala Citec Presentation

Ähnlich wie Rails Scala Citec Presentation (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Rails Scala Citec Presentation