Since finding a good starter document is a very important decision, I took my time to select my first RoR source. I went over the following books and decided to use the latter one:

• Ruby on Rails For Dummies
• Sitepoint Simply Rails 2nd Edition
• Beginning Ruby on Rails
• The Ruby on Rails Tutorial Book

Although it is called as a tutorial, when you get the pdf dump, the 12 chapter tutorial is approximately 500 pages, which is literally a book.

The language of the book is very clean and most of the time funny. You can easily develop the code when you are reading it.  You can also follow a test driven approach if you want, but you don’t have (I didn’t).

I finished the book in 7 days with a daily 4 hours concentrated reading/coding sessions and with lots of Starbucks Misto (thanks Starbucks Besevler crew!).

The final code is at Github, and live demo site at Heroku.

As a pointer for the further steps, the tutorial suggest some pointers but I prefer to go on with my path, which requires ImageMagick and Paperclip, so next post will be about these two.

See you next time!

ps. I really like Heroku. Grails has something similar but to be honest, it is not that magical (as in iPad).

Java Dergisi dagitim olarak cok iyi bir is basarmis, neredeyse her yerde gormek mumkun. Derginin fiyati biraz yuksek(9.90) ozellikle Java ile ilgilenmesi olasi ogrenciler icin fiyat biraz hedef kitleyi dusurebilir. Derginin basim kalitesini dusurerek, dergi fiyatinda biraz oynama yapilabilir diye tahmin ediyorum, cunku kullanilan kagit cok cok sacma bir bicimde kaliteli. Guzel ornekler icin, bkn Matematik Dunyasi, Wired, NTV Bilim.

Yazilar korktugum gibi giris seviyesi tutoriallardan olusmuyor, gerci burada bir denge yakalamak cok zor, onlarca dali olan java dunyasinin hangi alanina girseniz bir uzmanlik alani cikiyor. Ornegin Java ME ve Androiddin arka arkaya yazilar ile islenmesi cok hostu. Biri gitmek uzere olan, biri yerlesmeye baslamis siki teknoloji.

Teknik yazilarin disinda, birazda genel havayi soluyan yazilarin eklenmesi derginin okuma keyfini arttirabilir, ornegin bu sayida James Gosling’in SUN’dan ayrilmasi ya da Oracle’in SUN’i satin almasi satir aralarinda gecistirilmis.

Son olarak, derginin Java dergisi olmasi illaki Java programlamasi ile ilgili olmasini gerektirmez. JVM ustunde calisan diger dillerden de bahsedilmesi (jruby, jython, scala, groovy) ve bunlari kullanan frameworklerin tanitilmasi da bence onemli bir katki olur.

Umarim dergi yeterli satis rakamlarini saglar ve surekliligi saglayabilir.

For the close button, instead of adding a hyperlink from the java code, this time we used JSNI which enables you to integrate JavaScript directly into your application.

We have a class called GenericNotifcation in the package org.remote.dogan.client. When a noticition bar is needed,

public static void showNotification(String message, int seconds)

is called.To hide the bar the following method is called,

public static void hideNotification()

So, to make the JSNI close method call from js, we need to call the hideNotification java method from js.

To do this, we add amethod to register hideNotification method a js method for the handwritten javascript

public static native void exportStaticMethod() /*-{
$wnd.closeNotification =
	@org.remote.dogan.client.GenericNotifcation::hideNotification();
}-*/;

As a second step, we should call the method exportStaticMethod() to actually make the registration of the js method. We do this in showNotification method but for a generic case, onModuleLoad is good candidate.

public static void showNotification(String message, int seconds)

{
GenericNotifcation.exportStaticMethod();
...
}

So as the last step, we add the js call in the html template like the following:
<a title=”close this notification” onclick=’closeNotification()’ />x</a>

For further information, the documentation for GWT JSNI is here.

Step 1. Get a Twitter account and create a Twitter application from http://twitter.com/apps (don’t forget to check in browser and enter a  valid callback url.

Step 2.  Download twitter4J add the library (in my case twitter4j-core-2.1.1-SNAPSHOT.jar) to project and update classpath

Step 3. Create a web application (I assume you have the Google plugin for Eclipse )

Step 4. Add the following servlets and update your web.xml. First servlet will handle login part. It will create a RequestToken which will create the magical aggrements between the consumer(your application) and provider(twitter). First servlet save the  token and secret token since we will need them later.

String token = requestToken.getToken();
String tokenSecret = requestToken.getTokenSecret();

• Home servlet
• Login Servlet

Step 5. You forget to update web.xml didn’t you, update the web.xml

Step 6.  Enable session by adding

    <sessions-enabled>true</sessions-enabled>

to appengine-web.xml.

You can see my version from http://90.latest.denemekaya.appspot.com/login

ps. don’t forget to set the callback in Twittter to the url of the servlet for callback.

Links:

• http://www.pakzilla.com/2009/10/03/tutorial-java-based-twitter-app-on-google-app-engine/
• Explain the same procedure with Grails — http://blogs.bytecode.com.au/glen/2009/12/08/log-into-your-grails-app-using-your-twitter-credentials.html

Memcache provides convenience to store a frequent query in memory, so that you don’t have to make the same execution over and over again. For the iPhone application I build (Fragman), I build a GAE/J backend for managing movie names, IMDB URLs, thumb images, video files, etc. It interacts with the Obj-c code via calls encoded in JSON.

Since the categories are updated so frequently (new trailer, top 250 , soap opera trailers), every time the user starts the application from her iPhone, the corresponding categories Id(key) lists are  created which includes all the aspects mentioned above,

what I see, after people start to use the application that, most of the time, the application got stuck with the time constraint of GAE and this causes inconvenience, so I decided to hold the category lists’s JSON in memory. Following is the code ,

this is the servlet for creating the JSON which is called after say upcoming movie list is changed. This servlet updates the memcached list

        List keyList = new ArrayList();
	static Cache cache;
	static
	{
		try
		{
			CacheFactory cacheFactory =

CacheManager.getInstance().getCacheFactory();
			cache = cacheFactory.createCache(

Collections.emptyMap());
		}
		catch (CacheException e)
		{
			// ...
		}
		//.....
                public void doGet(HttpServletRequest request,

HttpServletResponse response) throws ServletException, IOException

	        {
                       //................
                       if(cache.containsKey(mode))
		       {
			     cache.remove(mode);
		       }
		       cache.put(mode, keyList);
	        }

                //........

          }

And this is the servlet that fetch the Fragman beans from the datastore with the given keys (key list is got from the memecached list)

          keyList = (List)cache.get(mode);

By doing this, I reduce the time that the servlet that creates the JSON takes.

The chart will show the remaining number of months in the current year.

• First download the jar from the project home page http://code.google.com/p/gchart/
• Put it under war/WEB-INF/lib and add the gchart.jar to your classpath
• Create a  Web Application project called it GChart-samples (I assume you have Google Eclipse Plugin and follow the basic steps from here)
• This step is for make-up, find GChart_samples.html under war/WEB-INF and clear the part between <body> tags.
• Open GChart_samples.gwt.xml and add the following line

  <inherits name='com.googlecode.gchart.GChart'/>

• Create a class in client folder called FirstChart and change it as the following

  package com.dogan.kaya.client;
  
  import com.googlecode.gchart.client.GChart;
  
  public class FirstChart extends GChart
  {
  	public FirstChart()
  	{
  		setChartSize(350, 350);
  
  		addCurve();
  
  		int[] data = { 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
  		for (int i = 0; i < data.length; i++)
  		{
  			getCurve().addPoint(i + 1, data[i]);
  		}
  		//curve customization
  		getCurve().getSymbol().setHeight(10);
  		getCurve().getSymbol().setWidth(10);
  		getCurve().getSymbol().setBorderColor("black");
  		getCurve().getSymbol().setBorderWidth(3);
  		getCurve().getSymbol().setSymbolType(SymbolType.LINE);
  		getCurve().getSymbol().setFillThickness(2);
  		getCurve().getSymbol().setFillSpacing(0);
  		//chart customization
  		getXAxis().setAxisMin(1);
  		getXAxis().setAxisMax(12);
  		getXAxis().setTickCount(12);
  		getXAxis().setHasGridlines(false);
  		getXAxis().setTickLocation(TickLocation.CENTERED);
  		getXAxis().setTickLabelFontSize(10);
  		getYAxis().setAxisMin(0);
  		getYAxis().setAxisMax(12);
  		//to get inteter values on y axis, be careful
  		//about the number of intervals it can be tricky
  		getYAxis().setTickCount(13);
  		getYAxis().setTicksPerLabel(2);
  		getYAxis().setHasGridlines(false);
  		getYAxis().setTickLabelFontSize(10);
  		//
  		update();
  	}
  }

• Open GChart_samples class and change it like the following

  package com.dogan.kaya.client;
  
  import com.google.gwt.core.client.EntryPoint;
  import com.google.gwt.user.client.ui.RootPanel;
  
  public class GChart_samples implements EntryPoint
  {
  	public void onModuleLoad()
  	{
  		RootPanel.get().add(new FirstChart());
  	}
  }

• My output is sth like that

ps:

some nice links about gchart are as follows:

1. gchart homepage
2. A simple tutorial at http://whatwouldnickdo.com/wordpress/264/simple-charts-in-gwt-with-gchart/

Anyway, for some time I consider turn back to good old J2EE, then wander on the land of some other Java enterprise frameworks (Spring MVC, Wicket, Struts 2, Hibernate etc ) then Google App engine Java with its in progress full stack framework like environment. Then I decide that all the ones mentioned above has steep learning curves and without feeling complely comfortable with them, It is imposible to develop sth quickly.

Then the obvious direction was rails. First give a try to Django, then read some about  RoR but both of them somehow scare me out. I need to learn a new language (which Django tutorial specificly warns about looking a good python tutorial before devlde into Django), on the other hand, Grails (my love!) just start the sentence with “don’t worry about the groovy, you can learn it along the way”.

Obviously, Grails is relatively new compared to two other alternative and it has (or used to have) to many bugs for a relaible product.

But trust me, it is easy to just start and kick the first alfa version of sth out is a joy.

–

Ok this post is suppose to be a yet another introduction to Grails tutorial, so…

Steps to Get Started

1.  install Grails (there is nothing I can add here — http://www.grails.org/Installation)

2. open command line and create a project with grails create-app Yeap

3. Go to the created directory cd Yeap

4. Type grails run-app

That’s it!

I’m currently using Apache Shiro plugin (previously JSecurity), Gwt plugin, Postgresql, Eclipse for the development, More posts related to these will be here soon (I hope)

tagaroo suggests this image is appropriate for the post

This was again the case with an old mysql table with encoding utf8_general_ci. Before there was UTF-16 then UTF-8 now I have deal with the subleties of utf8_general_ci (which is in fact has other types like utf8_unicode_ci).

Anyway, after spending hours just to see the correct characters in the console, very near to the point I gave up, I found a link that suggest to just replace the unwanted characters like “ç” to ç. here is the complete list that I use in Java,  but be careful about the order you replaced:

textVal = textVal.replace("ÄŸ","ğ");
textVal = textVal.replace("ı","ı");
textVal = textVal.replace("Ä°","İ");
textVal = textVal.replace("Ä","Ğ");

textVal = textVal.replace("Ü","Ü");
textVal = textVal.replace("ü","ü");
textVal = textVal.replace("Ç","Ç");
textVal = textVal.replace("ç","ç");
textVal = textVal.replace("Ö","Ö");
textVal = textVal.replace("ö","ö");
textVal = textVal.replace("ÅŸ","ş");
textVal = textVal.replace("Å","Ş");

Yeap, that solved my problem, thanks to you guys at the forum. But, I still doesn’t understand why we still need to have that number of encoding!