Steve Levine

WebView(Javascript) -> Native Android API

2012-03-03T15:35:00-05:00

For a few weeks towards the end of last year I was developing an Android application. During that time I discovered a few new (to me) things about the Android platform. One in particular that caught my attention was having Javascript code running locally on the device call a native Android function.

Before getting into the technical details, let me first talk about a situation where this piece of functionality would be useful. Lets say (for arguments sake), that you have to write an Android application that requires advanced and very polished charts. What are you options? You can try to find a native Android implementation that meets the requirement, but I must admit, I have been there and done that, and couldn’t find any particularly good libraries. Yes there are some out there, but they didn’t have the polish I was looking for (please comment if you know of good ones).

If there aren’t any good Android libraries available what can you do? From personal experience I know there are a lot of good Javascript charting libraries out there. How can this help when developing an Android application not a web application? You can host the charting library on a server somewhere and reference them from an Android WebView? From my experience, this solution is not optimal because of slow performance. Even thought it was too slow, it still looked much better than any of the native libraries available.

Is there way to get the Javascript code to run faster perhaps by taking advantage of the beefy hardware most Android devices run on? Turns out it is quite easy to run the Javascript libraries directly on the device. After moving the Javascript code from the server to the device the performance was greatly improved. The charts rendered fast and were very responsive to the touch.

Running Javascript on the device instead of the Server is fast, but it creates a different sort of problem, namely, now you have a view (Javascript Chart) running inside another view (WebView), how does the Javascript library get its data? The obvious answer is to have the Javascript code call some (REST) service via HTTP. For arguments sake, lets say, this would not work due to the fact that the data is only available via a proprietary Java wrapped protocol. Is there a way for the Javascript code to make a Java call? There is and that is what the rest of this post is going to be about.

For simplicity, I am going to abstract away the charts and data and replace them with a simple requirement, namely, have a WebView render the underlyingAndroid SDK version.

Note: For the purposes of this post, and because I like it, I am going to use Scala as the programming language. As always, you can find all the code on Github.

The goal of this demo is to show how you can call Java from Javascript running in an Android WebView, thus we need to create a WebView, populate it with a simple html file and then enable Javascript.

MainActivity.scala - setting up basic view

  // Step 1: Create WebView 
  val webView: WebView = new WebView(this)

  // Step 2: Load page from assets
  webView loadUrl ("file:///android_asset/index.html")

  // Step 3: Enable Javascript
  webView.getSettings setJavaScriptEnabled(true)

So far, so easy. Next, we need to create a simple Scala function in our MainActivity to expose for Javascript to call. We said we wanted our view to expose the underlying Android sdk version, so lets create a function called sdkVersion()

MainActivity.scala - function to expose SDK version

  object jsFun {
      def sdkVersion() = android.os.Build.VERSION.SDK
  }

Next we need to make this function available to Javascript by adding it to the DOM.

MainActivity.scala - Adding a function to the DOM

  // Add the above function to the DOM as "Android" 
  // The function can now be invoked from Javascript with the following: Android.sdkVersion()
  webView addJavascriptInterface(jsFun, "Android")

Optional step: When developing Javascript applications it is sometimes helpfull to be able to debug something to the browser console. Believe it or not, it is quite easy to implement the browser’s console implementation with an Android one, and instead of logging the message to the browser console, it will send them to the Android Logcat system.

MainActivity.scala - Implement Javascript console.log

   // provide the WebView with a console.log implementation
   webView setWebChromeClient new WebChromeClient {
      override def onConsoleMessage(consoleMessage: ConsoleMessage): Boolean = {
        val msg = new StringBuilder(consoleMessage
          .messageLevel.name).append('\t')
          .append(consoleMessage.message).append('\t')
          .append(consoleMessage.sourceId).append(" (")
          .append(consoleMessage.lineNumber).append(")\n")
        if (consoleMessage.messageLevel == ConsoleMessage.MessageLevel.ERROR)
          Log.e("JavascriptExmple", msg.toString())
        else
          Log.d("JavascriptExmple", msg.toString())
        true
      }
    }

Finally we need to create our html/javascript view.

Lets create a file called index.html and place it under src/main/assets and add at least the following code to it:

index.html - default page that calls our Android.sdkVersion() function via Javascript

<div>Click <a href="#">here</a> to invoke an Android function to
   find out the Android SDK version used to build this App.
</div>
<div class="sdk">SDK:</div>
</body>
<script>
    console.log("This message should appear as a debug message in Logcat.");
    $("a").click(function () {
        $('.sdk').append(Android.sdkVersion());
    });
</script>

As you can see here, we are invoking the Android (Scala) method called sdkVersion() and appending the results of the call to a div using JQuery.

Thats all there is to it, now you know how to invoke an Android function from Javascript running in an Android WebView.

Mission Accomplished, Migration From Wordpress to Octopress Complete!

2011-09-28T14:26:00-04:00

Someone told me about the Octopress blog engine last week, which is a blog engine based on Jekyll, the engine that powers sites such as GitHub Pages. The main difference between Octopress and plain vanilla Jekyll is with Jekyll, you have to write your own Templates, Styles, and Javacscript code, but with Octopress, it has been abstracted away. All you need to do is clone the Octopress repository and start writing posts (or migrating posts in my case). With that being said, I have spend the past week migrating my blog from Wordpress to Octopress.

Here are some of my initial thoughts, first on Wordpress:

Compared to when it first came out, Wordpress is now too heavy for a simple blog. It has the functionality of a content management system, and that is why sites like TechCrunch use to manage their content. They also have an army of authors creating content, vs one for my blog.
Every time the admin site opens, it says that an Wordpress upgrade is available. At first this was neat, a one click upgrade, but now, it is becoming a bit of a risk. A lot of effort has gone in to the site, and if for some reason the upgrade process is not clean, it can break a lot of things. Clearly, you should be backing up as you go along, but then it is no longer a one click upgrade.
The process of writing a post is very heavy. First you need to log in to the Admin site, start writing the post in html markup. If you want to include code in your post, there is not really a clean way to do this. To preview your post you hit preview, but most of the time the code plugins do not behave correctly thus the only real way to preview is to publish the post.
An internet connection is required to do anything. This is not 100% true, as you can always use a tool such as Mars Edit to write the post offline, but the preview never looks the same as it does when published on the real site. It also doesn’t understand how to preview or author code samples.

Now my thoughts on Octopress:

It is based on Ruby which is Cool!
No database required! Again, since Octopress is nothing more than a Template Engine, the end product is static html that you can copy to any host and it will be live.
Since Octopress is a template engine, not a blog engine, you have your entire blog including all your posts in a single project. This works out great because you can open the project in RubyMine and see your posts as Markdown, your design as Sass and CSS, and your site layout as Liquid Templates.
The writing process is very Agile, as you can preview the site as many times as you want without having to copy/push/deploy code anywhere. All that you need to do is cd in to your blog’s project directory and type rake preview and browse to localhost:4000
You can write posts in Markdown, which happens to be my favorite way of generating web content (thanks to GitHub and Stackoverflow).
There are a variety of great ways to embed code within a post. The first great option is to use the neat GitHub notation by surrounding your code with three tick marks. The second is to use the Liquid Template notation, which is equally nice. Lets not forget that you can include a GitHub gist VERY easily, just { gist gistIdNumber }. Can’t get much easier than that! Last but defiantly, not least is you can include a source file from the filesystem.
Code samples look fantastic when they are rendered in the Solarized themed code viewer! Hers’s a sample:

Tail Recursive Fibonacci

  def fib( n:Int) = fib_tr( n, 1, 0)

  def fib_tr( n: Int, b: Int, a: Int): Int = n match {
    case 0 => a
    case _ => fib_tr( n -1, a + b, b)
  }

It has been about a week and my blog is completely migrated over to Octopress now. It has been a rather enlightening experience for me because Octopress and Wordpress are so different. Bottom line is Octopress was written by and targeted at hackers, and that fact inspires me at a level that Wordpress never was able to do. I am hoping to leverage that hacker inspiration to get my self writing posts on a more regular basis starting today.

In case you haven’t heard - Apple is not showing Java any more love…

2010-10-21T16:29:24-04:00

Official release notes. If you think about it it makes perfect sense for them. To them Java is no different than Flash, just a GUI platform. How many killer Java applications are there out there (besides Java IDE’s) ? Add to the fact that SunOracle is probably twisting their arm for more licensing money.

Thus, it makes perfect sense for them, why would they want to waste their resources implementing a JVM that is required by only a few applications especially when they are trying to boot strap their “App Store”? Supporting Java developers working on server software is not part of their business model.

But… This is not bad for Java developers (although lots of Java developers are showing the Apple hate right now), because the Apple JVM was never up to date, and always behind the “real” JDK implementation. Remember the Eclipse 64 bit fiasco?

My hopes moving forward is that the community comes together to come up with a completely open source version of the JVM for BSD/Mac. There are already two really good starting points, SoyLatte and OpenJDK. It would be great if Apple were to open source their JVM code base (although this is not likely due to SunOracle Licensing), can still hope.

Bottom line, if you are a Java developer you do not have to start migrating away from OS X, everything will be fine – just give it a bit of time.

Just my thoughts.

First Thoughts On My New Eee Pc (1005PE)

2010-03-23T18:30:30-04:00

So far, so good with my new Eee PC (1005PE) Netbook. The machine came pre-installed with Win 7 Starter edition, so the first task for me to do was to get rid of Windows 7 and install Ubuntu Netbook on it. So I downloaded the Ubuntu Netbook 10.04 daily build image (yes, I am daring), and was on my way.

At first, this task seemed easier said than done because I was running in to the most fundamental problem possible, namely, I could not get the Eee PC to boot from the ‘bootable’ usb stick I created on my Mac Pro desktop. I checked every single bios settings, made sure that USB was chosen as priority boot drive, Still nothing. Kept getting the Windows 7 startup sound which was starting to get a bit tedious.

The next thing I thought was maybe the Cruser U3 software was causing the trouble so I went out and found a U3 uninstaller, and ran it. Still didn’t boot from the USB Stick. I then found out that in order to get the boot menu on the Eee PC, you need to hold down the Escape key while its booting. I tried that, it had the USB as a target bootable device, I selected it, but still went in to Windows 7.

At this point I was quickly running out of ideas, the only other thing I can think of was perhaps the USB stick was some how not bootable? Maybe the USB stick was not created correctly even though I followed the Ubuntu Mac instructions step by step. I downloaded the Ubuntu 10.04 daily build on to my Eee PC while booted in to Windows 7, and then downloaded this program called UNetbootin. This time I used that program to create my bootable USB stick, and then I tried to reboot again.

This time it booted in to the Live CD version of Ubuntu, yes, I was saved! I couldn’t believe that it was a bad image on my USB Stick. Why can’t a Mac create a bootable USB Stick? The strange thing is that the Eee couldn’t even read the files on the USB Stick when connected in Windows 7, but when the Stick was plugged in to my Mac Pro, I was able to see the files fine. And vise versa, once I created the USB Stick in Windows, I coulsn’t see the files on Mac. What is the deal here? I thought ISO images were platform independent?

With that being said the USB Stick problem is well in the past for me. Look for my next post where I will give my impressions of Ubuntu Netbook 10.04.

RubyMine 2 Debugging Issue Resolved

2010-01-23T15:27:19-05:00

If you are trying to debug Ruby code in RubyMine 2 IDE, but are having difficulties such as, the IDE freezes after you try to step in, step over, or step next and are wondering if your configuration is wrong? It is not, if you happen to have installed the ruby-debug-ide19 gem from the command line (not from IDE), you need to patch the actual gem code to get things working nicely.

Open the following file with your favorite text editor (part of ruby ruby-debug-ide19 gem)

$GEM_HOME/ruby-debug-ide19-0.4.12/lib/ruby-debug/command.rb

Add the following code at line \~120 (look below for full code location):

return "" if str == "$FILENAME"

After the modifications, the code should look like:

def debug_eval(str, b = get_binding)
begin str = str.to_s
return "" if str == "$FILENAME"
max_time = 10

Thats it, you should be able to debug your Rails/Ruby code in RubyMine without issues.

With Grape, Groovy Is On Par with Native Scripting Languages

2009-12-24T14:31:36-05:00

If you haven’t heard, the latest version of Groovy was released this week and included with it, among many other great features, was Grape (Groovy Advanced Packaging Engine). Grape is an annotation based dependency management system that provides functionality similar to that of Maven and Ivy with one clear advantage, namely, no build file.

If Grape doesn’t use a build file, how does it know what dependencies are necessary to run the code? Does it figure it out for you on the fly? Unfortunately, it is not that smart (yet), perhaps the next release. If it doesn’t figure it out for you, then how do you specify your dependencies? You configure your dependencies by using the@Grapes or @Grab annotations.

What is so good about being able to configure your dependencies via annotations?

If you are working with Groovy scripts, it frees you up from having to worry about dependency management and allows you to focus more on what the script needs to do much like when working with other scripting languages like Ruby or Perl. In order to clearly demonstrate the advantages of Grape, lets walk through an example.

The problem

Trying to keep up with my ever changing IP address after switching ISP’s earlier this year. There are several services running at my home that I need access to on a daily basis. If my IP changes over night, after a brown out, or for some other reason, I need to know about it asap.

In order to keep up with my IP address, I wrote a set of scripts that perform the following:

Obtains the current IP address of the server where it is running
Looks up the most recent IP address of the server in a log file
If the current IP address is different that the most recent IP address:
- Updates the log file with the current IP address
- Send the new IP address in a customizable email to a configurable address
If the IP address’s are the same, it does nothing.

The Solution

It took a total of three Groovy classes/scripts to solve this problem. We are not going to get in to the details of the solution because I want to stay focused on Grape.

You can find all of the code discussed in this post on github. Please feel free to download and use it. Feedback is welcome as well.

This simple Groovy class first connects to a mail server, and then sends the change of address message.

(Mailer.groovy) download

import javax.mail.Session
import javax.mail.Message
import javax.mail.internet.MimeMessage
import javax.mail.internet.InternetAddress

@Grapes ([
  @Grab (group = 'javax.activation', module = 'activation', version = '1.1'),
  @Grab (group = 'javax.mail', module = 'mail', version = '1.4')
])

class Mailer {
  static def s_config = new ConfigSlurper ("message").parse (new File ('MailProperties.groovy').toURL ())

  static def deliverIpAddressChangeMessage(ipAddress) {
    def subject = "IP Address Changed to $ {ipAddress} "
    def message = " IP Address changed to $ {ipAddress}. \nPlease update your configurations."
    sendMail("${s _config.message.to}".toString(), "${s_config.message.from}".toString(), subject, message)
  }
  //…
}

The most interesting things to pay attention to are:

The @Grapes block after all of the imports, you can see this groovy class depends on javax.activation and javax.mail jars.
Thanks to Grapes, you can compile this class simply by invoking groovyc Mailer.groovy as opposed to having to configure either Maven, Gant, Ant, or some other build tool to manage the dependencies and classpath for you.
What’s the big deal? Read more to find out!

This next code snipped represents the “main” entry point of my solution. It simply obtains the current IP address of the machine it is running on, checks the current address against the most recent known address stored in a log file, and then uses the previous class to send an email if the IP address has changed.

(whereIsMyIp.groovy) download

#!/usr/bin/env groovy

// IP Address Regex http://www.regular-expressions.info/examples.html
currentIp = ("http://whatsmyip.us/".toURL().text =~/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/)[0]

println currentIp

def ipLog = new File("ip-log.txt")

recentIp = ipLog.readLines().last().tokenize(",").last().trim()

if (currentIp!= recentIp) {
  Mailer.deliverIpAddressChangeMessage currentIp
  println "IP Address has changed, it is now: ${currentIp}. Sending Message."
  ipLog << "${new Date()}, ${currentIp}\n"
}

The most interesting thing to pay attention to in this script is:

The #!/usr/bin/env groovy on the first line on the script.
This line enables the script to be called directly from the command line like: ./whatsMyIp.groovy instead of groovy whatsMyIp.groovy

The Big Deal!

If Grape didn’t exist the only way to invoke this script would be to invoke it with a build tool such as Maven, GAnt, or some other. If a build tool didn’t suit you then you would have to invoke groovy -classpath=/path/activation.jar… and manage the dependencies there. Both of these solutions work fine, but are clunky.

If you were to solve this problem using a language such as Ruby, you would not have to worry about dependency management since Ruby is so closely integrated with the OS. You would simply run gem install some gem, and this would install the dependencies at the OS level. Thus allowing you to focus on your script and letting the Ruby runtime focus on the dependencies. Invoking ./someScript.rb is common in Ruby.

Grape gives Groovy scripts the same clean dependency abstraction. It is possible to invoke ./whatsMyIp.groovy without having to worry about any dependency management. Once the groovy runtime comes across the Grape annotations, it loads the dependencies on demand freeing the Groovy script from having to be wrapped with a dependency management layer.

This is a huge deal because now simple Groovy scripts can leverage the entire Java ecosystem from the command line without having to wrap the invocation with a build tool. Groovy Scripts are now clean, simple, and easy. I hope this inspires you to go out and convert some Ruby or Perl script to Groovy.

Time Machine over a Network Drive

2009-12-13T14:04:45-05:00

This post describes the steps involved when setting up Time Machine to backup to a Network Drive. These steps are only required if you want to back up to a device other than a Time Capsule. It is pretty quick and easy, so without further due, lets get started.

Step 1: Enable network backups in Time Machine

In a terminal window cut/paste the following command:

defaults write com.apple.systempreferences TMShowUnsupportedNetworkVolumes 1

Update: Steps 2 & 3 are only required if you are not running Snow Leopard. If you are, then all you need to do is mount the network drive you wish to use as a Time Machine destination, and then proceed to Step 4.

Step 2: Create Timemachine backup volume

In a terminal window cut/paste the following command:

hdiutil create -fs HFS+J -volname "Backup of computer-name" computer-name_[mac address without’:’].sparsebundle

The simplest way to obtain your mac address is to open a terminal window and type the command: ifconfig -a, and look for the section of the output where it says: ether 00:33:44:55:66:77

The simplest way to obtain your computer name is to open a terminal window and type the command: hostname, it will return the name of your computer, example, my-hostname.

Putting it all together, based on the above examples, you would run the following command:

hdiutil create -fs HFS+J -volname "Backup of my-hostname" my-hostname_003344556677.sparsebundle

Step 3: Copy file created in step 2 to network Time Machine backup destination*

Using finder or terminal, copy the newly created .sparsebundle file to the place you want your Time Machine backup to reside.

Step 4: Open Timemachine preferences, and the network drive should show up as a backup target

If for some reason it doesn’t, try opening and closing the Time Machine preferences, as it may take a moment for it to detect the newly available network drive.

Step 5: Rest easy knowing your mac is now backed up to a network storage volume.

Scala Sugar - Iteration

2009-11-22T14:58:11-05:00

In this second installment of Scala Sugar, lets put the lists that we created in the previous post to use.

How do we typically interact with lists when writing non-trivial programs? We iterate over them! With that being said, lets explore how iteration in Scala compares with iteration in Java.

Taking the lists in the previous post in to account, lets assign ourselves a task of iterating over each element in the list and converting them to uppercase.

First, we all know how to do this in Java using a standard for each loop:

(String s : l) { System.out.print(s.toUpperCase()); }

There are so many different ways to iterate in Scala, thus we are only going to talk about the most trivial ways.

for (s \<- l) print (s.toUpperCase())

-or-

l.map(\_.toUpperCase()).foreach(printf("%s", \_))

Download Source: simpleLists.scala

As you can see, you can loop in Scala the same way that you do in Java, namely, with a for each loop. There is nothing special about that.

The second loop is written in more a functional paradigm, as it uses the Scala map function. It allows you to iterate over the list without having to know anything about the details of the iteration itself. With Scala you are working at a much higher level. If we look at the Scala map function, it takes in a function as an argument, in this case the function is “toUpperCase()”. The map function then applies this function to all of the elements in the List, thus you don’t have to worry about the actual iteration logic. In this scenario, all the caller needs to worry about is that they have a List of elements, and they want some function f applied to all of them.

You can chain functions together on a List. In this case, we changed a foreach to the end of the map. If we were to describe the what is going on in plain english, it would sound something like, take all the elements of l, apply “toUpperCase” to all of them, then for each of them, print them.

The final interesting thing to notice in the above line of code is the “_” placeholder syntax. It looks strange to have a “_” there as part of the code, but all it is doing is acting as a placeholder for the function. It simply represents the current element of the List being operated on. Even though there are two “_“‘s in this example, they are completely independent of each other. The placeholder is a very powerful advanced concept in Scala and this example barely touches the surface of its usage. We will talk more about it in a dedicated post.

As you can see, Scala supports both the “Java” way of iterating and a pure functional way. Again, this example is just one of the many different techniques for iterating in Scala. In a future post we will look at other ways of iterating in Scala.

References

The code found in this post is hosted at github.com along with other sample Scala code.

Scala Sugar - Lists

2009-11-21T16:01:58-05:00

If I want to become a real Scala Ninja, I am going to have change the way I think about coding. For the past 10 years I have been programming primarily using the object oriented paradigm. Although Scala supports pure object oriented programming, it is my desire to learn to program in Scala in a complete functional paradigm.

Of course, learning a new programming paradigm is not going to happen over night, it is going to take a bit of time. Over the course of the next few months, I am going to be posting a series of posts documenting my progress learning Scala. They will be written from the perspective of a “hardcore” Java programmer being enlightened by a sweet new language. I will write about all of the “sugar” Scala has to offer a Java programmer, and that is how I came up with title “Scala Sugar”.

In this first installment of Scala Sugar lets discuss one of the most fundamental concepts required to write any non-trivial program, namely Lists. For the longest time, Lists in Java didn’t bother me at all, as they seemed “normal” to me. That was until I was introduced to dynamic languages a few years back. Now, Lists in Java seem extremely verbose to me as I wonder why in Java you can’t just create and populate a list with a single line of code. Lets look at our first Java vs Scala comparison.

Lets create a trivial list of three lowercase strings.

import java.util.ArrayList;
import java.util.List;
List<String> l = new ArrayList<String>();
l.add("a");
l.add("b");
l.add("c");

In Java it takes a minimum of 6 lines of code to declare a list of 3 strings! Now lets declare the same list in Scala.

val l = List("a", "b", "c")

Thats it, one line of code! The most important things to pay attention to are:

No need to import List in Scala, as most fundamental classes are imported by default in Scala
You do not have to give ‘l’ a type in Scala. Scala uses Type inference which means that it can infer its type from the object it is pointing to. It is important to realize that Scala is statically typed, it just doesn’t require you to type your variables when you define them. The compiler is smart enough to figure it out.
You can construct a list with elements in Scala, no need to “add” each element separately.

Even in this trivial example, you can start to see how clean and concise Scala is.

In my next post we will explore different ways to iterate over the lists.

References

The code found in this post is hosted at github.com along with other sample Scala code.

Scala reduceLeft

2009-11-19T17:52:02-05:00

This post was updated on November 19, 2009.

As you know, during the past few weeks (time permitting), I have been spending time studying the Scala programming language. After reading the first few chapters of Programming In Scala, I have come across the first feature of Scala that would have been totally useful for me on one of my Java programming tasks a few months ago.

The actual programming task was quite complex, but for the purposes of this post, we will work with a dramatically simplified example. The simplified task is: given a list of Stocks figure out which one has the highest earnings per share.

Here is one way the problem can be solved in Scala:

class Stock(val ticker: String, var price: Double, var earnings: Double, var shares: Int) {
    override def toString = ticker + " has eps of: " + eps + " with a price of " + price
    def eps = earnings / shares
    def >(that: Stock): Boolean = {eps > that.eps}
  }

  val portfolio = List(
    new Stock("aapl", 203, 4.73E9, 878876000),
    new Stock("ibm", 66, 1.23E10, 1384331000),
    new Stock("goog", 465, 4.19E9, 314754113)
  )

  println(
    portfolio.reduceLeft(
        (s1, s2) => if (s1 > s2) s1 else s2
    )
  )
  // goog has eps of: 13.31

Download Source: Stock.scala, reduceLeft.scala

If you have never seen Scala code before, this code will look quite foreign to you because there are a lot of concepts in Scala that are not present in Java. In a few weeks (again time permitting), will begin writing a series on Scala for Java programmers, but for right now, please bear with me, and try to follow along.

The most interesting things to me about this code are:

~~Line 04: You are reading it correct, that is operator overloading!~~
- Correction: Scala doesn’t actually support “operator overloading”, in fact, “operators are not special language syntax”. In Scala any method can be an operator. What makes an operator an operator is how you use it. Example:

1 + 2 //operator
1.+2 //not operator (but returns wrong type)
(1).+(2) // Correct return type

Line 07: It is great to be able to populate a list so easily without having to mess around with add methods.
Line 14: This is the coolest feature of them all so far, the ability to reduce a list of elements down to one based on a binary operator.

This is just a small demonstration of the very basics of the Scala language. If you find this at all interesting, you can find out much more at scala-lang.org.

Note: obviously, this is not the most optimal Scala solution so if your a Scala guru, criticisms are welcome. I hope to come back to this example every few weeks, continually improving it as my knowledge of Scala grows.

References The code found in this post is hosted at github.com along with other sample Scala code.

Simple Applescript For The Traveling Mac

2009-11-12T22:46:45-05:00

The Problem

You have a MacBook and a nice Apple Cinema display (this doesn’t sound like a problem so far), and you travel with the MacBook every day. When you open the lid of your MacBook you like to have the Dock on the left side of the screen giving you the most top to bottom space, but when you come home and connect the MacBook to your Cinema display and set up dual monitors, you want the dock on the bottom of the Cinema, not on the left side of the MacBook.

You don’t want to have to go in to preferences every time to switch the location. (or maybe you do?) For me it was becoming a very tedious task, so I began researching ways to automate it.

The Solution

Leverage Apple’s “Language of Automation”, Applescript to handle the task. Applescript has lots of useful hooks in to OS X.

The requirements for the script are quite simple: - Obtain the current resolution of the primary monitor - if the resolution is > 1900 (Cinema Display) configure the Dock for large display - else configure the Dock for laptop display

For the moment, that is my goal, simple, yet time saving.

Step 1: Open AppleScript Editor Step 2: Paste the following code in

– Obtain current resolution tell application "Finder" set screenSize to bounds of window of desktop set screenWidth to item 3 of screenSize set screenHeight to item 4 of screenSize –display dialog "Screen resolution: " & screenWidth & " X " & screenHeight & " " & screenSize as Unicode text end tell – Configure the Dock based upon the current resolution if screenWidth is less than 1900 then tell application "System Events" tell dock preferences –get properties set properties to {minimize effect:genie, magnification size:0.669312179089, dock size:0.0, autohide:false, animate:true, magnification:true, screen edge:left} end tell end tell tell application "WebKit" set the properties of front window to {bounds:{71, 22, 1350, 893}} –get properties of front window end tell else tell application "System Events" tell dock preferences set properties to {minimize effect:genie, magnification size:0.632275104523, dock size:0.25925925374, autohide:false, animate:true, magnification:true, screen edge:bottom} end tell end tell tell application "WebKit" set the properties of front window to {bounds:{230, 59, 1612, 1050}} –get properties of front window end tell end if

Step 3: Run it to make sure it works as expected, if so, save the script as application, so you don’t need to open AppleScript Editor each time you want to run it.

Future requirements

Figure out how to hook the script in to sleep/wake events in Snow Leopard.
Customize more than just the Dock.
Migrate it in to a startup script that brings up all necessary applications based upon current mood (reading/blogging/coding).
Others???

Overall, I find Applescript a very easy way to automate things in Snow Leopard.

All of the source for this post can be found on github.com. Please feel free to fork and improve. Enjoy.

iPhone 3.0 upgrade from beta 5 to final

2009-06-18T12:40:50-04:00

For the past few months, I have been running the iPhone OS 3.0 betas on my iPhone without too many issues. Thus I assumed that when the final version of OS 3 was released, it would be easy to upgrade to it. This has not been the case. The current beta on my iPhone was beta 5, and then yesterday when the final version was announced, I assumed after a simple plug in to iTunes, I would be upgraded to the released version. Nope, iTunes kept telling me that I have the latest version of iPhone OS 3. It seems as though it is not checking the build number, only the OS level. The next thing I tried was doing a restore, this didn’t work either because it gave me an error saying it could not connect to the site to download the file.

Finally, after some Googling around, I found that others with the same problem circumvented it by putting their iPhone in recovery mode and then upgrading from there.

If you are currently running beta 5, you were supposed to upgrade to the GM version posted last week. I skipped it thinking their would be another release in the next few days with the final version. I have now learned that the GM version is the same as the final version. Unfortunately, now it is too late to download the GM from the developer website, as Apple has taken it down, and according to their documentation, you should obtain the final version through iTunes. Thus if you are in the same boat as me, on beta 5, you will have to install the latest version via recovery mode.

Easy Upgrades

2009-06-15T17:49:31-04:00

Who doesn’t like easy upgrades? Easy upgrades are great when implemented correctly. There are two speciifiic easy upgrades I have been (enjoying) using recently, namely, Wordpress and Ubuntu Server.

Wordpress

This blog has been powered by Wordpress for a long time, and has been upgraded many times along the way. Download the latest tgz file, unzip it, save your wp-content directory, upgrade your database, and then you are good to go. Keep in mind this was a very simple procedure, as they call it their “famous 5-minute installation”, which it typically was.

Once upgrading to 1.7, the procedure became as easy as clicking a link on the admin page, and stepping through a wizzard This blog is now running 1.8, so it has been through several automatic upgrades already, and each one of them has been completely boring, which when talking about upgrading an environment, is a very good thing. This magic does not only apply to upgrading the entire platform, as you can automatically upgrade your plugins as well.

Ubuntu

Many years ago I set up several Ubuntu Gutsy Gibbon (7.10) Servers in my basement to serve different purposes on my internal network. These servers have been running without issue for the past 2 years. They would probably run seamlessly for another 2 years, but unfortunately, I needed to install a new package that didn’t have a deb available for the current version of Ubuntu. At first I was trying to find ways around this, installing the sources instead, but that didn’t work well for me, as it needed a newer version of a dependent library. Even considered trying a different software package, but it seemed like all of the software packages I was trying to install, required a newer version of Ubuntu.

What was I left to do? Either upgrade or rebuild from scratch. Based on past experiences with other distros, upgrades have been nothing but headaches for me. Since, I really didn’t want to invest the time to rebuild the server from scratch, decided to try my first Ubuntu upgrade. Again, based on my past experiences, I assumed I needed to download the media, and then hook up a monitor to the server, and finally go through a set of upgrade screens.

To my delight, after a little bit of research I found that you can do the entire upgrade from the command line), no user interface required, no media download required, no monitor required! This was too good to be true right? Well, no. I ran the do-release-upgradecommand, and now my server is running Hardy Heron (8.04). Couldn’t be any easier. Ubuntu’s upgrade infrastructure is very impressive.

What is the moral of the story? If you want to build a loyal user community, treat the members of the community well by providing them with an easy upgrade path.

Quicksilver is a timesaver

2009-01-26T14:57:25-05:00

It has been a while since a single program changed my workflow as much as Quicksilver has.

Over the years, it has been covered a lot on the Mac sites, but it never really seemed like something that would help me. Guess it was the stubborn side of me refusing to try something new. So the question is what changed my mind now? Two things:

The Productive Programer: In his book Neil Ford describes several work flows involving Quicksilver that actually made sense to me, especially the Subversion plugin.
Pragmatic Thinking And Learning: Again, the virtues of Quicksilver described in such a way, that made a lot of sense to me.

After reading these two excellent books, it was time for me to give it a try, and see what it has to offer. It has been about a week now, and it is hard to imagine using my Mac without it. It has increased the efficiency of my workflow tremendously. The mouse has become optional for most tasks. It has sped up common tasks for me such as checking in/out files from Subversion, opening documents to edit, quickly composing emails and attaching files, and my favorite time saver is this neat trick that allows you to lock your computer with a simple keystroke. Previously, it required clicking on the “lock screen” option in keychain.

If you are a Mac developer like me, and you are in to efficiency, you need to at least give Quicksilver a try. You won’t be disappointed.

Going Functional with Scala

2009-01-15T16:59:32-05:00

Lately it seems like functional programming has been the talk of the town, the new (old) paradigm that is making a comeback in a major way. For a while, I resisted the urge to follow the paradigm de jour, being the hard core OO guy that I am, but now it is clear to me that it is more than just hype. There are many reasons functional programming makes sense as a paradigm for developing software today, but the one that I am most interested in is the fact that it handles concurrency so well, thus providing us the building blocks to develop extremely scalable applications.

FP(Functional Programming) has been on my mind for a while. The seed was placed there in late 2007 by the Java Posse listening to their interview with Martin Odersky. They were not talking about FP per se, but more about a specific JVM language called Scala (pronounced skah-lah not scale-la). Scala is not a pure functional language, it is actually a fusion between functional and object oriented programming. It brings together the best of both worlds. My exposure to Scala did not end there, as I got another huge dose at Java One 2008. Two of my favorite sessions there were either on Scala, or Scala was a major discussion point.

The first session was the Script Bowl. This session was not specifically about Scala, it was more of a JVM scripting language battle, and in the end JRuby was crowned king by the audience. In my mind, Scala was the clear winner, because of the simple, yet elegant and powerfull concurrency demonstrated. The presenter wrote what looked like a relatively simple program, and it was capable of indexing tons of RSS feed dumps in real time on a typical multi-core laptop computer. I remember thinking to my self, wow, it would take me a lot more time and effort to write a similar program in Java, and it probably wouldn’t have the same level of scalability as the one demonstrated. The Scala code was able to fully utilize the multi-core processors it was running on.

The second session was on Scala presented by the father of Scala him self Martin Odersky. During that session I was wowed again with some of Scala’s features like it:

is scalable because it works for very small and very large systems.
“is the Java programming language of the future.”
is object oriented, functional, and a scripting language.
leverages Actor’s as the primary concurrency construct.
fits seamlessly in to a Java environment.
is a composition language, as it adds the notion of Traits.
has an updated type system supporting type inference.

After those two sessions, I headed over to the Java One bookstore to check out the Beta version of Programming in Scala. I was impressed, but couldn’t help thinking, is Scala for me? Can I use it at work? Is it viable in the enterprise?

Fast forward 7 months to today, and let me answer my own questions with one word: yes!

Is it for me? Yes, because Scala is not only something new, it is something advanced, because it was written in a no compromise academic environment. If nothing else it is a great way to broaden my horizons as a programmer.
Can I use this at work? Yes, Scala code compiles down to Java byte code, so theoretically, if I was very evil, I could write all my code at work in Scala, run Scalac on it, and add the class files to the application, and no one would be any the wiser. Will I do that? No way, I am simply trying to illustrate a point that Scala is totally compatible with any existing Java environment.
Is it viable in the enterprise? Yes, with its advanced concurrency model, I can only imagine the type of throughput you can achieve. (Looking forward to finding out)

Now you know where my interest in Scala comes from. Hopefully after reading this post, you will be a bit curious about it as well.

New Webkit Feature

2009-01-14T11:20:23-05:00

Just noticed a new and important feature released with the latest nighty build of Webkit, namely, an option to check for updates automatically. Mozilla has had this feature in their browsers for a long time, and it was hard not having it available in Webkit. Just got used to downloading a new version every so often.

The days of remembering to update Webkit are now over, the latest nightly knows how to keep it self in sync with the current nightly build.

Here is the option you are presented with the first time you open the latest Webkit.

If you choose to say no to the above dialog, or if you are like me and you leave your browser open all the time, and you want to check for updates manually there is that option too.

Once the process is complete, you will see the following dialog letting you know you are up to date.

It is great to see this much needed feature has finally arrived in Webkit. Hopefully this will entice more people to jump on the Webkit nightly bandwagon.

Keyboard Shortcuts

2008-12-18T10:45:28-05:00

Do you want to learn all of the keyboard shortcuts to your favorite Java IDE, but just don’t have time to study a cheat sheet? Are you envious of your team lead because when you peer program with them, they are able to get things done without using the mouse?

You ask your self how did they do it? Do they memorize a cheat sheet while on the Subway? Do they go home and practice coding every night? Are they gifted with great memories? Well, they may be all of these things, but you don’t have to be!

All you need to do is install a plugin called Key Promoter that is available for both Intellij and Eclipse. The way it works is every time you use your mouse to accomplish a task that can be accomplished via a keyboard shortcut, it pops up a window and lets you know. In the Intellij version, it actually keeps track of how many times you used your mouse for each action. It becomes insulting after a while if you see you used your mouse 20 times for the same action, knowing it has shown you the corresponding keyboard shortcut each time.

For more details you can find the Intellij plugin here, and the Eclipse plugin here.

Simple Security for HTTP Based RESTful Services (Part 2)

2008-12-16T18:51:23-05:00

In part one of this series, we examined one potential solution that turned out to be not so good. In this post lets try to find a solution using the same design, but a better implementation.

To recap, we decided to use the simplest solution which is to add a security hash to each service call. The first approach we tried was adding the security hash to the XML payload of each service call. The conclusion was that approach was not very elegant, and actually quite ugly.

Let us now discuss a more elegant solution. Keeping the same parameters in place, namely, we want to pass the hash along with each service request, where can we place it where it will not cause the implementation to be ugly? Why don’t we try by add the Hash as a field in the Http header?

The request would look like:

PUT http://blah.com/services/someEntity/226 HTTP/1.1
Accept: text/xml
Content-Type: text/xml
User-Agent: Jakarta Commons-HttpClient/3.1
Host: somehost:port
Hash: 53b383c67a03d23a38b6f52f4a732553
Content-Length: 380
<someEntity>
    <fieldOne> fieldOne </fieldOne>
    <fieldTwo> fieldTwo </fieldTwo>
</someEntity>

As you can see, the hash has been added to the Http header (line 6). To verify the hash, we need to do create a Servlet Filter that verifies the Hash.

A very simple filter would look like:

public class VerifyHashFilter implements Filter {
   public void doFilter(ServletRequest request,
            ServletResponse response,FilterChain chain)
            throws IOException, ServletException {
     if(((HttpServletRequest)request).getHeader("HASH").equals("12345"))
        chain.doFilter(request,response)
     else
        ((HttpServletResponse)response).setStatus(401);
   }
}

Then our service code implementation would change to:

@Path("/services")
public class SomeEntityServiceImpl {

    @PUT
    @Path("/someEntity/{id}")
    @Consumes("text/xml")
    public void updateSomeEntity(SomeEntity entity,
                @PathParam("id") int id) {
    dao.saveOrupdate(entity)
    }
}

To test our service, we can use curl:

$ curl -i  -H 'HASH:12345' http://localhost:9095/rest-test
HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: 71
Server: Jetty(6.1.14)

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<someEntity>
    <fieldOne>fieldOne</fieldOne>
    <fieldTwo>fieldTwo</fieldTwo>
</someEntity>

And the negative test:

$ curl -i  -H 'HASH:54321' http://localhost:9095/rest-test
HTTP/1.1 401 Unauthorized
Content-Length: 0
Server: Jetty(6.1.14)

As you can see, the implementation code is much cleaner and reusable now. The service code can be called from anywhere within the application without having to worry about a security hash. It is safe to assume that if the code makes it as far as the service, it passed through the security filter thus making the request authorized. Having that assumption as part of the design allows you to write much more generic and reusable code.

Please keep in mind this concept is nothing new, as this solution is an over simplification of how the Spring Security module works. The value in this solution is it doesn’t have dependencies on any external frameworks. When designing this solution, that was one of the determining factors.

Next time you need to implement a quick authorization mechanism for your REST service, make sure you keep the Http header along with a Servlet filter in mind.

Simple Security for HTTP Based RESTful Services (Part 1)

2008-11-29T19:58:50-05:00

This is going to be the first in a series of posts discussing potential ways of securing bi-directional RESTful based HTTP services. For this series we are going to make the requirements quite simple, namely, “secure” simply means the caller of the service is authorized to invoke it. Lets assume that this solution is being deployed along with a simple IP addresses restriction mechanism. Since IP address’s can easily be spoofed, this solution is the next level of defense to ensure the identity of the caller.

There are many different potential solutions to this problem, but for this series, we are going to focus on the simplest solution which is to add a security hash to each service call. This post assumes you understand how to secure B2B communications with the use of a security hash. If you need a refresher, please refer to this post on the subject.

Since we know the design for securing our communications, we need to decide on an implementation. The first potential implementation we are going to examine is adding a “security hash” to the XML payload for each service call.

The embellished XML payload would look like:

<someEntity>
    <hash>4723af11bef05fc6207bd22cd163d9db</hash>
    <fieldOne> … </fieldOne>
    <fieldTwo> … </fieldTwo>
</someEntity>

with the “hash” field (line 2) representing the security hash.

The interface of the SomeEntity service, would look like:

public interface SomeEntityService {
    public void updateSomeEntity(SomeEntity entity, int id) throws SecurityException;
}

with an implementation that looks like:

@Path("/services")
public class SomeEntityServiceImpl {

    @PUT
    @Path("/someEntity/{id}")
    @Consumes("text/xml")
    public void updateSomeEntity(SomeEntity entity,
                    @PathParam("id") int id)
                        throws SecurityException {
        if (validateHash(entity))
            dao.saveOrupdate(entity)
        else
            throw new SecurityException("Not Authorized");
    }
}

With the actual HTTP Client call looking like:

PUT http://blah.com/services/someEntity/226 HTTP/1.1
Accept: text/xml
Content-Type: text/xml
User-Agent: Jakarta Commons-HttpClient/3.1
Host: somehost:port
Content-Length: 380
<someEntity>
    <hash>4723af11bef05fc6207bd22cd163d9db</hash>
    <fieldOne> fieldOne </fieldOne>
    <fieldTwo> fieldTwo </fieldTwo>
</someEntity>

There you have it, our first potential solution to the problem. We now need to examine if this solution is correct, and if it is, is it elegant?

First things first, is it correct? If you trace through the code, you can see that before the service makes a call to the DAO, it checks to verify the validity of the hash field (line 10). If the hash it is not valid, it will throw an Exception, which in turn would return a 401 to the user. It would not be possible for a client to access the DAO without having the proper hash as part of the XML Payload.

Even though this approach would perform as expected, it has two main issues, the first being it mixes concerns. What we mean by mixes concerns is it mixes business logic with security logic. This is a standard problem that applies to layered architectures. The main side effect of this problem is it makes the code very difficult to reuse. Lets me demonstrate this with a simple code fragment:

// Code in a Web Controller class somewhere
try {
    someEntitySvc.updateSomeEntity(entity);
} catch (SecurityException e) {
    // Nothing we can do… We don't have the hash???
}

As you can see from this simple example the implementation of the service is not generic enough to be usable by a Controller in the Web Tier. Firstly, even if the Web Tier knew about he hash, the code becomes polluted with Exception handling for an Exception that is not applicable to this client. Secondly, the Web Tier simply doesn’t have any knowledge of the hash, and putting logic here to generate the hash just to use the service would not make any sense from a design perspective.

The second issue with this approach is the fact that you can only apply it to Http methods that accept a payload. What about methods that do not accept a Payload, I.e., GET? To make this work for the GET method, we would have to pollute our GET method implementation with a @Consumes(“text/xml”) tag, which functionally would work, but from a API design perspective, it is quite ugly. As a consumer of a GET method, all you need to know is the id of the entity you wish to “get”. Adding an XML payload for “security” purposes is a bad and cumbersome design.

With all that being said, it looks like this is not the best solution to the problem. Stay tuned for part two of this series where we will discuss a more elegant approach to solving this problem.

A little Salt with that Hash?

2008-10-30T19:06:09-04:00

Was just presented with a unique (to me) requirement which is to implement a single sign on across multiple domains within the same page via a cookie. Huh? Let me elaborate, in simple terms it means that there is a base site, lets call it foo.com, and then there is a partner site, lets call it bar.com. On foo.com’s main page we want to be able to iFrame in bar.com with the credentials of the current user logged in to foo.com transparently sent over and in turn logged in to bar.com as well.

In order to achieve this, the first thing that needs to happen is the two sites need to have a sub domain in common. The easiest way to accomplish this is to set up an alias on the parent site (foo.com) to bar.com. The alias would be something like bar.foo.com which points to bar.com. This is required because if they do not have a domain in common there is no way for them to share cookies.

The next thing that needs to happen is both sites have to agree on a way of authenticating a user. In our case we used a cookie that consisted of the user id followed by a hash of the user id which looked something like 12345,jfk83jf835jfiie43.

Your probably wondering how this simple cookie can facility a single sign on across two different sites? Let me explain, first lets talk about the how the values of the cookie are generated. The first value, namely, the user id, is self explanatory. The second part of the cookie, the hash, has a little bit more to it. In order to effectively use the hash, the two sites need to have a “shared secret” aka “The Salt” that only they know.

In order to generate the hash, you append the salt to the user id, and then run it through a one way hashing function. The result is a unique key that can only be generated by the two parties who know the salt (or generated by anyone who knows the salt, so make sure the salt stays very secure). Since it is a one way function, it would be very difficult for someone to reverse engineer it.

Now that we have the id and the hash explained, lets talk about how bar.com can use this to authenticate the user. When a user on Foo.com first logs in, the shared cookie is created by foo.com, and when they hit a page in the iFrame which is pointing to bar.com, bar.com checks the cookie. If it is there, it has the user id and hash of the remote user.

Step one for bar.com is to take the user id, hash it (based on the agreed upon salt), and first verify that it matches the hash that is supplied as the second part of the cookie. If it matches, it is safe for bar.com to assume the user id in the cookie is the user id of the remote user, thus bar.com can log the user in.

This method is not the most secure method of doing a single sign on as a hacker can easily do a man in the middle attack and thus obtain the cookie, and hash, and then with the user id and hash in hand, can easily log in to bar.com as the remote user.

There are a few precautions you can take if you choose to use this method like adding values to the salt like, date, time, request id, that would make the request unique not only to a user, but to a specific time of day or a specific request. Another approach you can take to make this more secure is to simply use SSL across the wire.

Keep in mind we used this method as a simple way of verifying user identity, we were not concerned with either site getting hacked as we had other security mechanisms in place.

So, please take this approach with a grain of salt.