And here’s the reply from the domain team (technical team,I suppose)
“Both websites http://just-thor.com/ and http://bobokow.com/ are working fine at our side. Please check again.”

But I still can’t open the website on my site. I even asked a friend of mine which was at another location to test and still failed. Hence I replied an email.

“Sir/Madam,
Attached with the error page. I am glad its working on your side, but I am not browsing at your side,so please fix it.”

ps. site was up one hour later I replied the email. Thank you for the hardwork.

Here’s part of the code

//sample code taken from http://code.google.com/apis/ajaxlibs/
<script src="http://www.google.com/jsapi"></script>
<script>
  // Load jQuery
  google.load("jquery", "1");

  // on page load complete, fire off a jQuery json-p query
  // against Google web search
  google.setOnLoadCallback(function() {
    $.getJSON("http://ajax.googleapis.com/ajax/services/search/web?q=google&v=1.0&callback=?",

      // on search completion, process the results
      function (data) {
        if (data.responseData.results &&
            data.responseData.results.length > 0) {
          var results = data.responseData.results;
          
          for (var i=0; i < results.length; i++) {
            // Display each result however you wish
            alert(results[i].titleNoFormatting);
          }    
        }
        
      });
    });
</script>

//sample code taken from http://code.google.com/apis/ajaxlibs/
<script src="http://www.google.com/jsapi"></script>
<script>
  // Load jQuery
  google.load("jquery", "1");
</script>
<script>
  // on page load complete, fire off a jQuery json-p query
  // against Google web search
  google.setOnLoadCallback(function() {
    $.getJSON("http://ajax.googleapis.com/ajax/services/search/web?q=google&v=1.0&callback=?",

      // on search completion, process the results
      function (data) {
        if (data.responseData.results &&
            data.responseData.results.length > 0) {
          var results = data.responseData.results;
          
          for (var i=0; i < results.length; i++) {
            // Display each result however you wish
            alert(results[i].titleNoFormatting);
          }    
        }
        
      });
    });
</script>

Happy Coding

Here’s the release note.

The new Scala 2.8 codebase includes the following new fixes and features:

• Redesigned collection library
  The collection library has undergone a complete overhaul for Scala 2.8, offering a more coherent and efficient design, while maintaining virtually complete compatibility with existing sources. Detailed information at: http://www.scala-lang.org/sid/3
• New array implementation, manifests for polymorphic arrays
  Handling of arrays has been simplified and optimized in Scala 2.8. The previous compiler magic has been replaced by a more systematic and predictable implementation in terms of implicit conversions. Full details at: http://www.scala-lang.org/sid/7
• Type specialization
  Scala 2.8 adds specialized type parameters, which enable the compiler to generate transparently multiple versions of a given definition, and to use the most specific version whenever the static type information at a call site allows it. Details at: http://www.scala-lang.org/sid/9

• Named and default arguments
  Named arguments improve the readability of method calls with many arguments. Default arguments reduce code duplication, and enable “copy” methods for case classes, useful to generate quickly modified copies of case classes. A complete description at: http://www.scala-lang.org/sid/1

• Package objects
  Packages can now contain besides classes and objects also methods, fields or type aliases. These are added to a package by declaring a package object. Package objects are still work in progress; more capabilities might come for 2.8 final or a release soon afterwards.

• Beefed up Scala Swing libraries, better documentation
  Components publish key events, input events can be consumed, refactored window subhierarchy, additional demos, Swing listeners are installed lazily, more complete component caching, minor refactorings, bugfixes, more Scaladocs. Design document at: http://www.scala-lang.org/sid/8

• Revamped REPL
  Many bugfixes. Tab-completion for all packages on the classpath, as well as object and instance methods and fields, including type aliases and package objects. Searchable history, integrated shell access, and a power mode which offers direct access to compiler internals.

• Implicits changes
  We have refined the implicit resolution process so that resolution is now able to determine type variables.

• Improved equality
  Equality across numeric types is to be consistent across all the primitives types, while also adhering to the equals/hashCode contract. Numeric comparisons will have the same results as they would between Java primitives. This is currently still being completed.

• Packrat parser combinators
  With support for packrat parsing, parser combinators are now able to handle left-recursive grammars and will show improved performance for ambiguous productions.

• Improved XML library
  Many bugfixes.

• Type constructor inference
  Type inference has been extended to deal with type constructors, so that, in certain cases, you can omit type parameter lists that contain higher-kinded types (aka type constructors, e.g., List).

• Improved Annotations
  Scala 2.8 adds support for nested java annotations. For annotations on fields, it is now possible to specify which synthetic members (getter / setter) will have the annotation. Documentation about Scala annotations can be found at: http://www.scala-lang.org/sid/5

• Enhanced actors
  New Reactors provide more lightweight, purely event-based actors with optional, implicit sender identification. Support for actors with daemon-style semantics was added. Actors can be configured to use the efficient JSR166y fork/join pool, resulting in significant performance improvements on 1.6 JVMs. Schedulers are now pluggable and easier to customize.

• Support for continuations
  Continuations are supported by a compiler plugin. This plugin is not included in this first beta, but will be added in subsequent releases.

Here’s the office page link and here’s the download link.

And now,my current company requested every one in the company to use Outlook as the mail client. The experience isn’t that great though. I took 5 minutes to send an email because I don’t know how to use the address book function. I used to get that by typing name or email,and gmail just suggest me possible match. Too many buttons, what’s the difference between “Attach Item” and “Attach File”? And when I try to search for person in my address book,I just can’t. For instance, I am trying to search for a name “John Doe”,I have to type “John” first in Outlook to locate the entry,but instead I type “Doe” in Gmail it will start suggesting me.And there are so many fields in address book.Oh man,its driving me crazy.

I think the simplicity and usability of Gmail had make me stupid.Thanks, Google.

Happy coding

If you look carefully,there is a photo with a lamp post and some snows on it.I can’t help wondering how come the snow can shape like a snake or whatever it reminds you of.

Hope you like the photos

Here’s the code of it.

package com.justthor.reader

import scala.io.Source
import scala.xml._

object SimpleFeedReader {
  def main(args : Array[String]) : Unit = {
    val url = "http://just-thor.com/feed/"
    val data = XML.loadString( Source.fromURL(url).mkString )
    data \ "channel" \ "item" foreach(
      a => println((a \ "title" text) + " == "  + (a \ "link" text))
    )
  }
}

Ok,let’s go thru the code line by line.

At line 09, again we use Source to load content from url,by calling the method fromURL(quite obvious,right?).The mkString will create a String out of the content. Then, we use XML.loadString to parse the String into an XML object.

At line 10, we traverse the XML object with something like XQuery.
The RSS xml format is something like this

<channel>
<link>...</link>
<description>...</description>
<!-- item 1-->
<item>
  <title></title>
  <link></link>
</item>
<!-- item 2-->
<item>
  <title></title>
  <link></link>
</item>
<!-- and the rest goes here -->
</channel>

So when we write

data \ "channel" \ "item"

Here’s the output of the result

File Reading in Java and Scala == http://just-thor.com/2009/10/01/file-reading-in-java-and-scala/
PHP communicate with Java using JSON – Unicode Version == http://just-thor.com/2009/09/28/php-communicate-with-java-using-json-unicode-version/
Scala And JDBC == http://just-thor.com/2009/09/27/scala-and-jdbc/
A mistake or fate? == http://just-thor.com/2009/09/17/a-mistake-or-fate/
Women are weird == http://just-thor.com/2009/09/13/women-are-weird/
20 must visit sites for Java developer == http://just-thor.com/2009/09/12/20-must-visit-sites-for-java-developer/
Why do I practice pair programming? == http://just-thor.com/2009/09/08/why-do-i-practice-pair-programming/
Installing Scala on Windows == http://just-thor.com/2009/09/02/installing-scala-on-window/
Logging for different requested URI in Apache HTTP Server == http://just-thor.com/2009/09/01/logging-for-different-requested-uri-in-apache-http-server/
Say hello to Java and Scala == http://just-thor.com/2009/08/30/say-hello-to-java-and-scala/

And now we have a very simple yet functional RSS parser.

Happy coding,

This is normally how we read files in Java.First we open a reading stream, then read the content and process it,and at last we close the stream.

package com.justthor;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class SampleFileReader {

  /**
   * @param args
   */
  public static void main(String[] args) {
    BufferedReader in; 
    try {
      // Open file
      in = new BufferedReader(new FileReader("test.txt"));
          String str;
       
          // Start reading
          while ((str = in.readLine()) != null) {
        // Print the content
        System.out.println(str);
          }
          
          // Close the stream
          in.close();
      } catch (IOException e) {
        e.printStackTrace();
      }
  }
}

With some third party libraries, such as Apache Common Io, we can simplify the code to something like this.

package com.justthor;

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.apache.commons.io.FileUtils;

public class SampleFileReader {

  /**
   * @param args
   */
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    try {
      List<String> contents = FileUtils.readLines(new File("test.txt"));
      for ( String content : contents ) {
        System.out.println(content);
      }
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
}

Well, it does look a bit simple now compare to the previous version. But we only manage to type 1 or 2 lines less than the previous version. This is due to we are force to handle the checked IOException. What if we try to achieve the same thing using Scala?

package com.justthor

import scala.io.Source

object SampleFileReader {
 def main(args : Array[String]) = {
  Source fromFile("test.txt") getLines foreach { println }
 }
}

Its much simple, right? Scala provides an util for IO named Source. This util read the file and get the contents by calling getLines method. This getLines method returns a Iterator[String]. And from there we can process the content by looping the returned iterator. We can use Source util to do more than reading files. I will provide more examples in the next few posts.

Happy coding.

For instance,we want to store a PHP array in database and later to be processed by Java,we can do something like

$aValue = array("key1"=>"value1","key2"=>"value2");
$sEncodedValue = json_encode($aValue)
//we will get something like {"key1":"value1","key2":"value2"}
//and then, we store the value to db

On the other hand,we use Java to read it and decode it.

//read from db and got the resultset,assuming we are using JDBC
while (rs.next()){
String rawValue = rs.getString("encodedValue");
// since we encoded an associative array,it will be translated to a Java Map object instance.
// we are using JSON-lib for JSON parsing the following example
JSONObject json = JSONObject.fromObject(jsonString);
Map decodedValue = (Map) JSONObject.toBean(json, Map.class);
String value1 = decodedValue.get("key1");
}

What if we are trying to store unicode value using JSON format in PHP?
For example,

$aValue = array("key1"=>"你好吗","key2"=>"value2");
$sEncodedValue = json_encode($aValue);
//This is what we get after encoded
//{"key1":"\u4f60\u597d\u5417","key2":"value2"}

If you decoded it back to Java,key1 value will return “u4f60u597du5417″ instead.This is so wrong.

How to solve it?
We can use mb_convert_encoding function in PHP.
Let’s make some changes to our code.

$aValue = array("key1"=>mb_convert_encoding("你好吗", "UTF-8"),"key2"=>"value2");
$sEncodedValue = json_encode($aValue);

By doing so,values are stored in database in unicode format,and you can decode it back in Java.

Happy coding.

Here’s the code

// Import JDBC package from standard Java SDK
import java.sql.{Connection, DriverManager, ResultSet};

class DataReader {
  // Load the driver
  Class.forName("com.mysql.jdbc.Driver").newInstance;

  val connection = DriverManager getConnection "jdbc:mysql://localhost:3306/mail?user=root&password=&characterEncoding=UTF8"

  def startReadingData(){
    try{

      // Create statement for readonly
      val statement = conn createStatement (ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY)

      val rs = statement executeQuery "select * from mail_queues order by id"

      // Looping resultset
      while (rs next) {
      println (rs getLong "id")
      }

      statement close
    }catch {
      case e => e printStackTrace
    }finally {
      connection close
    }
  }

}

Ok, you maybe wondering,why are so many dots(.) and parentheses missing?In Scala,when you are invoking one function with no or one parameter, you can omit the dot and parentheses. And Scala doesn’t have checked exception, which means you can write the above code without enclosed it with try…catch clause.I included it to make sure the DB connection is properly closed after use.

Happy coding.:)