• Less cluttered, easily readable, developer and browser friendly template files
• Speed
• Safety
• True separation of concerns

To achieve these goals Cambridge was designed differently than it’s alternatives like JSP, Freemarker or Velocity. The main idea in template syntax in Cambridge is not to add any code blocks or wrapping elements into your existing template markup. The markup languages like html and xml already have a well structured hierarchy of tags. Every tag has a built in scope. (We know where it starts and ends.) Cambridge makes use of this scope which already is in your template files. You associate behaviors to your tags and that behavior becomes active within the scope of that tag.

To achieve the performance goal, every template file gets parsed only once and then gets normalized into an efficient form to be rendered. What do I mean by an efficient form? Every web developer knows that DOM is. When your template files are parsed, a DOM like tree for all your template elements is created by Cambridge. Traversing this tree while rendering would work, but would be ineffective in many performance critical scenarios. What Cambridge does is basically to flatten this tree into a list of fragments to be printed to an output stream. A fragment might be static or dynamic based on if it is an expression to be evaluated or a tag which has some dynamic behavior associated or any standard tag or text. This new normalized form is used by Cambridge again and again until the template file is changed and need to be re-parsed.

So lets have a look at how some of the features of Cambridge compare with other alternatives.

Expressions

Evaluating expressions are very similar in almost all templating solutions for Java. JSP, Freemarker, Cambridge, Play Framework all uses the ${…} syntax to escape from html and print the value of an expression. Velocity is a bit different, it doesn’t require you to use braces, you can just type $userName to get the value of the userName variable.

Every template engine has a different underlying expression language. JSP uses the Jsp Simple Expression Language. Freemarker and Velocity have their own expression languages. Play Framework uses Groovy which actually is much more than an expression language.

Cambridge comes with a built in expression language that I’ve developed which depends on Antlr runtime. However, thanks to the extensible nature of Cambridge, you are not limited to that. If you want more features with a little sacrifice of performance, you can use MVEL or OGNL as your expression language in your Cambridge templates.
For many people, built-in expression language should be enough, however I must say that I’m also very impressed by MVEL.

Conditional Blocks

JSP with JSTL

No true else/elseif support.

<c:if test="${loggedInUser != null}">
  <div class="hello">Hello ${loggedInUser}</div>
</c:if>
<c:if test="${loggedInUser == null}">
  <div class="logIn">Please log in</div>
</c:if>

JSP with inline Java code

<%
if (loggedInUser != null) {
%>
<div class="hello">Hello <%=loggedInUser%></div>
<%
} else {
%>
<div class="logIn">Please log in</div>
<%
}
%>

Velocity

#if ($loggedInUser)
  <div class="hello">Hello $loggedInUser</div>
#else
  <div class="logIn">Please log in</div>
#end

Freemarker

<#if loggedInUser??>
     <div class="hello">Hello ${loggedInUser}</div>
<#else>
     <div class="logIn">Please log in</div>
</#if>

Play Framework

#{if loggedInUser}
       <div class="hello">Hello ${loggedInUser}</div>
#{/if}
#{else}
       <div class="logIn">Please log in</div>
#{/else}

Cambridge

In Cambridge, you don’t need to wrap your tags with code blocks or other tags. You just add dynamic attributes like a:if, a:elseif or a:else to your existing classes.

<div a:if="loggedInUser != null" class="hello">Hello ${loggedInUser}</div>
<div a:else class="logIn">Please log in</div>

What if you don’t have an existing tag that wraps whatever content you want to depend on a condition? Then you can use the invisible tag <a:span>.

The output of the following example will only be the text message without the <a:span> tag being rendered in the output.

<a:span if="messages.size != 0">
   You have ${messages.size} messages
<a:span>

Loops

JSP / JSTL

<c:forEach var="friend" items="${user.friends}">
   <div>${friend.name}</div>
<c:/forEach>

Freemarker

<#list user.friends as friend>
   <div>${friend.name}</div>
</#list>

Velocity

#foreach($friend in $user.friends)
   <div>$friend.name</div>
#end

Play Framework

#{list items:user.friends, as:'friend'}
       <div>${friend.name}</div>
#{/list}

Cambridge

   <div a:foreach="user.friends" a:as="friend">${friend.name}</div>

In the second part of this article, I will write about the performance comparisons of these frameworks.

Vaclav Pech at JAX 2010 from Egor Malyshev on Vimeo.

First of all let me write about what is new in this release. Perhaps the most important change in 0.2 is the new expression language architecture. In version 0.1 you were able to use only the built in custom expression language. I realized that there are other good expression language alternatives for Java that are very popular which could be used with Cambridge. With release 0.2, Cambridge not only supports the built-in simple expression language but also allows you to use either MVEL or OGNL. You can also integrate other expression languages by only implementing two simple interfaces.

Another big new feature is template inheritance. Cambridge templates now can extend other templates and the child template can override parent templates tags. Here is an example of how it works:

Parent template: (skeleton.html)

<html>
<head><title>${title}</title>
<body>
<div class="mainMenu">
   <div id="menuElements"></div>
</div>
<div id="main"></div>
</body>
</html>

Child template:

<!--$extends "skeleton.html"-->
<div id="menuElements">
  <ul>
    <li>Home</li>
    <li>Products</li>
    <li>About Us</li>
    <li>Contact</li>
   </ul>
</div>
<div id="main">Main Content</div>

So what happens here is that every element that you define in the child template overrides the element with the same id of the parent element. Unlimited levels of inheritance is supported and this doesn’t cost you any performance penalty whatsoever.

A nice addition to the templates are true if/elseif/else conditional blocks. In version 0.1, all you could add as a conditional tag behavior was an if statement. Now you can do the following:

<div a:if="speed > 80">Fast</div>
<div a:elseif="speed > 40">Not so fast</div>
<div a:else>Slow</div>

The only trick here is that the elements of a conditional block can be only separated by white space. No other tag or text node can come between nodes marked with conditional tag behaviors.

A nice addition to the supported web frameworks in version 0.2 is the Play Framework. Now if you put cambridge-playframework.jar and cambridge-core.jar into your classpath, you can start using Cambridge as your template engine in play framework. My benchmark tests show 2.5 times faster page rendering times compared to Play Framework’s own template engine! Play framework support is built with the new extension point API which allows you to alter tokenizing and parsing behavior of template parser for custom code blocks. If you want to decide how template blocks starting with %{ and }% are handled for instance, you can create an extension point for that.

Support for Spring MVC and Struts 2.0 are also work in progress for version 0.2.

The core functionality has reached a feature freeze and there doesn’t seem to be any show stopper bug for the 0.2 release right now. I released a beta today and after Spring MVC and Struts 2.0 integrations are complete and the documentation is updated, I will release 0.2.

I think this is amongst the best FPS games ever. The first game of the series was also very nice. The story really gets you into the game. The only thing I can think of as a negative is that the single player campaign mode is a bit short. (Maybe I felt that way because of the excitement). Looking forward for a third game of the franchise.

Here is an example to get the search result urls of a query that is made on google:

url = "http://www.google.co.uk/search?hl=en&q=${1}&btnG=Search&meta=&aq=1";
query = "erdinc yilmazel";

echo "opening " + url(query.urlEncode());

open url(query.urlEncode()) as input;
read input {
   locate "<h2 class=hd>Search Results</h2>";
   do {
      locate "<li class=g>";
      locate "<h3 ";
      locate "<a href=\"";
      capture as link until "\"";
      echo link;
      links += link;
   } until "</ol> </div> <!--z-->";
}

The script above prints every url that is gathered to the output and also collects them in a list named as links (Actually an ArrayList in Java). At the time of writing executing the script gives the following output:

opening http://www.google.co.uk/search?hl=en&q=erdinc+yilmazel&btnG=Search&meta=&aq=1
http://tr.linkedin.com/in/erdincyilmazel
http://www.facebook.com/erdincyilmazel
http://blog.erdincyilmazel.com/2010/01/05/open-sourcing-some-projects/
http://developer.amazonwebservices.com/connect/message.jspa?messageID=147347
http://markmail.org/message/x6irtpux7euhnptj
http://www.vclcomponents.com/PHP/Development_Tools/Libraries_and_Classes/MyObjects-info.html
http://www.aboutus.org/erdinc.yilmazel.com
http://groups.google.com/group/javawug/browse_thread/thread/6e0a171748a8b735
http://vaadin.com/forum/-/message_boards/message/89339
http://www.myobjects.org/

The thing about “Content Retrieval Engine” is that it doesn’t have to read all the document and get it into memory to do data extraction. It does everything in a single pass while reading from the input stream. This allows it to run very fast and very memory efficient. You can extract information from huge documents that are several gigabytes.

So what is tinymashup.com? I am planning it to be a hosted service to run CRE scripts. You can write your scripts, run them against any web page and get the output in any format you like such as XML, JSON, plain text etc. You will be able to write scripts and share them with others. I am also planning on licensing the technology to people who need it. (I can also open source it too, haven’t decided yet )

The other project, which is currently in active development is the Cambridge Template Engine. It is a template framework for Java which I’ve been dreaming about for more than a year. I started working on Cambridge in mid 2008. To be honest, I wasn’t able to devote enough time for it to make it a usable product for a long time. A few months ago, while struggling with JSP, I decided to get back on it and I’ve been working hard for a stable version. One of my colleagues working on istanbul.net already started using Cambridge in a project which will soon become online.

What makes Cambridge different from other template engines like Freemarker or Velocity? Well, first of all Cambridge was designed to generate especially HTML or other markup documents like XML. Cambridge knows the tag structure of your template documents even if they are not well formed. This allows you, as a developer, to use the scope of html tags that is already in the document instead of wrapping your html with external code or tags.

For instance, if you want a portion of html to be viewed based on a condition you would write something like this in JSP

<s:if test="conditionMet">
<div id="someDiv">
<strong>Some content</strong>
</div>
</s:if>

or

<%
if(conditionMet) {%>
<div id="someDiv">
<strong>Some content</strong>
</div>
<% } %>

It would also look like the one above if you were using PHP too. On the other hand, Cambridge knows where the div element starts and ends. So the same code in cambridge is written as this:

<div a:if="conditionMet" id="someDiv">
<strong>Some content</strong>
</div>

The code above is a simple html document which can be viewed in any browser or html authoring tool without a problem. Unless absolutely necessary, Cambridge does not introduce any new tags to the template file. You only need to add extra attributes to your tags to associate some behaviours.

I am currently trying to improve the documentation for Cambridge and I need feedback for both of the libraries. Please report any bugs, feature requests or comments on the project pages.

Neyse, fazla lafı dağıtmadan eclipselink’e döneyim. Bildiğiniz gibi Oracle persistence provider’ı olan toplink ürününün bir nevi light versionu olan toplink-essentials‘ı open source camiasına hediye etmişti. Glassfish’in bundan önceki sürümlerinde de (V1 ve V2) toplink-essentials kullanılıyordu. Ancak geçen sene içinde Oracle toplink ürününün tamamına ait kaynak kodunu Eclipse Foundation’a bağışladı ve Eclipselink ortaya çıktı. 2008 Mart ayında ise Sun Microsystems, Eclipse ve Oracle ortak bir girişimle Eclipselink’in JPA 2.0 referans implementasyonu olmasına karar verdiler. Şu anda 1.0.2 stable sürümü olan Eclipselink Glassfish V3 ile birlikte bizlere sunuluyor.

Tabi uygulama sunucusu olarak Glassfish V3 tercih edildiğinde geliştirme ve test aşamalarında da yine aynı ortamı sağlamak amacıyla Eclipselink kullanmak zorundasınız. Başka bir JPA provider kullanabilirsiniz elbette ama hem eclipselink’in kendine has özelliklerini kullanmak, hem de uygulama sunucusu üzerinde çalıştırdığınızda sürprizlerle karşılaşmamak için unit testlerinizi de yine aynı persistence provider ile çalıştırmak isteyeceksinzdir.

Bunun için aslında güzel bir tutorial yazmak isterdim ama benden önce çok güzel şekilde yazmışlar. Sade ve işe yarar küçük bir örnek olan bu tutorial’da maven ile eclipselink kullanarak mysql ya da derby database’i üzerinde DbUnit ile nasıl unit testler çalıştırabileceğinizi anlatıyor. (Amma cümle oldu!!! içinde binbir tane buzzword var!!) Tutorial’ı yazan arkadaş örnek kodları da favori ide’m olan intellij projesi olarak da koymuş daha bir güzel olmuş

Eclipselink’in kendine has JPA’dan ayrı bir takım eklentileri ve iyi olduğu söylenen cache mekanizması var. (Henüz derinlemesine incelemedim.) Bu kendine has özellikleri Eclipselink JPA Extensions adı verilen bir api ile sunuyor. Bu api içerisinde standard JPA annotation’larına ek olarak kullanabileceğiniz ekstra annotationlar var.

Son olarak glassfish’in de Eclipselink kullanımı ile ilgili kendi dökümantasyonu olduğunu söyleyeyim. Glassfish V3 Prelude her ne kadar Prelude adı insanı yanıltsa da production ready ve Sun tarafından ticari olarak desteklenen bir ürün ve iyi şekilde dökümante edilmiş. Yalnızca eksiği bir V3′e ait planlanan tüm özelliklerin implement edilmemiş olması. Örneğin clustering yok.

Şuan için refactoring, debugging gibi desteklerin olmadığını da söylemek lazım. Python kodlamak için pek çok editör denedim, eminim problemleri giderildiğinde intellij’den başkasını kullanmayacağım, ancak şuanda en iyi pytyon ide’si olarak eclipse’in pydev plugini gözüküyor.

Daha önce bahsettiğim Netbeans’in python plugin’i de hızlı şekilde development’a devam ediyor ancak orada da özellikle sistem pathinden import edilmiş diğer libraryler ile ilgili autocompletion özellikleri düzgün çalışmıyor. (Konuyla ilgili bug report ettim)