PhilCali Code v0.1

Do You Speak Cronish?

2011-05-10T12:25:00.002-05:00

A while back, I spoke about writing a cron dsl. Well, some progress has been made.

Invocation

How do you talk about cron? Do you say that a job runs every day at midnight? Well if you do, then you need no further instructions on how to create your crons programmatically. Some example of some crons:

Update: I should have run the text in the console before output wrong data.

"Every day at midnight".crons == "0 0 * * *"
"Every 14 days at midnight".crons == "0 0 */14 * *"
"Every day on the weekday in June, July, and August at 3:30".crons == "30 3 * 6,7,8 1-5"

We all speak cronish to some degree!

The Syntax

One night, I decided to break down a cron statement into some determinable blocks. I came up with the following grammar rules:

Incrementing statements
Connectors
Values / Descriptors

Incrementing Statements

Incrementals is the keyword every. This produces the famous *. Any numeric value you punch in after every makes it one of these: */n. A cron statement must start with one of these. Therefore, the shortest incremental time you can do, is something like:

// second, minute, hour, day of month, month, day of week, year
"Every second".cron == Cron("*", "*", "*", "*", "*", "*", "*")

Connectors

The connectors I've chosen help make an English sentence regarding a cron job clear. Here's the run down:

at refers only to time, which includes seconds, minutes, and hours. ie: at 4am and 4pm
on refers to day values, particularly day of week values. ie: on Friday, Saturday, and Sunday
in refers to month values. ie: in January to May
on the nth refers to day of month values. ie: on the 1st, 2nd, 3rd, and 4th day
in the year n is special syntax for a year value.

Connectors can be strung together with other connectors or incrementals. Some examples would be:

"Every day at midnight in every month".crons ==
"Every month at midnight on every day".crons

"every year in July on the weekend at 1pm-4pm".crons ==
"every day on the weekend at 1pm-4pm in July".crons

Just follow the simple rules, and it's pretty easy to build your time.

Values / Descriptors

Descriptors are just more keywords we use in English to describe something. These are:

midnight and noon
n:n:n for full clock description.
other in the incrementals instead of 2.
am and pm for hours.
st, nd, rd and th for days in the month.
weekend and weekday
last applies for day of week and day of month.

The values are either numeric or English values for fields. Days are Monday - Sunday, months are January - December, and day of month are simply numbers.

Scala Cron Job

Describing a cron job in pure Scala is also done through dsl type speak. The syntax is heavily borrowed from sbt's task creation.

val payroll = task {
  println("Getting paid today ... with virtual cash!")
} executes "every Friday on the last day in every month"

// And we're off!
// Alternatively you could have written it like this

val visitation = task {
  println("Greetings, my name is Mouth Mouthman.")
}

visitation executes "every Wednesday at 6pm"
visitation executes "every Sunday at 3pm"

// Kill a job with stop
payroll stop // Oh noes!

Where do we go from here?

There's a lot of work that still needs to happen before this could be released. Cronish is freely available at my github. I'm working towards a stable release.

-- Philip Cali

99 Problems

2011-04-12T21:26:00.000-05:00

I ran across an awesome blog post today titled Programming Problems To Improve Your Language Skills. I never actually wrote anything in Haskell yet, but I thought that solving the Ninety-Nine Lisp Problems was a great way to start. That's the point of this post. There is, however, a goofy Scala snippet that's in order first.

Scala Snippet

It's a funny thing, logical operators. In php and python, if you want to test that this something is true and that something is true, you'd simply write if this and that. Very straight forward. Those of us coming from C understand that && and || represent and and or respectively. I never actually questioned it... that's just the way it was.

My wife is taking a beginner CSC class at university, and when she saw &&, she simply read it as and-and.

What's does "and-and" mean, and I never seen those vertical things before...

A very natural response. In Scala, we can change this!

class BooleanExpression(origin: Boolean) {
  def and (expr: => Boolean) = origin && expr
  def or (expr: => Boolean) = origin || expr
}

implicit def boolean2BooleanX(some: Boolean) =
  new BooleanExpression(some)

Now your conditional sound very natural:

if (file.exists and something)
  println("Yeeeeee")

val x = 5
if(x > 4 and (x < 10 or x > 100))
  println("We got it anyway")

It is important to note that this is less efficient. It is, however, cool.

Haskell Problems

And here's the first 20 problems, almost. I skipped a couple, but I plan on going back to it. I tried not to use Prelude with all the pre-defined list functions, but it still doesn't hurt when the goal is to learn a language.

-- problem 1
my_last :: [a] -> a
my_last (x:[]) = x
my_last (x:xs) = my_last xs

-- problem 2
my_but_last :: [a] -> [a]
my_but_last (x:y:[]) = [x, y]
my_but_last (x:rest) = my_but_last rest

-- problem 3
element_at :: [a] -> Int -> a
element_at xs i = head [y | (x, y) <- zip [0..] xs, x == i]

-- problem 4
count :: [a] -> Int
count xs = foldl (\acc x -> acc + 1) 0 xs

-- problem 5
rev :: [a] -> [a]
rev [] = []
rev (x:xs) = rev xs ++ [x]

-- problem 6
palindrome :: (Eq a) => [a] -> Bool
palindrome xs = if(rev xs == xs) then True else False

-- problem 7

-- problem 8
compress :: (Eq a) => [a] -> [a]
compress [] = []
compress (x:xs) = [x] ++ compress(dropWhile(== x) xs)

-- problem 9
pack :: (Eq a) => [a] -> [[a]]
pack [] = []
pack (x:xs) = [[x] ++ takeWhile (== x) xs] ++ pack(dropWhile(== x) xs)

-- problem 10
encode :: (Eq a) => [a] -> [(Int,a)]
encode xs = [(count ls, head ls) | ls <- pack xs]

-- problem 11

-- problem 12
decode :: (Eq a) => [(Int, a)] -> [a]
decode xs = concat . map (\el -> let (times, i) = el in repl i times) xs

-- problem 13

-- problem 14
dupe :: [a] -> [a]
dupe [] = []
dupe (x:xs) = x : x : dupe xs

-- problem 15
repl :: [a] -> Int -> [a]
repl [] _ = []
repl (x:xs) n = map (\_ -> x) [1..n] ++ repl xs n

-- problem 16
dropr :: [a] -> Int ->[a]
dropr xs i 
  | count xs < i = xs
  | otherwise = let (headr, (_:rest)) = splitAt (i - 1) xs in headr ++ dropr rest i

-- problem 17
split :: [a] -> Int -> ([a], [a])
split xs n
  | n == 0 = ([], xs)
  | count xs < n = (xs, [])
  | otherwise = (take n xs, drop n xs)

-- problem 18
slice :: [a] -> Int -> Int -> [a]
slice xs from to
  | from == 1 && to == count xs = xs
  | from > to = []
  | otherwise = [x | (index, x) <- zip [1..] xs, index >= from && index <= to]

-- problem 19
rotate :: [a] -> Int -> [a]
rotate xs n = let index = if n < 0 then count xs + n else n
                  (first, second) = split xs index 
              in second ++ first

-- problem 20
remove :: [a] -> Int -> [a]
remove xs n = [x | (i, x) <- zip [1..] xs, i /= n]

Had it All Wrong

2011-04-01T16:17:00.000-05:00

Development comes in spurts. Even though I'm in the middle of several personal projects, sometimes a simple change in pace really helps. I took a break from coding to dive in some Haskell (some break). I ran across an online book, published by Miran Lipovaca, that looked fun and interesting enough to learn the language: Learn You a Haskell for Great Good.

I read through five chapters last night, only to discover that I should have learned Haskell before learning Scala. I now see how much concepts Scala has pulled from Haskell. My opinions on the experience thusfar will be expounded on after the jump.

For the Great Good, Indeed

The more I understand about Haskell, the more I love it. Due to my time learning Scala, I feel very at home with the language. The point of this post is to observe similarities with the two, as I go about learning.

The last chapter I read was about recursion, something I understand very well at this point. As Miran describes, the poster child for Haskell is the quicksort implementation.

quicksort :: (Ord a) => [a] -> [a]  
quicksort [] = []  
quicksort (x:xs) =   
    let smallerSorted = quicksort [a | a <- xs, a <= x]  
        biggerSorted = quicksort [a | a <- xs, a > x]  
    in  smallerSorted ++ [x] ++ biggerSorted

Now a side by side Scala implementation...

// Need this for Haskell like Ord type
implicit Ordered._

def quicksort[A: Ordering](ls: List[A]): List[A] = ls match {
  case Nil => Nil
  case x :: xs =>
    val (smaller, bigger) = xs partition(_ <= x)
    quicksort(smaller) ++ List(x) ++ quicksort(bigger)
}

The Breakdown

Time for a line by line comparison.

// Haskell
quicksort :: (Ord a) => [a] -> [a]  
// Scala
def quicksort[A: Ordering](ls: List[A]): List[A]

The first line is Haskell's way of defining a function. quicksort takes a single parameter, which is a list of type a defined to be Ord. It will return a list that is type a. More specifically, it will return a sorted one.

The Scala implementation does just as well.

// Haskell
quicksort [] = []  
// Scala
ls match {
  case Nil => Nil

The seeming redefinition of quicksort is simply constructing a pattern match. That bit of Haskell specifically states: Given an empty list, an empty list will be returned.

In Scala, you have to be a bit more explicit in your declaration of a pattern match, initiated by the keyword match. A match expression will return something (in this case, we've explicitly defined its type as a List[A], so we better do that). Staying true by our line by line analysis, should ls be Nil (or empty), return empty.

// Haskell
quicksort (x:xs) =   
// Scala
  case x :: xs =>

Should the input parameter be a non-empty list, extract the head of the list from its remainder, and do some work. A singleton list will be extracted thusly:

x:[]

Scala supports pattern matching and extraction in its pattern matching very similarly. If a Scala object defines an unapply method then you can take advantage of this behavior. Once again, we see how Scala caters to this way of thinking.

// Haskell
    let smallerSorted = quicksort [a | a <- xs, a <= x]  
        biggerSorted = quicksort [a | a <- xs, a > x]  
// Scala
    val (smaller, bigger) = xs partition(_ <= x)
// Optional rewritten like so
    val smaller = quicksort(xs.filter (_ <= x))
    val bigger = quicksort(xs.filter (_ > x))
// Scala for comprehensions
    val smaller = quicksort(for(a <- xs; if a <= x) yield(a))
    val bigger = quicksort(for(a <- xs; if a > x) yield(a))

Haskell is binding some variables to use in its in statement which we'll go into in a minute. Haskell has incredible list comprehensions. You can filter, pattern match, use let expressions, etc.

Scala's answer to Haskell's list comprehensions, is the for comprehension. For this example, though, it's a bit overkill. List's in Scala inherit from a Traversable type which comes with powerful operations: map, zip, filter, reduce, to name a few.

We're almost done.

// Haskell
    in  smallerSorted ++ [x] ++ biggerSorted
// Scala
    quicksort(smaller) ++ List(x) ++ quicksort(bigger)
// Or other implementations above
    smaller ++ List(x) ++ bigger

Haskell will now use the bindings set before and work. Haskell will do its work lazily, which is awesome.

Scala list concatenation with other Lists is done exactly the same way as Haskell.

Pretty cool. I'm looking forward to learning more.

-- Philip Cali

Dropbox Documentation Server

2011-03-26T21:07:00.000-05:00

What does this even mean? Well, it means I'm really cheap, and lazy. It probably means I'm silly, too, when I tell you what I'm doing.

First, a back story is in order. I was reading some internet articles the other day, when completely irrelevantly, I thought of making my Public Dropbox folder a static web site. Dropbox has a really neat desktop tool that syncs a folder on your machine to their cloud storage, automagically. Being that the site would be static, I started to wonder what I could even do with it. Then I realized: this is perfect for a documentation server! (Maybe not!)

Step 1: Getting the Docs

Sbt is a wonderful build tool. It can generate really nice API documentation with a single command. The only thing about these docs, is that they're not pretty to look at. Docco on the other hand, produces some really nice looking documentation. The circumflex crew already ported their re-imagination of docco style documentation for scala.

I made quick work into building a sbt plugin that simply wraps the circumflex batch docco functionality with a single docco action within sbt.

Step 2: the Plugin

Like I mentioned before, all this plugin (initially) would need to do, is piggy back off the circumflex docco project to do batch docco processing on the project's src directory. Enter sbt-cx-docco.

In a developer's project definition, they can route the docco output to a specific folder. Naturally, for this experiement, I routed it to my Public Dropbox folder on my local hard drive.

I am thinking more about this, and I have more plans for this plugin that involves severing my circumflex dependency. You may or may not see about this in the future.

Step 3: ???

I have no idea what else I have planned for this thing. I'm thinking about setting a monido that looks at the folder, and adds the project to the list for me. This depends on how lazy I get, I guess.

Step 4: Profit!

A free static web server. Pretty good, Dropbox... Pretty good.

-- Philip Cali

Monido, What?

2011-03-15T11:14:00.000-05:00

I've been working on a little project called Monido, which is simply a monitoring service for Scala. It can monitor anything from a file, a directory, a DB table, or web page. I think you get the picture.

The project, however, only ships with a single reference implementation to monitor the file system for changes. I'm using it for this very post at this moment. More on that later.

The Program

I explained in an earlier post that I write my blog entries in markdown, and store them in a git repo. I have since modified that BloggerBot script to only inject the html source in my clipboard when it runs. The command looks like:

java -jar blogbot.jar ~/notes/posts/24.md

Monido can automate this procedure:

monido ~/notes/posts -e java -jar blogbot.jar

Every time I save this post, I get:

Writing conversion to your clipboard ....
Done.

This saves me a few key strokes!

The -e argument for monido is essentially like using the pipe for a Unix system. The full file path of the changed file is passed to the terminal argument, and immediately run. Monido defines itself as a pure JVM, cross-platform solution to file monitoring.

monido ~/some/other/thing -e ls -l

Monido can spawn recursive monitors, although this practice is discouraged on using a large directory tree. Your operating system does this for you, so you should use that instead. Jnotify is a good Java wrapper around these OS events.

Monido is not just a file monitoring service, though! This is where the good part begins.

The Library

Monido's infrastructure is very flexible, being that it's comprised of two (optionally three), components. These components are:

PulsingComponent
MonitorComponent
ListeningComponent (optional)

The explanation of these components are given on the Monido github page:

A PulsatingComponent is something that wakes the MonitorComponent to do something. A PulsatingComponent could wake it at set intervals, once a day, manually, etc. The MonitorComponent will simply monitor whatever it was told to monitor (The FileMonido reference implementation monitors the file system.) Optionally, the Monitor can notify a client of a change (or anything else really) by making use of the ListeningComponent.

Lots of moving parts that have arbitrary dependencies make it a great candidate for some DI.

Now, I will show you how to do a DBMonido, just for fun.

import com.github.philcali.monido._

// First we need to define the DBMonitor by extending the
// MonitorComponent.
trait DBMonitorComponent extends MonitorComponent {
  this: ListeningComponent[Adapter] =>
  // Let is connect via a db string
  class DBMonitor(db: String) extends SimpleMonitorDevice{
    def connect: Adapter = // connect to db
    def pulsed {
      // Making a fictional query
      val results = connect.query("SELECT COUNT(id) as count from entries")
      if(results("count") >= 9000) listener.changed(connect)
    }
  }
}

// Define Monido now
object DBMonido extends Monido with ListeningComponent[Adapter]
                               with DBMonitorComponent 
                               with PulsatingComponentImpl {

  // This object will NOT compile until dependencies are met
  val listener = new MonidoListener {
    def changed(db: Adapter) {
      // Clear records
      db.query("TRUNCATE entries")
    }
  }

  // the MonitorComponent expects a monitor value to be defined
  val monitor = new DBMonitor("jdbc:sqlite:test.db")
  // Next the PulsatingComponent expects a pulsar value to be defined
  // Sneal peak at 0.2 Scalendar syntax
  import com.github.philcali.scalendar._
  val pulsar = new Pulsar(1.day.inMillis)
}

DBMonido.start
// And we're off!

This is a pretty silly example of checking a record once a day for the change you're looking for, but now I'll show you how easy it is to configure the Monido. Say now I wanted to use a different pulsating implementation. I'll use a fictitious CronPulsing implementation that uses a cron string for its configuration.

// Re-define the DB monido
object DBMonido extends Monido with ListeningComponent[Adapter]
                               with DBMonitorComponent 
                               with CronPulsing {
  ...
  // same as before. The monitoring component worked great, so
  // leave it alone.

  // Sneak peak at the cron project
  import com.github.philcali.cron._
  val pulsar = new CronPulsar("every Sunday at midnight".cron)
}

DBMonido.start
// And we're off!

So there's your Monido. I don't know how useful it could be to everyone else, but I find myself in need of Monido's pretty often.

-- Philip

Scalendar v 1.0

2011-02-23T16:49:00.001-06:00

Update

It is now hosted on both scalendar's github page, and on scala-tools. It was approved a couple of days ago, and hopefully, other people might find it useful.

As I worked on my wife's ipad app, I kept refining my Scala Calendar wrapper (which I coined Scalendar thanks to brad). It began to evolve into a really nice api, in which you work with immutable objects that wrap the Java Calendar api. While it completely interoperates with Java time, it works well enough as a stand-alone library.

The main functionality like date traversal and property getters haven't changed from the last post. If you're interested, read more about the changes after the jump.

Construction

My biggest issue with the version I was working with, was the ability to make time. As I began to use it throughout the app, I began to realize rather quickly that it was indeed the biggest issue.

// Now to convert from strings, you need to define
// a SimpleDateFormat, or just use the Pattern object

import com.philipcali.utils.calendar._

// If you don't plan on converting strings
// to time, then simply import
// import com.philipcali.utils.Scalendar

// A global implicit will do
implicit val pattern = Pattern("M-d-yyyy")

val monthsAlive = ("11-19-1985" to Scalendar.now).delta.months

// Creation from now
val now = Scalendar.now

// "Setters"
// It completely integrates with java.util.Calendar
import java.util.Calendar._

val endOfWorld = now.year(2012).month(DECEMBER).day(21)

val countdown = endOfWorld to now

"t %d days" format(countdown.delta.days) // t -667 days

"There's only %d months left!" format(countdown.reverse.delta.months)

// Optional, the "make time" syntax:
val made = Scalendar(year = 2012, month = DECEMBER, day = 21)
val madeMore = Scalendar(year = 2012, 
                         month = DECEMBER, day = 21, hour = 23)

made < endOfWorld // true, made 0's out anything below the day
madeMore < endOfWorld // false, because hour was set

// Of course time can be built with unix timestamp
val fromLong = Scalendar(Scalendar.now.time)

// Below is an eample of interaction with a DB and
// formatting the results via a duration traversal
val duration = Scalendar.now to Scalendar.now + (3 months)

// Fictional DBO querying
val events = Event.find (
  Event.userid === "philip.cali",
  Event.created > duration.start.time,
  Event.created < duration.end.time  
)

// Format events for each month
duration.traverse(1 month) { monthD => 
  // It's entirely possible to get more granular
  // but that's overkill for this example
  println("Events in %s" format(monthD.month.name))
  events.filter(e => monthD contains(e.created)) foreach(println)
}

I got rid of the hasNext method, as that typically requires state, and the Scalendar class is completely immutable. I've made use of Scala 2.8 package objects, and completely realized how valuable it was when I wanted to save imports by placing my implicit conversions in there. Now the clients get a rather robust date api just by importing Scalendar.

The code will be on my github very soon. I have to rip the api out of the project I'm currently using it in and create a separate project. One gave birth to the other.

Manipulating time

2011-02-11T11:05:00.000-06:00

Handling time using the standard Java libraries can be a real pain. I am writing a webapp that uses pretty complicated date arithmetic, and while Java's Calendar object works, clients of the library are forced to work with a mutable object, thus being rather verbose to accomplish a simple task.

Enter ScalaCalendar to save the day! I began writing a Scala wrapper for the Java Calendar object, and I'm mostly happy how it turned out. Here's an example of how it works:

// Importing the base ScalaCalendar object like so
// allows you to do some pretty powerful things.
import com.philipcali.calendar.ScalaCalendar._

// Let's work with the simple things
val rightNow = java.util.Date() // or createTime() or "now"
val tomorrow = rightNow + 1 day
val nextMonth = rightNow + 1 month
val yesterday = rightNow - 1 day   

// Generate a duration is rather simple too
val span = rightNow to (rightNow + 1 week)

rightNow isIn span // returns true

rightNow isWeekend
rightNow isWeekday

span.delta.days // returns 7
span.delta.months // returns 0

// Calendar fields
// Your standard field have a name method
// which tries to define the field in English
rightNow.time == rightNow.millisecond
rightNow.second.value
rightNow.minute.value
rightNow.hour.value
rightNow.day.value
rightNow.day.inWeek
rightNow.day.inYear
rightNow.week.value
rightNow.week.InYear
rightNow.month.value
rightNow.year.value

// Work with strings
val allFeb = "2/1/2011" to ("3/1/2011" - 1 day)

// This is where it gets good:
// A duration is traversable by any other duration
span.by(1 day) foreach { dayDuration
  println(dayDuration.day.name)
}

// Only work with MWF days
val mwf = span.by(1 day) filter(_.day.name match {
  case "Monday" | "Wednesday" | "Friday" => true
  case _ => false
})

// Only weekends
span.by(1 day) filter(_.isWeekend) foreach { time =>
  println("Partying it up on %s!" format(time.day.name))
}

// Using this logic, building a calendar table is painless
val calHtml = 
<table> {
  "2/1/2011".calendarMonth.traverse(1 week) { weekD =>
    <tr> {
      weekD.traverse(1 day) { dayD =>
        <td>{ dayD.day.value }</td>
      }
    }</tr>
  }
}</table>

// There's convenience methods for generating a Calendar month
// week, and day
"2/1/2011".calendarMonth // contains 1/30/2011 - 3/5/2011
"2/1/2011".calendarWeek // contains 1/30/2011 - 2/5/2011
"2/1/2011".calendarDay // contains 00:00:00 - 23:59:59

// You can even traverse a timespan in reverse
val countdown = ("2/28/2011" to "2/1/2011").by(1 day) map(_.day.value)
countdown.take(5).mkString(",") // "28,27,26,25,24"

// Traverse a duration at your own space
val february = "2/1/2011" to "2/1/2011" + (1 month)

while(february.hasNext) {
  february.next(1 day)
  // do something
}

// Construct something wacky
// This gets the weekdays every other week in the month
for(days <- february.by(1 week); if(days.week.value % 2 == 0)
     day <- weeks.by(1 day); if day.isWeekDay) {
  println(day.day)
}

The by method splits the durations into a lists of durations, while the traverse method splits and applies a function you give to transform that duration into something meaningful. The ScalaCalendar integrates with java.util.Date and java.util.Calendar seamlessly.

Most people will probably look at this and face palm, but it satisfied my needs for this particular project quite nicely.

I'm going to release the calendar api on my github account very soon.

-- Philip Cali

Three Programming Languages

2011-01-26T20:34:00.000-06:00

I ran across this post a few months ago, that I recently given some more thought to while making supper. (Funny how the brain works isn't it?) I've come up with my "three" programming languages as of this writing, and I'd like to share them with you.

The author classifies the three programming languages every one must know:

The Happiness Language
The Hack-it-out / Get Things Done language
The Bread and Butter language

I disagree with the author that there needs/should to be a difference for all three languages. In my experience, there's really no difference between the Happiness and GTD language. To me, if you can quickly solve the problem with the language in your head, then you can simply type it out and execute it quickly, thus getting it done. Anyway...

I think there are three languages, though:

The language you can quickly solve problems with (call it Happiness, GTD, whatever). For me, this is Scala. This language makes me happy, and I've recently wrote a script that calculates an average for a dataset for work rather quickly.
The language you get paid to work in. While I can solve problems the fastest in Scala, I'm glad there a distinction for me. I get paid to work in PHP, and it makes my stomach turn a little to define a body of an anonymous function with a string (pre 5.3 code base). I'm glad my precious Scala is free from the political stress and red tape at my 9 to 5. This keeps Scala safe and happy.
The language you desire to learn more about. Having used Scala for more than two years, I can honestly say I wish I knew Scala more than I do now. I learn something new about the language on every new personal project I work on, and I feel I'm only starting to scratch the surface of some greater potential.

So there you have it. I do believe broadening your programming language knowledge makes you a more versatile problem solver, to a certain extent. Ultimately, I think problem solving skills are sharpened like any other skill set: solving problems. People just use learning a programming language as an excuse to tackle a new problem differently.

On a slightly different note, I laughed aloud when someone commented on aforementioned blog post: Javascript is your happiness language? Are you a serial killer?

I would say that with PHP, as I think looking at variables starting with the dollar sign is torture to the visual sense. When I program in PHP the goal is to make it as terse as possible with a billion helper functions to avoid those awful dollar signs.

-- Philip Cali

Who needs a Template Engine?

2011-01-23T21:03:00.000-06:00

My wife commissioned me for another web app this weekend, and we spec'd it out using an app on her iPad (We both had a lot of fun). I wanted to prototype this sucker as quick as possible, and to be frank, my template engine I wrote for Scalatra wasn't cutting it. It dawned on me rather suddenly, something my former co-woker mentioned to me in passing.

"Scala supports in-line XML literals... Why not just go with that?"

And here I am almost a year later, saying to myself: Huh... you have an excellent point....

Why not, indeed. Using raw Scala as my template engine, I get some great benefits right out of the box, which I will elaborate a little later. First I want to address the big negative aspect.

Web Designers would hate me

If a web designer (non-Scala coder) had to build an interface using this method, they would probably shoot me, or want to anyway. The purpose of a web template is explained quite beautifully here. And while this new proposed method achieves this goal, but they'd have to compile Scala code to see changes. Ouch!

Let's take a look at what I mean, though. Let's just say, a designer was instructed to format a blog post. All they would have to do is this:

object BlogPost extends Template[Post] {
  def template(post: Post) = {
    <div class="post">
      <div class="post-header">
        <h1>{ post.title }</h1>
      </div>
      <div class="post-body">
        <p>
          { post.body }
        </p>
      </div>
    </div>
  }
}

Now in a Scalatra servlet, rendering this template is rather simple:

get("/single/:id") {
  val post = Post.get(params("id"))
  BlogPost(post)
}

Scala is the Template Engine

Why bother building functionality for conditionals and loops, when the language supports this already. All I had to do was build a simple inheritance system that makes it easy to wrap templates in templates (for headers and footers and such). I was amazed at some of the implicit benefits this granted me:

I know if my template is valid at compile-time! Scala won't even compile invalid XML literals. Very cool.
My templates can be Unit Tested! Not sure how useful this is yet, but it's possible :P
I don't have to learn another web template language! Hoo-ray!

Now, I'll spend less time talking about this switch, and more time prototyping the app.

Just for kicks, let's see more of it in action:

object HomePage extends WrappedTemplate {
  val master = MasterTemplate 

  def wrapped(context: Context) = context match {
    case Context(_, posts: List[Post]) =>
    <div id="content">
      <div id="posts">
        { posts.map(BlogPost(_)) }
      </div>
    </div>
  }
}

object MasterTemplate extends ParentTemplate {
  // I don't really like this, but it works for now
  def template(data: (WrappedTemplate, Context)) = data._2 match {
    case Context(title: String, _*) =>
    <html>
      <head>
        <title>{ title }</title>
      </head>
      <body>
        { wrapped(data) }
      </body>
    </html>
  }
}

// In Scalatra servlet
...
get("/") {
  val posts = Post.find()
  HomePage(Context("title" -> "Home", "post" -> posts))
  // Optionally, use can use this shorthand
  // HomePage(NoKeyContext("Home", posts))
}

(FYI, I'm not prototyping a blog. Code here is strictly for example purposes.)

-- Philip Cali

Remote Control v0.1 Alpha

2011-01-17T14:41:00.000-06:00

The remote control package has finally reached an alpha stage today. The library includes ways for a server program to give client programs a way to change its behavior on the fly, or to run arbitrary code on command, and receive values from those arbitrary commands.

It all started here, which brought us there. The last post in the series provided a way to inject a program's context into potentially dynamic portions of the server application. I have since refactored the library to make the client side interaction much easier.

I thought it would be easier for me to describe the library calls and use cases with code samples.

Dynamic

The dynamic call has been refactored into something that makes more sense than the previous way.

// Back to the old way, sweet!
dynamic('code) {
  println("Potentially dynamic code, without context preservation")
}

// With Context
val name = "Charlie Murphy"
dynamic('code, Context("name" -> name)) {
  println("My name is %s" format(name)
}

// Shorthand
dynamic('code, name) {
  println("My name is %s" format(name)
}

I have removed the need to pass a function that takes in a Context. This is redundant. What ever is inside the dynamic portions will know the context. I've provided a shorthand which takes in a varargs of Any.

Update

The update syntax got the most improvements.

update('code) { ctx =>
  println("There is no context, so I will speak in riddles")
}

// The update pulling values from the context
// with the key
update('code) { ctx =>
  val name: String = ctx("name")
  println("%s and I" format(name))
}

// The update applying a partial function 
// and uses Scala extractors to pull values
update('code) {
  case Context(name: String) => 
    println("Your name is not %s" format(name.reverse))
}

Reset

I've given the client the ability to reset the dynamic portion to its default state. A simple call to reset will do it.

// Back to "My name is Charlie Murphy"
reset('code)

Prepend and Append

There may be times a client doesn't want to change the dynamic portion, only add something directly before or after it. That's where prepend and append come in handy. For example:

// Takes a Context like update
prepend('code) { ctx =>
  println("Hey!")
}

append('code) { ctx =>
  println("What's yours?")
}

// When dynamic is called it will now print
// Hey!
// My name is Charlie Murphy
// What's yours?

Remote Control

That's it as far as changing a server's behavior from a client program. The next part of this post is show to how control a server from a client program. The main difference between changing behavior and controlling a server, is what the client can expect from a command. If you are still confused, think of it this way:

If you worked in the fast food industry, and your manager told you until further notice to inform customers who order a specific menu item, "We don't serve your kind here." Star Wars references aside, you, the application, changed your original behavior from serving everyone to rejecting those who order a specific item on the menu. Let's change gears now.

Your manager is thirsty, and yells, "Hey, Mikie, pass me a cold one!" He was looking at you when he spoke, so even though your name isn't Mikie, you do what your told immediately.

That is the key difference between behavioral modifications and commands.

Any server application can handle remote commands by inheriting from the RemoteControlled trait. An easier way to see this is through the scala irc robot.

import remote.RemoteControlled

class Scalabot extends Pircbot with RemoteControlled {
  override def id = 'scalabot
   // The rest is the same
  ....

To interface with the robot remotely, the client package would use the Controller object to connect and sent signals, like so:

import control.Controller._

// A remote Controller will provide itself as default context
connect('scalabot) signal {
  case Context(self: Scalabot) =>
   self.joinChannel("#scala") 
}

I provided a more complex example, to show how to retrieve data from the remote controller. A client can receive data in two ways:

through the signal method
through the signalFuture method

The signal method will try to return a response immediately, if your signal returns anything at all. The signalFuture method will immediately return a function containing the result. (This is quite literally the future. It's a function that will apply itself until the value is there). Here's the example of a client program that wants exported data from the ircbot.

import ircbot.ScalaBot
import context._
import control.Controller.connect
import signals._

object Main extends Application {
  // Computation signal takes in an optional description
  // used for logging purposes
  val compSig = Computation({
    case Context(self: ScalaBot) =>
      // Dump db as csv
      val results = self.db.query("SELECT * FROM chats")(_.executeQuery())

      results.map(_.values.mkString(","))
  } /*, "Running function which returns csv data" */)

  connect('scalabot) signal(compSig) match {
    case Some(Response(csv)) =>
      val writer = new java.io.FileWriter("chats.csv")
      csv.asInstanceOf[List[String]].map(_ + "\n").foreach(writer.write)
      writer.close()
    case _ => println("This means we did not get a response back")
  }
}

I ran the client package after chatting a few times, and the results was a chats.csv on my local machine.

1295284140634,schmee,Testing my chats
1295284147310,schmee,Doing some more chats
1295284161032,schmee,philbo is my robot

All in all, it works. I have a few more features I want to add to it, but I'm happy with it so far.

-- Philip Cali

Dynamicism with Context Preservation

2011-01-13T15:27:00.000-06:00

In my last post I talked about changing some code in real time. One of the problems with my current approach was the loss of the program context. If we are using my Scalabot example, this means that I can make no changes to ScalaBot from the dynamic portions, not dynamic calls, etc. I was limited to interacting with a constant data store. I have since tweaked my library which allows for context preservation, if context is important to the dynamic call.

The signature changed from:

dynamic('symbol) {
  // Block of code
}

To:

dynamic('symbol, Context("variable" -> variable)) { ctx =>
  // Block of code
}

// Or if context is unimportant
dynamic('symbol) { ctx =>
  // Block of code
}

The update signature hardly changed. A context is always passed into a dynamic block now. It could be an empty context, but a context nonetheless.

update('symbol) { ctx =>
  if(!ctx.params.isEmpty) {
    // Grab stuff from context, and operate
    val x = ctx("variable")
    // do something with x
  }
}

I'll show you how I used it to turn my ScalaBot against its master. It's always more fun to witness the AI get a mind of its own, and destroy everything. Taking a look at the dynamic block from yesterday, let's preserve the context.

dynamic('message, Context("bot" -> this, "sender" -> sender)) { ctx =>
  println("A message posted from %s" format(sender))
}

Once again, I chatted a couple times, before I turned my bot against me.

import ircbot.ScalaBot
import hotcode.HotSwap._

object Main extends Application {
  update('message) { ctx =>
    val bot: ScalaBot = ctx("bot")
    val sender: String = ctx("sender")

    sender match {
      case "schmee" => bot.sendMessage("#pircbot", "schmee is a loser. Don't listen to him")
      case _ => println(sender)
    }
  }
}

This time I truly changed the bot's behavior, because I have a reference to the bot itself. I knew before going into this, that the presentation of this library would take a hit, but I thought the end result was worth it. I've decided to sell this library a little differently. It's more of a remote control library. Hot swapping is not possible with it, but I like what it does.

I have an idea of some additional code to allow more remote controlling. Will get to that later.

-- Philip Cali

Real-Time Solutions via ScalaBot

2011-01-12T21:01:00.000-06:00

I was talking about a pseudo hot swapping solution in my last post. I briefly spoke of its potential, but at the time of its writing, I wasn't even sure it would solve problems. I decided a good way for me to find out if it was capable of solving those problems, would be to build something with it.

The first decent scenario I could think of, was to program a little ircbot whose behavior I could change on the fly. The more I thought it, the more I was convinced that it would be a perfect fit. So here's the spiel:

Let's say I want to read the #scala irc logs every day. Yes, I'm that much of a dork. This much of the requirement I knew into building the program, and hurried to launch the app. Well, after three days of reading logs, I'd like for my little robot to do something a little different upon each message it receives. In a normal situation, this would require me to logout of the channel, and put the other up. I could potentially miss a nugget from Martin Odersky, which could have horrible consequences. So, the best case scenario would be if I could have my changes without missing a beat.

Now that I got my scenario lined up, I went to look for some java irc client out there. After evaluating several irc libraries out there, I ran across PircBot. It was hosted on maven, which was a win for me and sbt.

I threw together this simple class (and look, it uses my db adapter!), which simply logs into an irc channel, and stores every message into a sqlite database:

import org.jibble.pircbot.PircBot
import hotcode.HotSwap._

class ScalaBot(name: String) extends PircBot {
  this.setName(name)
  this.setLogin("philip")

  val db = Adapter("org.sqlite.JDBC", "jdbc:sqlite:chats.db")

  db.exec("""CREATE TABLE IF NOT EXISTS chats (
              timestamp INTEGER,
              sender STRING,
              msg TEXT)""")(_.execute()) 

  override def onMessage(c: String, sender: String, login: String, h: String, msg: String) {
    db.exec("INSERT INTO chats VALUES (?, ?, ?)") { stm =>
      stm.setLong(1, System.currentTimeMillis)
      stm.setString(2, sender)
      stm.setString(3, msg)
      stm.execute()
    }

    dynamic('message) {
      println("Post hook for dynamic message processing")
    }
  } 
}

Yes! Raw SQL... I'm lovin' it! (Clears throat)

I want to draw your attention to the dynamic call. Notice, right now, it's wrapping a trivial println statement. I'm the kind of programmer, who programs back-doors in every application. Can you Imagine the security risks? I digress...

I launch the application as is, because it solves my first problems. I now want to change it's behavior after it stores a message. Here's where we get to the good stuff.

I used freenode's web app to log in as a human. There's an empty channel (thankfully) at #pircbot where you can test your bots. A playgoround full of robots. I chatted some random things as the user "schmee", and sbt printing out what you'd expect:

[info] Post hook for dynamic message processing
[info] Post hook for dynamic message processing

Great. So at least I know it's running what's in the dynamic block. The following segment is going to change that (fingers crossed).

import hotcode.HotSwap._

object Main extends Application {
  update('message) {
    val db = Adapter("org.sqlite.JDBC", "jdbc:sqlite:chats.db") 
    val message = db.single("SELECT * FROM chats ORDER BY timestamp DESC LIMIT 1")(_.executeQuery())

    println(message)
  }
}

I run that, and chat a couple times more. Low and behold, my sbt output:

[info] Map(timestamp -> 1294867472648, sender -> schmee, msg -> Something special)
[info] Map(timestamp -> 1294867517142, sender -> schmee, msg -> trying it again)

It works, but there are some notable problems. The context is all lost. It works great if I'm reading from a datastore, or changing values in the datastore. I can't really change the bot itself though. I have some ideas about how to address this, but I think the presentation is going to take a hit. At any rate, I was pleased to see it work this well.

Scala Hot Swapping (Pseudo Hot Swap)

2011-01-11T10:40:00.000-06:00

I wrote some library code recently, triggered by a post I read. The gist of the author's post was to compare Scala and Erlang. I actually agree with him. I want to bring your attention to where I come into this, Hot code swapping.

I created a library capable of swapping out dynamic code, particularly run on a server. If I want to change behavior of some code without having to recompile the code and reboot the server, I should be able to do this.

My first attempt at this was more of a proof of concept, but it does work. Now, it's more of a pseudo hot swap solution, involving remote actors in the internal Scala library.

Here's some example of the client code in question.

import com.philipcali.hotcode.HotSwap._

def log(s: String) { 
  // logs text to file appender 
}

for(i <- 1 to 10) {
  println("Iteration %d" format(i))
  dynamic('main) {
    log("Potentially dynamic code")
  }

  // Sleep for a second so I can inject some code
  Thread.sleep(1000)
}

The control construct dynamic is what we zero in on. The code inside that block is stored on a RemoteActor. Now, a few seconds later, we want to change it.

import com.philipcali.hotcode.HotSwap._

def log(s: String) { 
  // logs text to file appender 
}

update('main) {
  log("Just been injected!")
}

The call to update here, replaces what's currently running with whatever is in the update code block. Under the covers, nothing is lost. The RemoteActor is actually storing revisions of the dynamic code, which can be replaced at any given time.

If we look at the resulting output in our logged file:

Potentially dynamic code
Potentially dynamic code
Potentially dynamic code
Just been injected!
Just been injected!
Just been injected!
Just been injected!
Just been injected!
Just been injected!
Just been injected!

So there you have it: pseudo hot swapping. The dynamic code here is hardly dynamic, because everything is compiled, but changing behavior to an application should be fairly painless. Now, to do what the author wanted in that comparison post (which was to simply add a log line), you don't have to shutdown the server!

Nano Time is Here!

2010-10-30T09:27:00.000-05:00

And you know what that means: an attempt to write another book! I've written up some thoughts on my characters, locations, and important what not's on Google Docs in anticipation.

Last time I participated, I wrote my entire novel in vim, segregating my chapters into different files. There's really not much else you need than that... Or so I thought.

I'm taking a rather different approach this year. I'm using the nerd tree plugin to keep better track of my chapters. The big change, however, is that I'm writing all my chapters in markdown. Through markdown, I'm provided with all the snazzy text formatting I need, but it's still plain text. I plan on writing a simple script to strip the markdown for the final paper submission. There's a good reason I'm writing the book in markdown...

You see, there's an awesome e-book management tool called calibre. I got this program to manage e-books on my wife's iPad, and they also offer a way to add books that anyone written into the Books app through various formats. I found the plain text format needing much modification to get it to look right on the device. Calibre's html support, on the other hand, is incredible, but who wants to write all those nasty tags. This lazy programmer intends to convert his markdown to html. //End third person speech.

I have an update on the cron DSL I've been working. Stay tuned on my adventure about building grammar rules (try to keep your eyes open)!

-- Philip Cali

DSL Magic

2010-10-25T08:08:00.001-05:00

Updated: Work is being done for a cron dsl work on my project cronish. Check it out... fork me... I'm open to suggestions.

I have never taken a strong interest in creating DSL's before tinkering with Scala. I had an eye opening experience this weekend, that originated as a joke.

I've recently taken an interest in the Harry Potter series. Other Potter fans may also know that the next one in the series is coming out next month. On my birthday, in fact.

I wanted to write a program that simply let me ask my computer when the movie was coming to theaters. Scala is perfect for this. The DSL was thrown together in a hurry, so I am not particularly fond of the underlying code, but the finished product was this:

scala> import com.philipcali.potter.dsl._
import com.philipcali.potter.dsl._

scala> When is "Harry Potter and the Deathly Hallows: Part 1" coming out?
Harry Potter and the Deathly Hallows: Part 1 is coming out in 24 days!

scala> When is "Harry Potter and the Deathly Hallows: Part 1" in theaters?
Harry Potter and the Deathly Hallows: Part 1 is coming out in 24 days!

What exactly is the point? I can ask my computer when a movie is coming out casually, and it will tell me... through Scala. The DSL is rather pointless for a Scala programmer. Using this simple DSL, a non programmer could code something, and that is the point I am getting to. The usefulness behind the DSL.

That's when it hit me!

A cron DSL. Imagine being able to do something like this:

scala> val schedule = "every day at 1:00pm".cron
schedule: java.lang.String = "0 13 * * *"

scala> "every half hour on the 19th of November".cron
res0: java.lang.String = "30 * 19 11 *"

scala> "every hour on every Thursday in December, January, and February".cron
res1: java.lang.String = "0 * * 12,1,2 4"

Once the parser is created, configuring a scheduler through annotations, actors, or other third party software would be a piece of cake. I plan on using Scala's built-in support for language parsing to achieve this goal. And a new project was conceived.

-- Philip Cali

BDD and ScalaTest

2010-09-29T09:02:00.000-05:00

I've read a good bit about ScalaTest and BDD before, but I actually used it for the first time on a particular project I'm working on at the moment.

The code in question was a bit of utility code that simply extracts a zip archive or archive's a directory (a basic packaging utility). Writing a spec for this was very easy.

Given an archive, extracting it should produce the known directory structure.
The extracted contents should be the same as the known contents
Archiving should produce an archive of directory
Archive should be valid (ie: no errors on extracting)

That's four quick ones. Below, I have the spec written out as a ScalaTest. I couldn't help but to have a big, goofy smile when I ran it through sbt.

package test

import org.scalatest.{FlatSpec, BeforeAndAfterAll}
import org.scalatest.matchers.ShouldMatchers
import Zip._

class ZipSpec extends FlatSpec with ShouldMatchers with BeforeAndAfterAll {
  import java.io.File
  val archivePath = getClass.getClassLoader.getResource("archive.zip")

  override def afterAll(configMap: Map[String, Any]) {
    def recurse(file: File)(fun: File => Unit) {
      if(file.isDirectory) 
        file.listFiles.filter(f => !f.getName.startsWith(".")).foreach {
          recurse(_)(fun)
        }
      fun(file)
    }

    // Delete temp files
    recurse(new File("archive")) { _.delete }
    recurse(new File("temp")) { _.delete }
    new File("../archive.zip").delete
    new File("archive.zip").delete
  }

  "Test archive" should "exists" in {
    val archive = new File(archivePath.getFile)
    archive should not be (null)
  }  

  "Extract" should """create directory tree: 
  archive/ 
  archive/child/ 
  archive/child/more.txt 
  archive/test.xml""" in {
    extract(archivePath.getFile)

    // Checking Dir tree
    new File("archive") should be ('exists)
    new File("archive/test.xml") should be ('exists)
    new File("archive/child") should be ('exists)
    new File("archive/child/more.txt") should be ('exists)
  }

  it should """create a new directory tree:
  temp/archive
  temp/archive/child/
  temp/archive/child/more.txt
  temp/archive/test.xml""" in {
    extract(archivePath.getFile, "temp")

    new File("temp/archive") should be ('exists)
    new File("temp/archive/test.xml") should be ('exists)
    new File("temp/archive/child") should be ('exists)
    new File("temp/archive/child/more.txt") should be ('exists)
  }

  "Extracted flat files" should "contain correct data" in {
    import scala.xml._
    import scala.io.Source.{fromFile => open}

    val xmltext = <stuff>
  <more-stuff>Test</more-stuff>
</stuff>
    val text = "You'll never find me!"

    XML.loadFile("archive/test.xml") should be === xmltext
    open("archive/child/more.txt").getLines.mkString should be === text
  }

  "Archive" should "create archive.zip" in {
    archive("archive")

    new File("archive.zip") should be ('exists)
  }

  it should "create archive.zip in parent directory" in {
    archive("archive", "../")

    new File("../archive.zip") should be ('exists)
  }

  "../archive.zip and archive.zip" should "be the same size" in {
    val parentzip = new File("../archive.zip")
    val archivezip = new File("archive.zip")

    parentzip.length should be === archivezip.length
  }

  "Extracting archive.zip" should "not throw any exceptions" in {
    extract("archive.zip")
  }
}

Here's example output from sbt's execution of the test spec.

[info] == test.ZipSpec ==
[info] Test archive
[info] Test Starting: Test archive should exists
[info] Test Passed: Test archive should exists
[info] Extract
[info] Test Starting: Extract should create directory tree:
[info]   archive/
[info]   archive/child/
[info]   archive/child/more.txt
[info]   archive/test.xml
[info] Test Passed: Extract should create directory tree:
[info]   archive/
[info]   archive/child/
[info]   archive/child/more.txt
[info]   archive/test.xml
[info] Test Starting: Extract should create a new directory tree:
[info]   temp/archive
[info]   temp/archive/child/
[info]   temp/archive/child/more.txt
[info]   temp/archive/test.xml
[info] Test Passed: Extract should create a new directory tree:
[info]   temp/archive
[info]   temp/archive/child/
[info]   temp/archive/child/more.txt
[info]   temp/archive/test.xml
[info] Extracted flat files
[info] Test Starting: Extracted flat files should contain correct data
[info] Test Passed: Extracted flat files should contain correct data
[info] Archive
[info] Test Starting: Archive should create archive.zip
[info] Test Passed: Archive should create archive.zip
[info] Test Starting: Archive should create archive.zip in parent directory
[info] Test Passed: Archive should create archive.zip in parent directory
[info] ../archive.zip and archive.zip
[info] Test Starting: ../archive.zip and archive.zip should be the same size
[info] Test Passed: ../archive.zip and archive.zip should be the same size
[info] Extracting archive.zip
[info] Test Starting: Extracting archive.zip should not throw any exceptions
[info] Test Passed: Extracting archive.zip should not throw any exceptions
[info] == test.ZipSpec ==
[info]
[info] == test-complete ==
[info] == test-complete ==
[info]
[info] == test-finish ==
[info] Passed: : Total 8, Failed 0, Errors 0, Passed 8, Skipped 0
[info]
[info] All tests PASSED.
[info] == test-finish ==

As inevitably a part of testing an archive utility, the test code will create a bunch of files we don't want. Fortunately for us, ScalaTest comes with a BeforeAndAfterAll trait for us. I just to needed override afterAll in this case, where I put the code to remove what was created.

I feel the immediate advantage of this test framework is that the test code itself quite literally explains what's going on. Once I got the spec written, refactoring the implementation code was breezy (which is characteristic of unit testing in general).

Consider me a ScalaTest convert. I doubt I'll ever write a traditional unit test again.

-- Philip

LWJGL / SBT plugin example app

2010-09-13T15:22:00.001-05:00

I decided to try out my new plugin for my new work environment, and my nephew has been frequently inquiring to make him a video game, but I particularly enjoy my free afternoons. I thought a good way to test the plugin and appease the little guy, was to simply write a small game!

I'll be the first to admit that I'm not a game programmer. Far from it. It requires a different way of thinking , and to frank with everyone: I'm not very good at it! I would, however, be lying if I said I wasn't itching to make another game. It has been over a year since I used LWJGL and Slick to make Scetris, so I thought a quick Tic-Tac-Toe game was in order. (Don't shoot me for my baby steps!)

Suffice to say, all three were accomplished relatively quickly.

The sbt-lwjgl-plugin works great! The speed I was able to have this project up and running was hardly comparable to that of my previous eclipse work environment.
This was a great exercise getting back in the swing of things, as they say. Slick makes making a simple game like this rather breezy.
I think my nephew will enjoy the little game.

Here's a screenshot. If the game looks like I spent a couple of hours on it, then mission accomplished.

-- Philip

LWJGL / SBT plugin

2010-09-09T12:04:00.000-05:00

So I created a LWJGL / sbt plugin today, thanks to this rather simple-but-awesome blog post I read. I also added a little nugget for developers using Slick, which is a simple trait for slick dependencies. It is probably more silly than useful, but it was easy enough to add.

This project spawned because my aggravation in having to develop games in sbt. Fortunate for me, someone had encountered a similar issue.

The plugin, and more information about the plugin, can be found on github: sbt-lwjgl-plugin.

-- Philip Cali

Streamlining Appengine Development

2010-09-02T10:19:00.001-05:00

So I have a few apps on appengine. I have my beautiful wife to thank for that. I never planned on deploying anything other than a silly blog on it before she came in my life, coming up with awesome ideas. She would mention in passing, "I wish there was an app for x on my ipad". Chances are, there would be, but it would cost a dollar or two. I know that does not sound like much, but I always look for an opportunity to expand the brain a little. So I write her apps.

All my apps prefice with 1337, which I coined the leet suite:

1337 Shop list: Your standard shopping list app. You can share with people, and anyone with a Google account can use it.
1337 Flashcard: Your standard flashcard app that uses html 5 transitions, and stuff.
1337 Todo list: Your standard todo list with Google Calendar integration (which actually is not done yet).

They all support a mobile (specifically iPhone) version, and a desktop version. Through out all this, I have made several libraries to help roll these guys out, and I was using eclipse to build and deploy the builds. I will digress now.

Eclipse is a monster. On my Macbook pro, eclispe alone consumes 1 gig of the 1.7 gigs I have available. This is the cool thing about Eclipse: it dies when there is no memory left to consume.

So I was in this frustrating cycle of coding, watching that blasted beach ball, coding, crashing, launching eclipse, waiting, waiting, waiting, coding, watching the beach ball, crashing.

There has got to be a better way, right!? There is! Over the past year, I have converted all the home grown scala projects to use sbt.

The sbt/git eco-system, is very inviting. My biggest complaint about coding Scala in vim was the lack of auto (method/field) complete ability, and seeing compile errors as I typed.

But I figured it was time to grow up. I combined terminal multiplexing (screen) with vim and sbt. I now code, compile (build), and deploy all from the command-line. This type of work environment has alleviated a lot of the memory over head to run eclipse, combined with the fact that I learned a few things about vim and screen.

Now all I have to do to roll out a new appengine app with all my libraries, is:

git clone ssh://user@domain/var/git/appengine_scaffolding.git new_app
cd new_app
git rm -rf .git
sbt
[info] Building project appengine_scaffolding 1.0 against Scala 2.8.0
[info]    using AppengineScaffoldingProject with sbt 0.7.4 and Scala 2.7.7
> update
> dev-appserver-start -p 8888

Direct my browser to http://localhost:8888, and bam! That is all.

Some immediate advantages:

Learning more about sbt. I love that build tool. You configure your build and dependencies all through Scala code.
Learning more about screen. I have used screen for years. I love screen. On a day to day basis, I could get by with few open terminals, create, remove, rename, etc. Screen is very complicated. It allows you to split your view horizontally or vertically. This feature is very nice with sbt. I can reload or compile in sbt, and have the source file in my view right above it.
Learning more about vim. Vim is something else I used for years. I learn something new about it every week, it seems.
The appengine sbt plugin. A must get if you plan on doing similiar sbt/scala appengine development.

I realize this post was more about advertising than anything. Sorry if it bored you to death.

-- Philip

Moved!

2010-09-01T12:59:00.005-05:00

So I ported all the content from my old blog, and started one here hosted by Google. I have been so impressed by Google, and all their online services. They are good to their customers, and really good to developers, what with all the libraries.

Gdata
Appengine
Online services (gmail, calendar, contacts, map, blogger, etc)

I converted all my previous posts from html to markdown. Markdown is a nice readable markup language in its default state, which is easily converted into other formats. While I trust Google with a lot of things, I always like to have physical backups of all my posts.

So I store all my posts in my personal git repo, in multiple markdown files. Cool enough. There is a really nice webapp with javascript Markdown to html conversion, called Showdown. I could paste my markdown, convert it, then copy and paste the converted html into Blogger.

But I am a developer, who is also very lazy. I wrote a small script that transforms a markdown file into html, and loads the converted text into my clipboard for pasting into Blogger.

For those interested, the code for this script is below:

package com.calico.blogger.BlogBot

...
import com.petebevin.markdown.MarkdownProcessor
import scala.io.Source.{fromFile => open}
import grizzled.util.{withCloseable => withc}

object BlogBot {
  def writeToClipboard(text: String) {
    val clipboard = Toolkit.getDefaultToolkit.getSystemClipboard
    val str = new StringSelection(text)
    clipboard.setContents(str, null)
  }

  def main(args: Array[String]) {
    if(args.size < 1) {
      println("Please provide me a text file to convert from markdown to html")
    }   

    // Remove the <code></code> protions
    val regex = """<code>|</code>""".r

    // Add syntax highlighting
    val brush = """<pre>""".r

    val m = new MarkdownProcessor
    val markdown = m.markdown(open(args(0)).getLines.mkString("\n"))

    val nocode = regex.replaceAllIn(markdown, "") 
    val ret = brush.replaceAllIn(nocode, """<pre class="brush: scala; toolbar: false;">""")

    // Write to file
    println("Writing conversion to file: out.html ....")
    withc(new FileWriter("out.html")) { w =>
      w.write(ret)
    }   

    // Write to clipboard
    println("Writing conversion to your clipboard ....")
    try {
      writeToClipboard(ret)
      println("Done.")
    } catch {
      case e: Exception => println("Failed ... " + e.getMessage)
    }   
  }
}

So the process is made quite simple with scala, sbt, vim, and screen. I like working in pure command-line these days.

This is a post to inform people that I am still alive, and doing development on the side.

-- Philip

Quotes with Actors Part II

2009-06-11T10:26:00.000-05:00

This is where we'll be getting to the good part. For those of you are just now joining, the part one of the this series can be found here. Today I'm going to be talking about how to make those communicating actors cross JVM, cross machine, cross platform. By changing a our code base a bit, and make use of the RemoteActors, we can achieve our goal.

So let me give you a scenario. Let's say Steve has an extensive collection of video games quotes that he thought were generally entertaining, and his buddy Bill has an extensive collection B-movie Sci-Fi quotes he thought were entertaining. Steve read a few of Bill's random quotes; low and behold, even he was entertained! But here's the problem: Steve doesn't want to pollute his quote collection with Bill's quotes, but he want people to know about Bill's quotes, when people connect to his quote server.

In the last post we had a quote generator that would start an actor and loop away. Since we've established a client/server terminology, let's take that code and make it accessible over the wire.

import scala.actors.Actor._
import scala.actors.RemoteActor._
import java.util.Random

class QuoteServer(val port: Int, val name: Symbol) {
  lazy val quotes = ... // Load our quotes from the "store"

  val generator = actor {
    alive(port)
    register(name, self)
    val rnd = new Random()
    loop {
      react {
        case Request() => {   
          val (who, said, from) = quotes(rnd.nextInt(quotes.size))
          sender ! Quote(from, who, said)
        }   
      }   
    }   
  }
}

alive and register are methods on the object RemoteActor. One tells the actor to stay alive on a particular port, and the other registers the actor (in this case, self). That's basically it! Now we just need some code that kicks off that process to try it out.

scala> import calico.quotes.server.QuoteServer
import calico.quotes.server.QuoteServer

scala> import calico.quotes.client.Request
import calico.quotes.client.Request

scala> val server = new QuoteServer(9090, 'local)
server: calico.quotes.server.QuoteServer = calico.quotes.server.QuoteServer@1742c56

scala> server.generator !? Request()
res0: Any = Quote(Suikoden II,Luca Blight,"I've chopped hundreds,
 thousands of necks. I can do it with my eyes closed!")

Now I haven't demonstrated the remoteness yet, but it's all set up to work properly. The attentive would have noticed that the Request case class was moved to a client package. Some client some make a request. Remember, we are trying to make request over the wire. Sounds like it could be difficult right?

import scala.actors.remote.{Node, RemoteActor}

case class Request()
case class Quote(from: String, who: String, what: String)

class QuoteC(ip: String, port: Int, val name: Symbol) {
  private val remote = RemoteActor.select(Node(ip, port), name)

  def quote = { 
    remote !? (1000, Request()) match {
      case Some(Quote(from, who, what)) => what + "\n" + " - " + who + " from " + from
      case _ => "No quotes! Sorry... Is the server up?"
    }   
  }
}

We changed a couple of things from out last implementation, most notably, the use of the RemoteActor. The !? operator is overloaded with ability to set a timeout. Since we're dealing with remote activity, we don't want a request attempt to block the process. Instead, we just give the user a nice generic error message, for simplicity's sake.

Without show some implementation code of this simple library, we can do something like this:

> java -jar quote_server.jar
Please enter a port and server name

> java - jar quote_server.jar 9073 video_games
Starting server 'video_games on port 9073...

Let's try to connect.

> java -jar quote_client.jar
Welcome to the quote REPL
> /connect 127.0.0.1 9073 video_games
Connecting to 'video_games server
> /quote
"I've chopped hundreds, thousands of necks. I can do 
 it with my eyes closed!"
- Luca Blight from Suikoden II
> /exit
Goodbye!

I went ahead and threw the client implementation in a loop for kicks, but a quote server can act as a client to other quote servers with a small change.

...
case Request() => { 
   val (who, said, from) = quotes(rnd.nextInt(quotes.size))
      sender ! Quote(from, who, said)
}   
case ServerList(ls) => sender ! ServerList(QuoteC.servers)
...

Now we have a way to return a server list from this server, so it's possible for a client to "hop" around from server to server, or a server to create categories with server lists, etc. The point is: a distributed quote server system can appear localized from a single client connection. This is exactly what we wanted from our example implementation.

Some things to note:

We could easily make and online interface by using the lift web framework.
Concurrency is achieved by one quote server being able to handle several concurrent request.
Going remote is easy!
There are several implementations one can make with our little library.

This was an example of how one make use of the RemoteActor's in their code. It may not be the best example, but it's a good place to start in understanding how it works.

-- Philip

Quotes with Actors Part I

2009-06-04T10:03:00.000-05:00

Several months ago, I got serious with the Scala Actor library, and quickly fell in love. Very little data is required to thread together your application with actors, and make you feel like a rawk star ;) This is part one of a two part series covering some assets of the scala actor library. First, we'll be looking at how to incorporate actors in code, then how to make application communication with RemoteActors.

The application we're going to make is a quote generator. Clients would send a request for a random quote, and the application will send a quote in the form of a string, formatted like so: "What was said" - Who said it from Where. With those requirements, we can come up with a couple of case classes for this simple application.

case class Request()
case class Quote(from: String, who: String, what: String)

What are case classes? In Scala, a case class definition is shorthand for this:

object Quote {
  def apply(from: String, who: String, what: String) = new Quote(from, who, what)
  def unapply(q: Quote): Option[(String, String, String)] = Some(q.from, q.who, q.what)
}
class Quote (val from: String, val who: String, val what)

Case classes are used for pattern matching, which the actor library makes heavy use of. The unapply is required for extracting, an incredible convenience for pattern matching. You can see that appending case in front of your class saves yourself a lot of typing.

If we go back to our requirement, it said: Clients would send a request for a random quote. A verb and a noun. Similar to: a browser makes a GET and displays the response. So the next step is to make a quote "server" with a running actor.

import java.util.Random
import scala.io.Source.{fromFile => open}
import scala.actors.Actor._

val quotes = { 
  (for(line <- open("resources/quotes.txt").getLines;
    val split = line.split("=")) yield((split(0), split(1), split(2)))).toList
}

val generator = actor {
    val rnd = new Random()
    loop {
      react {
       case Request() => {
         val (who, said, from) = quotes(rnd.nextInt(quotes.size))
         sender ! Quote(from, who, said)
      }
    }
  }
}

Alright let's break this up. The first thing I'm doing is getting a list of tuples from a text file that contains our quotes. We'll call that our "store" of quotes in val quotes. I imported everything from object Actor, but we're only concerned about actor, loop, react, and sender.

The actor method takes in a body of code, instantiates an Actor class, and starts our actor. It's not enough that our sever starts. The server is required to run as long as we need it.
That is where loop comes in. loop takes in a function, calls that function and repeats itself. It is a never ending loop, which is exactly what we want.
react takes in a function and applies it to any message the actor receives in its mailbox. This is where pattern matching is key. Our server is only concerned about quote requests. In the event that our server has received a request, it grabs a random quote from the store.
Think of sender being the from address on the mail. Our server says "send this quote to the sender of this request." That is done by the ! operator and the Quote case class to the right of it.

Now all we need is a client to make that request. The client code would look something like so:

generator !? Request() match {
  case Quote(from, who, what) => what + "\n" + " - " + who + " from " + from
  case _ => "No quotes! Sorry :("
}

The !? operator is like a send/receive method. It sends the generator a request and receive a Quote. In the event that it's not a quote (which it should always be), return an "error" string. All we do now is some formal wrapper of the code above, and we got a random quote generator.

package calico.quotes

import scala.io.Source.{fromFile => open}
import scala.actors.Actor._
import java.util.Random

case class Request()
case class Quote(from: String, who: String, what: String)

object QMachine {
  val quotes = { 
    (for(line <- open("resources/quotes.txt").getLines;
        val split = line.split("=")) yield((split(0), split(1), split(2)))).toList
  }

  val generator = actor {
    val rnd = new Random()
    loop {
      react {
        case Request() => {
          val (who, said, from) = quotes(rnd.nextInt(quotes.size))
          sender ! Quote(from, who, said)
        }   
      }   
    }   
  }
  def apply() = new QMachine(generator)
}

class QMachine(generator: scala.actors.Actor) {
  def quote = { 
    generator !? Request() match {
      case Quote(from, who, what) => what + "\n" + " - " + who + " from " + from
      case _ => "No quotes! Sorry :(" 
    }   
  }
}

Now we run this through sbt (Simple Build Tool; I highly recommend that you build all Scala projects with it), we can fire up the console and test it out.

scala> import calico.quotes.QMachine
import calico.quotes.QMachine

scala> val qm = QMachine()
qm: calico.quotes.QMachine = calico.quotes.QMachine@952527

scala> qm.quote
res0: java.lang.String = 
"Let me tell you something. There are weak men and strong men 
in this world. The strong men take everything and the weak men die. 
That's how the world was designed. Now I will show you how it works, weaklings!!!"
 - Luca Blight from Suikoden II

scala> qm.quote
res1: java.lang.String = 
"I've chopped hundreds, thousands of necks. I can do it with my eyes closed!"
 - Luca Blight from Suikoden II

scala>

Ah, nothing like uplifting quotes from RPG's most ruthless villain, Luca Blight. Some things to notice about our quote generator implementation through actors are:

The "client" knows about our "server", but our server could care less about the client. This separation is great, and largely popularised by the MVC paradigm.
A few lines of code, and we can make our quote server send quotes over the wire with RemoteActors.

And this is about it. Stay tuned for part two, when we make this "remote."

-- Philip

Factorial goofiness

2009-05-11T10:00:00.003-05:00

It's Monday afternoon, and it's time for a silly post. Have you ever been browsing the Internet, looking at something completely code irrelevant, yet something struck you: "I bet I could do this in X language"? I saw a tshirt that said "factorial!", when something like that hit me.

Using some of the power of Scala, I'm going to make a factorial look like it does in math books. Meaning, when you see the phrase 4!, it should evaluate to 24. Well, let's just get a factorial function to work first.

scala> def fac(n: Int) : Int = if(n == 0) 1 else n * fac(n -1)
fac: (Int)Int

scala> fac(4)
res0: Int = 24

There's our logic! I want to use a bang operator though. I want it to be a "true" factorial resemblance. If I want a bang operator, I'll need to have my own class.

scala> class Fac(val i: Int) {
     | def fac(n: Int): Int = if(n == 0) 1 else n * fac(n - 1)
     | def ! = fac(i)
     | }
defined class Fac

scala> val test = new Fac(4)
test: Fac = Fac@1d9d55b

scala> test!
res1: Int = 24

Well, now. That's starting to look right, but there's still this thing: new Fac. I want to get rid of that as well. I mean, I just want to type 4!, and it will result in 24. This can be done through implicit conversions.

scala> implicit def int2Fac(n: Int) = new Fac(n)
int2Fac: (Int)Fac

scala> 4!
res2: Int = 24

And that's it! A pretty stupid example, but this example shows us several things:

An example showing off operator overloading.
An example showing optional periods and parenthesis in method calls.
The reason for implicit conversions, and a perfect use case.

A fun example for a Monday.

-- Philip

Simplifying the JDBC

2009-05-04T15:34:00.000-05:00

The title of this post may raise some brows, but I mean what I say. You see, I do a lot of little batch scripting with sqlite databases, and since Scala is my scripting language of choice (as of this writing), I interact with the JDBC API quite a bit. In my situation, it would be silly to import all the 3rd party libraries that make it simple (the big ones being Spring JDBC and Hibernate). Allow me to show you what I mean...

For those of you who haven't ever interacted with JDBC, or forgotten completely, allow me to enlighten you. The following was taken from sqlite JDBC homepage:

import java.sql.*;

public class Test {
  public static void main(String[] args) throws Exception {
      Class.forName("org.sqlite.JDBC");
      Connection conn = DriverManager.getConnection("jdbc:sqlite:test.db");
      Statement stat = conn.createStatement();
      stat.executeUpdate("drop table if exists people;");
      stat.executeUpdate("create table people (name, occupation);");
      PreparedStatement prep = conn.prepareStatement(
          "insert into people values (?, ?);");

      prep.setString(1, "Gandhi");
      prep.setString(2, "politics");
      prep.addBatch();
      prep.setString(1, "Turing");
      prep.setString(2, "computers");
      prep.addBatch();
      prep.setString(1, "Wittgenstein");
      prep.setString(2, "smartypants");
      prep.addBatch();

      conn.setAutoCommit(false);
      prep.executeBatch();
      conn.setAutoCommit(true);

      ResultSet rs = stat.executeQuery("select * from people;");
      while (rs.next()) {
          System.out.println("name = " + rs.getString("name"));
          System.out.println("job = " + rs.getString("occupation"));
      }
      rs.close();
      conn.close();
  }
}

They do a little bit of everything here. Create a table, drop tables, inserts, and querying. Now let me show the the same program in question rewritten in Scala using my DB API. The actual code behind the API will come last.

import calicodb.Adapter

object Main extends Application {
  val sqlitedb = Adapter("org.sqlite.JDBC", "jdbc:sqlite:test.db")
  sqlitedb.exec("drop table if exists people;")(_.execute())
  sqlitedb.exec("create table people (name, occupation);")(_.execute())

  // Get our people ready
  val people = List(("Gandhi", "politcs"), ("Turing", "computers"), ("Wittgenstein", "smartypants"))

  sqlitedb.exec("insert into people values (?, ?);") { prep =>
    for(p <- people; val (name, occupation) = p) {
      prep.setString(1, name)
      prep.setString(2, occupation)
      prep.addBatch()
    }
    prep.executeBatch()
  }

  val rtn = sqlite.query("select * from people;")(_.executeQuery())
  println(rtn)
  // List[Map[String, Any]](Map[String, Any](name -> Gandhi, occupation -> politics) , ...
}

In my version, you should notice a few things different. I'm providing some space between us, because I want you to try to find as many of them as you can before I tell you. There's one in particular, that should catch your eye ;)

Okay. Ready? Let's start from the top. The big one: there's no close() statments anywhere! This is surely a recipe for disaster. Don't worry, it's not as bad as you think. You'll see in a second.

Other than that, I'm using an Adpater to interact with the sqlite database, but it seems like I'm messing around with a PreparedStatment directly. Because I am! I guess now is as good a time as any to look at the underlying code.

/** 
* For an update, insert, create, delete.
*/  
def exec(execute: String)(fun: PreparedStatement => Any) = { 
    val conn = getConnection
    try {
        val stm = conn.prepareStatement(execute)
        conn.setAutoCommit(false)
        fun(stm)
        conn.commit()
        stm.close()
    } catch {
        case _ => conn.rollback()
    } finally {
        conn.close()
    }
}

From my last post, you should be able to tell that I'm a big fan of general functions being passed around, and allowing the user to say what's up. Now it's clearer that my second parameter to this method is a function that takes a PreparedStatement, and does some work. Closure support allowed me to do batch commits based on a List of data. Fair enough. Good enough for me. Now there's this thing of queries returning a List of Map's. Must be some kind of magic. Let's take a look at that one now.

def query(q: String) (fun: PreparedStatement => ResultSet): List[Map[String, Any]] = {
    val conn = getConnection

    try {
        val stm = conn.prepareStatement(q)
        val results: List[Map[String, Any]] = fun(stm)
        stm.close()
        results
    } finally {
        conn.close()
    }
}

Ah, same as before... except you're assiging a ResultSet to a List[Map[String, Any]] !? That compiles!? Yes. I really left that in there to show off another feature of Scala: implicit conversions. There's another function that does the bulk of the conversion work.

/** Convert an ugly jdbc result set to a collection that can be used in code*/
implicit def rs2friendly(rs: ResultSet): List[Map[String, Any]] = {
 val meta = rs.getMetaData
 val names = for(i <- 1 to meta.getColumnCount) yield (meta.getColumnLabel(i))

 def buildr(names: List[String], rs: ResultSet): List[Map[String, Any]] = {
   rs.next match {
     case true => {
       val tuples = for(name <- names) yield (name, rs.getObject(name))
       val map = Map() ++ tuples
       map :: buildr(names, rs)
     }
     case _ => Nil
   }
 }

 val rtn = buildr(names.toList, rs)
 // Safe: close the result set since we're through
 rs.close()
 rtn
}

And there you have it. The Adapter does some nice things. It does all of it's nice things without relying on 3rd party warez. And it's low level and general enough to use for a lot of JDBC drivers out there. Heck making this script compatible with MySQL is easy enough.

// MySQL
val mysqldb = Adapter("com.mysql.jdbc.Driver", "jdbc:mysql://host:port/db")

That's all I have for today. I hope it was interesting enough :P

-- Philip

File utilities and the beauty of closures

2009-05-04T13:39:00.003-05:00

Arg! I made the same mistake again. You know: the one where you made a bad svn commit, and there are those pesky .svn folders everywhere. Well, it happened to me twice in the same night, and I'm too lazy to delete them by hand. I decided a simple Scala script would do the trick.

A simple little recursive function would do the trick. I fired up the scala interpreter, and whipped out the following function in a minute or two:

scala> def recurse(folder: java.io.File) {
  | if(folder.isDirectory) {
  |   folder.listFiles.foreach{recurse(_)}
  | } 
  | if (folder.getName.contain(".svn")) folder.delete
  |}  
recurse: (java.io.File)Unit

scala> recurse(new File("."))

Bam! That did the trick! I started to think about the function more (even though it was already stupid simple). There's a way to make this recursive function more general. Say I wanted a function that allows me to traverse a directory and do whatever I want, instead of traverse a directory and only delete .svn directories. A small change to the recursive function would allow that:

def recurse(folder: File) (action: File => Unit) {
  if(folder.isDirectory) {
    folder.listFiles.foreach(f => recurse(f)(action))
  }   
  action(folder)
}

The keen Scalafied eye would quickly see what I did there. For the rest of us, I'm going to begin explaining now:

The function recurse now takes 2 parameters: a java.io.File, and a function that takes in a java.io.File and returns Unit (which in the Scala world is equivalent to Java's void). The function parameter is named action. For each file, and directory, action will be called on it. So, now I can call it like so:

recurse(new File(".")) { f=> 
  if (f.getName.contains(".svn")) f.delete
}

That's just doing the same as before, but now, let's say I wanted to find every modified .scala from now to a week ago:

// Get the date from a week ago
val cal = Calendar.getInstance
cal.add(Calendar.DATE, -7)
recurse(new File(".")) { f=>
  if (f.getName.endsWith(".scala") && f.lastModified >= cal.getTime) println(f.getName)
}

Even better still: with Scala's closure support and partial functions, you can do some nifty actions with our very basic utility function. I want to show you the latter first:

// This is partial function syntax
// Regardless of the parent directory, I want to delete svn's
val deleteSvnIn = recurse(_: File) { f=>
  if (f.getName.contains(".svn")) f.delete
}

// Calling the partial looks very natural
deleteSvnIn(new File("."))
deleteSvnIn(new File("/some/very/bad/dir"))

// Or vice versa
val inCurrentDir(new File(".")) _

inCurrentDir { f =>
  if(f.getName.endsWith(".scala")) println(f.getAbsolutePath)
}

What I've shown you thus far is nothing spectacular. What I mean by that, is simply the same could be accomplished with any language that allows anonymous functions. Now, I'll show you closures. Allow me to give you a scenario first, so what I say makes sense: You were giving this library to work with, except you actually need the recurse function to return a value not just arbitrarily do something. You need to persist some data whether it be a count, a list, whatever. Given that you can't change
the horribly coded utility function, your options are:

Write another function that does what you need.
Rely on Scala's closure support for your help, rewrite the function if time permits, and submit a patch :)

Let's rely on closures for the time being.

// I want to count all the svn directories
var count = 0
recurse(new File(".")) { f=>
  if (f.getName.contains(".svn")) count += 1
}

println(count)

// I want to store all scala files
var ls = List[File]()
recurse(new File(".")) { f=>
  if (f.getName.endsWith(".scala")) ls += f
}
println(ls)

And there you have it! Even though we're solving problems outside the scope of this function's original goal, you're able to bend the rules with the power of closures. The functional programmer would have noticed the use of var's and scowled. I merely wanted to prove a point, not start a flame war.

-- Philip

PhilCali Code v0.1

Do You Speak Cronish?

Invocation

The Syntax

Incrementing Statements

Connectors

Values / Descriptors

Scala Cron Job

Where do we go from here?

99 Problems

Scala Snippet

Haskell Problems

Had it All Wrong

For the Great Good, Indeed

The Breakdown

Dropbox Documentation Server

Step 1: Getting the Docs

Step 2: the Plugin

Step 3: ???

Step 4: Profit!

Monido, What?

The Program

The Library

Scalendar v 1.0

Update

Construction

Manipulating time

Three Programming Languages

Who needs a Template Engine?

Web Designers would hate me

Scala *is* the Template Engine

Remote Control v0.1 Alpha

Dynamic

Update

Reset

Prepend and Append

Remote Control

Dynamicism with Context Preservation

Real-Time Solutions via ScalaBot

Scala Hot Swapping (Pseudo Hot Swap)

Nano Time is Here!

DSL Magic

BDD and ScalaTest

LWJGL / SBT plugin example app

LWJGL / SBT plugin

Streamlining Appengine Development

Moved!

Quotes with Actors Part II

Quotes with Actors Part I

Factorial goofiness

Simplifying the JDBC

File utilities and the beauty of closures

Scala is the Template Engine