Thomas Amsler

Eclipse "command + hover" doesn't show the "Open Declaration" popup on Mac OS X Lion

2012-01-11T21:10:00.000-08:00

This is a know issue and has been reported here:
https://bugs.eclipse.org/bugs/show_bug.cgi?id=353503

The workaround is to change the following Mac OS X System Preferences.

Open the Mac OS X System Preferences
Click on General
Change the "Show scroll bars:" setting to "Always"

Android: ViewPager and Fragments Part II

2011-11-24T11:17:00.001-08:00

What are the different ways to get a reference to the currently visible fragment page in a ViewPager?

First Solution

You can set a unique tag on each fragment page:

getSupportFragmentManager().beginTransaction().add(myFragment, "Some Tag").commit();

... and then retrieve the fragment page via:

getSupportFragmentManager().findFragmentByTag("Some Tag");

Using this approach, you need to keep track of the string tags and associate them with all the fragment pages. You could use a map to store each tag along with the current page index, which is set at the time when the fragment page is instantiated.

MyFragment myFragment = MyFragment.newInstance();

mPageReferenceMap.put(index, "Some Tag");

getSupportFragmentManager().beginTransaction().add(myFragment, "Some Tag").commit();

To get the tag for the currently visible page, you then call:

int index = mViewPager.getCurrentItem();

String tag = mPageReferenceMap.get(index);

... and then get the fragment page:

Fragment myFragment = getSupportFragmentManager().findFragmentByTag(tag);

Second Solution

Similar to the first solution, you keep track of all the "active" fragment pages. In this case, you keep track of the fragment pages in the FragmentStatePagerAdapter, which is used by the ViewPager.

public Fragment getItem(int index) {

Fragment myFragment = MyFragment.newInstance();

mPageReferenceMap.put(index, myFragment);

return myFragment;

}

To avoid keeping a reference to "inactive" fragment pages, we need to implement the FragmentStatePagerAdapter's destroyItem(...) method:

public void destroyItem(View container, int position, Object object) {

super.destroyItem(container, position, object);

mPageReferenceMap.remove(position);

}

... and when you need to access the currently visible page, you then call:

int index = mViewPager.getCurrentItem();

MyAdapter adapter = ((MyAdapter)mViewPager.getAdapter());

MyFragment fragment = adapter.getFragment(index);

... where the MyAdapter's getFragment(int) method looks like this:

public MyFragment getFragment(int key) {

return mPageReferenceMap.get(key);

}

I am using the second solution in my project, and it's working quite well. Here is the reference to the full source code.

Mount the Samsung Galaxy S II internal SD card on Mac OS X

2011-11-11T15:15:00.001-08:00

Tap on left hand side menu button and then:

Select Settings
Select Wireless and network
Select USB utilities
Tap on "Connect storage to PC" button
When dialog "Connect USB cable to use mass storage." comes up, connect the phone to the computer using a micro USB cable
Then on the next screen tap on "Connect USB storage" button, and then confirm the dialog

Android: ViewPager and Fragments

2011-10-23T21:17:00.000-07:00

The following is a simple Android sample application that uses a ViewPager, which is part
of the Support Package, and Fragments.

The FragmentPagerActivity class creates the ViewPager and the associated FragmentPagerAdapter.

 import android.os.Bundle;  
 import android.support.v4.app.Fragment;  
 import android.support.v4.app.FragmentActivity;  
 import android.support.v4.app.FragmentManager;  
 import android.support.v4.app.FragmentPagerAdapter;  
 import android.support.v4.view.ViewPager;  
   
 public class FragmentPagerActivity extends FragmentActivity {  
   
      private static final int NUMBER_OF_PAGES = 10;  
   
      private ViewPager mViewPager;  
      private MyFragmentPagerAdapter mMyFragmentPagerAdapter;  
   
      public void onCreate(Bundle savedInstanceState) {  
   
           super.onCreate(savedInstanceState);  
           setContentView(R.layout.main);  
           mViewPager = (ViewPager) findViewById(R.id.viewpager);  
           mMyFragmentPagerAdapter = new MyFragmentPagerAdapter(getSupportFragmentManager());  
           mViewPager.setAdapter(mMyFragmentPagerAdapter);  
      }  
   
      private static class MyFragmentPagerAdapter extends FragmentPagerAdapter {  
   
           public MyFragmentPagerAdapter(FragmentManager fm) {  
                super(fm);  
           }  
   
           @Override  
           public Fragment getItem(int index) {  
   
                return PageFragment.newInstance("My Message " + index);
           }  
   
           @Override  
           public int getCount() {  
   
                return NUMBER_OF_PAGES;  
           }  
      }  
 }

The PageFragment only contains a TextView. It is instantiated in the above
MyFragmentPagerAdapter's getItem(int index) method.

 package org.thomasamsler.android;  
   
 import android.os.Bundle;  
 import android.support.v4.app.Fragment;  
 import android.view.LayoutInflater;  
 import android.view.View;  
 import android.view.ViewGroup;  
 import android.widget.TextView;  
   
 public class PageFragment extends Fragment {  
        
      public static PageFragment newInstance(String title) {
  
          PageFragment pageFragment = new PageFragment();
          Bundle bundle = new Bundle();
          bundle.putString("title", title);
          pageFragment.setArguments(bundle);
          return pageFragment;
      }
        
      @Override  
      public void onCreate(Bundle savedInstanceState) {  
          super.onCreate(savedInstanceState);  
      }  
        
      @Override  
      public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
             
          View view = inflater.inflate(R.layout.fragment, container, false);  
          TextView textView = (TextView) view.findViewById(R.id.textView1);  
          textView.setText(getArguments().getString("title"));
          return view;  
      }  
 }

Sources:

git svn info : Can't locate Error.pm : on Mac OS X

2011-07-22T00:02:00.000-07:00

I am using git to access Subversion repositories. After upgrading to the latest git version (1.7.6), I got the following missing pearl module error:

Can't locate Error.pm in @INC ...

To fix this, I just loaded the missing module via:

sudo perl -MCPAN -e 'install Error'

... and everything was working again.

GWT Chart Tools: loading new CoreChart via VisualizationUtils

2011-06-23T11:02:00.000-07:00

The GWT Chart Tools have changed by adding new charts, that are of the same type as the deprecated ones, under "CoreChart". The old charts such as:

com.google.gwt.visualization.client.visualizations.ColumnChart

are deprecated in favor of:

com.google.gwt.visualization.client.visualizations.corechart.ColumnChart

If you are going to update to these new charts, you also have to change the way you load the VisualizationApi. For example, in my application, I used to load three types of chars the following way:

 VisualizationUtils.loadVisualizationApi(new VisualizationRunnable(), PieChart.PACKAGE, ColumnChart.PACKAGE, LineChart.PACKAGE);

When switching to "CoreChart", the above needs to be changed to:

 VisualizationUtils.loadVisualizationApi(new VisualizationRunnable(), CoreChart.PACKAGE);

References:

Chrome OS CR-48 Finding MAC Address

2010-12-13T11:27:00.000-08:00

If you need to know the MAC address of your CR-48 running Chrome OS, type:

chrome:///system

... in the address bar. Then look for "ifconfig" in the list and click on "Expand...". Then you should see a "wlan0" entry which shows you the "HWaddr", which is the MAC address.

How to create a QR Code

2010-08-20T22:01:00.000-07:00

I wanted to create a QR code for my Google profile page. After a little googling, I came across this information. You can use Google's Chart API to generate a QR code:

You can make a call to:

http://chart.apis.google.com/chart?chs=250x250&cht=qr&chl="some url"

e.g.

http://chart.apis.google.com/chart?chs=250x250&cht=qr&chl=http://www.google.com/profiles/tamsler

... and it generates the QR code for the provided URL. You can than use a QR code scanner such as Google Goggles.

Taking Sakai 3 To The Next Level

2010-04-01T14:33:00.000-07:00

The Sakai community has put significant effort into developing the next version of Sakai. Sakai3 will take the collaborative learning environment application space to the next level.

However, some folks in the Sakai community thought that the new development effort is not going far enough in terms of utilizing the latest technologies.

For the past few months, a small group of dedicated programers and UI specialists have been experimenting with some new UI approaches. I am happy to share the results with the community today.

Sakai 3 in 3D (a.k.a. Sakai3-3D):

This UI technology is taking advantage of the latest 3D JavaScript library called JS-Goggles-3D. As with everything 3D, you need 3D glasses to really appreciate the application.

If you are interested in becoming an alpha tester, please contact me at:

sloof@lirpa.org

Thank you very much for your time and interest.

Best,

Thomas Amsler

Thank you Google for your "Google Fiber For Communities" experiment.

2010-03-13T13:53:00.000-08:00

It's always amazing to see how community members from all different types of backgrounds come together, and work toward a common goal. In this case, to get affordable Internet access at unprecedented speeds, 1gbps. So many communities and cities around the United States have organized themselves to pitch to Google their "Google Fiber For Communities" readiness. I haven't seen so much entusiasm and energy evolving around such a project in a very long time.

I am part of the West Sacramento's community effort, that shows Google that this progressive City is the right choice for launching their Google Fiber experiment. After March 26, 2010, when the nomination process closes, I hope that all of this positive work and progress doesn't just come to a halt. I think that the Google Fiber project is more than just picking one fortunate city/community, where they will make affordable high speed Internat access available. This project is also about communities coming together, and to foster the right environment where new ideas are born and applications are created.

We should leverage this great momentum and try to organize a nation wide community effort, that strives for the same goal, to get affordable high speed Internet access. Equally important, we should collect and share all of our great new ideas and applications. As a nation wide community, we have all the knowledge and resources to work on these great ideas and applications together.

If anybody is interested in pursuing this, please let me know. I have created a Google group where we could start to collaborate:

http://groups.google.com/group/google-fiber-momentum

Twitter hash tag: #googlefm

iPhone : Sending Current Location Via MMS

2009-09-26T11:29:00.001-07:00

Here are the steps for sending your current location via MMS on an iPhone:

Open Maps application
Press the bulls-eye button at the lower left
Once it shows your location, click on the blue dot
A simple Current Location menu pops up
Click on the right pointing arrow which will open the Info screen
Click on the bottom center button called "Share Location"
From the "Share Location Using:" menu, select MMS
This will take you to the messaging client and automatically past your location/contact

Google Visualization API : Implementing a Data Source in Sakai

2009-09-24T15:48:00.000-07:00

This is a tutorial that shows how to create a Data Source in Sakai.

Environment: Sakai v2.5.x, Java 1.5

To install the Data Source Java Library, please follow these instructions:
http://code.google.com/apis/visualization/documentation/dev/dsl_install.html
NOTE:
- This library requires commons-lang v2.4, sakai_2-5-x uses v2.1
- This library was built using Java v1.6, sakai_2-5-x depends on v1.5

I used the following maven dependency to get the library:

 <dependency> 
  <groupId>com.google.visualization</groupId> 
  <artifactId>visualization-datasource</artifactId> 
  <version>1.0.2</version> 
</dependency>

You can build the library under Java v1.5. Here is some information about this:
http://groups.google.com/group/google-visualization-api/browse_thread/thread/7f4d2abb9d9d73c7

When you build the library under Java v1.5, use maven "mvn clean install". This will place the library into the maven repository.

Now we are ready to code:

First, create a data source controller:

 package org.sakaiproject.gradebook.gwt.server;  
   
 import javax.servlet.http.HttpServletRequest;  
 import javax.servlet.http.HttpServletResponse;  
 import org.springframework.web.servlet.ModelAndView;  
 import org.springframework.web.servlet.mvc.AbstractController;  
 import com.google.visualization.datasource.DataSourceHelper;  
 import com.google.visualization.datasource.DataTableGenerator;  
   
 public class DataSourceController extends AbstractController {  
   
      private DataTableGenerator generator;   
        
      //@Override  
      protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {  
             
           DataSourceHelper.executeDataSourceServletFlow(request, response, generator, false);  
           return null;   
      }  
        
      // Spring Injection:  
      public void setGenerator(DataTableGenerator generator) {  
           this.generator = generator;  
      }  
 }

Then, we create the data table generator:

 package org.sakaiproject.gradebook.gwt.sakai;  
   
 import java.util.ArrayList;  
   
 import javax.servlet.http.HttpServletRequest;  
   
 import com.google.visualization.datasource.Capabilities;  
 import com.google.visualization.datasource.DataTableGenerator;  
 import com.google.visualization.datasource.base.DataSourceException;  
 import com.google.visualization.datasource.base.TypeMismatchException;  
 import com.google.visualization.datasource.datatable.ColumnDescription;  
 import com.google.visualization.datasource.datatable.DataTable;  
 import com.google.visualization.datasource.datatable.value.ValueType;  
 import com.google.visualization.datasource.query.Query;  
 
 // Sample code from: http://code.google.com/apis/visualization/documentation/dev/dsl_get_started.html
 public class StatsDataTableGenerator implements DataTableGenerator {  
   
      public DataTable generateDataTable(Query query, HttpServletRequest requst) throws DataSourceException {  
   
           DataTable data = new DataTable();  
           ArrayList<ColumnDescription> cd = new ArrayList<ColumnDescription>();  
           cd.add(new ColumnDescription("name", ValueType.TEXT, "Animal name"));  
           cd.add(new ColumnDescription("link", ValueType.TEXT, "Link to wikipedia"));  
           cd.add(new ColumnDescription("population", ValueType.NUMBER, "Population size"));  
           cd.add(new ColumnDescription("vegeterian", ValueType.BOOLEAN, "Vegetarian?"));  
   
           data.addColumns(cd);  
   
           // Fill the data table.  
           try {  
                data.addRowFromValues("Aye-aye", "http://en.wikipedia.org/wiki/Aye-aye", 100, true);  
                data.addRowFromValues("Sloth", "http://en.wikipedia.org/wiki/Sloth", 300, true);  
                data.addRowFromValues("Leopard", "http://en.wikipedia.org/wiki/Leopard", 50, false);  
                data.addRowFromValues("Tiger", "http://en.wikipedia.org/wiki/Tiger", 80, false);  
           } catch (TypeMismatchException e) {  
                System.out.println("Invalid type!");  
           }  
           return data;  
      }  
        
      public Capabilities getCapabilities() {  
           return Capabilities.NONE;  
      }  
 }

The remaining part is the spring configuration. First we add the spring beans:

 <bean id="org.sakaiproject.gradebook.gwt.server.DataSourceController" class="org.sakaiproject.gradebook.gwt.server.DataSourceController">  
   <property name="generator"><ref bean="org.sakaiproject.gradebook.gwt.sakai.StatsDataTableGenerator"/></property>  
 </bean>  
   
 <bean id="org.sakaiproject.gradebook.gwt.sakai.StatsDataTableGenerator" class="org.sakaiproject.gradebook.gwt.sakai.StatsDataTableGenerator">  
 </bean>

Next, we add the data source controller reference to the SimpleUrlHandlerMapping. The file name needs to match the servlet reference in web.xml. In our case, the file is called sakai.gradebook.gwt.rpc-servlet.xml:

 <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">  
   <property name="mappings">  
     <map>  
       <entry key="/**/DataSource" value-ref="org.sakaiproject.gradebook.gwt.server.DataSourceController" />  
     </map>  
   </property>  
 </bean>

In the web.xml, make sure that you add the "DispatcherServlet":

 <servlet>  
   <servlet-name>sakai.gradebook.gwt.rpc</servlet-name>  
   <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
   <load-on-startup>1</load-on-startup>  
 </servlet>  
        
 <servlet-mapping>  
   <servlet-name>sakai.gradebook.gwt.rpc</servlet-name>  
   <url-pattern>/*</url-pattern>  
 </servlet-mapping>

That's pretty much it. To access it, browse to:

 http://localhost:8080/some-name/DataSource

This will return the the defined data table's data in JSON. You can get an HTML representation by entering:

 http://localhost:8080/some-name/DataSource?tqx=out:html

... as well as using the built in query support:

 http://localhost:8080/some-name/DataSource?tqx=out:html&tq=select link,name

... etc.

There is an excellent Google I/O session about this:
http://code.google.com/events/io/sessions/ImplementingOwnVisualizationDatasource.html

Sources:
Google Visualization API (Data Source): http://code.google.com/apis/visualization
/documentation/dev/implementing_data_source_overview.htm
Google API Libraries for GWT Visualization: http://code.google.com/docreader/#p=gwt-google-apis&s=gwt-google-apis&t=Visualization

HTML5 Geo Location : GWT : iPhone

2009-06-21T15:27:00.000-07:00

Since Apple has released the new iPhone 3.0 OS, I have been experimenting with its browser's HTML 5 Geo Location support. I am especially interested in getting this to work in a Google Web Toolkit (GWT) application hosted on Google App Engine (GAE). The following is some sample code that gets the Geo Location from the browser and makes that data available in a GWT application.

Step 1:
Using GWT's JavaScript Native Interface (JSNI), I wrapped the W3 GEO API calls.

private native void getGeoLocation() /*-{

 if(null == $wnd.navigator.geolocation) {
   return;
 }

$wnd.navigator.geolocation.getCurrentPosition(
 @org.thomasamsler.glm.client.Glm::geoLocationCallback(Lorg/thomasamsler/glm/client/Position;),
 @org.thomasamsler.glm.client.Glm::geoLocationCallbackError(Lcom/google/gwt/core/client/JavaScriptObject;),
 {enableHighAccuracy:true, maximumAge:60000});
}-*/;

Step 2:
The first argument to the getCurrentPosition(...) method is a Java onSuccess callback method:

public static void geoLocationCallback(Position position) {
   consoleFlowPanel.add(new HTML(position.getLatitude() + " : " + position.getLongitude()));
   // ...
}

The "Position" object is a GWT JavaScript overlay type:

public final class Position extends JavaScriptObject {

    protected Position() { }

    public native double getLatitude()/*-{
        return this.coords.latitude;
      }-*/;
    
    public native double getLongitude()/*-{
        return this.coords.longitude;
      }-*/;
}

Step 3: The second argument to the getCurrentPosition(...) method is a Java onError callback method:

public static void geoLocationCallbackError(JavaScriptObject jso) {
 // ...
}

Step 4: The third argument to the getCurrentPosition(...) method are the W3 position options:

interface PositionOptions {
    attribute boolean enableHighAccuracy;
    attribute long timeout;
    attribute long maximumAge;
  };

That's all that's needed. I hope that this will be part of a little GWT-Geo-Location library. In general, the above code works pretty well.

One issue that I have seen so far is the GPS coordinates accuracy. The GPS location that the browsers passes on is not very accurate, meaning that the acquired location deviates from the actual location by as much as ~3miles. I am not quite sure why it doesn't have the same accuracy as native iPhone applications that access the location API. So far, I have experimented with the various Position Options but all the different combinations and setting didn't improve the acquired GPS coordinates.

Sources:
HTML 5 Geo Location: http://dev.w3.org/geo/api/spec-source.html
GWT: http://code.google.com/webtoolkit/
GWT JSNI: http://tinyurl.com/gwtjsni
GAE: http://code.google.com/appengine/

Sakai Tool : Flashlight

2009-04-01T09:30:00.000-07:00

After countless hours of development, I am proud to announce the release of the brand new Sakai tool called Flashlight (code name #FFFFFF). This very unique tool will light up a user's working environment and will help her/him to stay productive even during late hours.

I already started on an improved version called Flashlight2 (code name #XXXXXX), which will let you choose different ambient light sources.

patching with git diff

2009-02-03T23:22:00.000-08:00

If you want to create a patch file via "git diff" that can be applied using "patch -p0 < patchfile" use the following command:

git diff --no-prefix > patchfile

then apply the patch:
patch -p0 < patchfile

If you have an existing "git diff" patch file that was created without the "--no-prefix" option, you can apply that patch via:

patch -p1 < patchfile

this will ignore the default a/ b/ source prefixes.

JSR-311 : Taking Jersey for a test drive

2009-01-28T21:58:00.000-08:00

I am adding REST support to our UCD Sakai gradebook2, by using the JSR-311 reference implementation Jersey. The JAX-RS (JSR-311) annotations are very easy to work with.
So far, I ran into on issue. Jersey's JSON support depends on Jettison v1.0.1, which in conjunction with Jersey v1.0.1 produces JSON of the following format:

{
 "gradeScaleRecord": [
   {
     "letterGrade": "A+",
     "fromRange": "97",
     "toRange": "100"
   },
...

The problem is that numbers are surrounded double quotes. The JSON standard output should be:

{
 "gradeScaleRecord": [
   {
     "letterGrade": "A+",
     "fromRange": 97,
     "toRange": 100
   },
...

The good news is that the current behaviour can be customized via a "javax.ws.rs.ext.ContextResolver":

package org.sakaiproject.gradebook.gwt.sakai.rest.config;

// imports ....

@Provider
public final class JAXBContextResolver implements ContextResolver {

private final JAXBContext context;

private final Set types;

private final Class[] cTypes = { GradeScaleRecord.class, GradeScaleRecords.class };

public JAXBContextResolver() throws Exception {

Map props = new HashMap();
props.put(JSONJAXBContext.JSON_NOTATION, JSONJAXBContext.JSONNotation.MAPPED);
props.put(JSONJAXBContext.JSON_ROOT_UNWRAPPING, Boolean.TRUE);
props.put(JSONJAXBContext.JSON_NON_STRINGS, new HashSet(2) {

{
add("fromRange");
add("toRange");
}
});
this.types = new HashSet(Arrays.asList(cTypes));
this.context = new JSONJAXBContext(cTypes, props);
}

public JAXBContext getContext(Class objectType) {

return (types.contains(objectType)) ? context : null;
}
}

Jersey finds this class by placing the JAXBContextResolver's package name in the web.xml PackagesResourceConfig defintion:


<servlet>
  <servlet-name>Jersey Web Application</servlet-name>
  <servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
  <init-param>
    <param-name>com.sun.jersey.config.property.packages</param-name>
    <param-value>org.sakaiproject.gradebook.gwt.sakai.rest;org.sakaiproject.gradebook.gwt.sakai.rest.config</param-value>
  </init-param>
</servlet>

This is also covered in a Jersey issue 197:
https://jersey.dev.java.net/issues/show_bug.cgi?id=197

Firefox plugin that pretty-prints and colorizes JSON

2009-01-24T21:06:00.000-08:00

If you are doing REST development, that produces "application/json" you may want to try out the JSONovich Firefox extension:

https://addons.mozilla.org/en-US/firefox/addon/10122
http://lackoftalent.org/michael/blog/json-in-firefox/

JSR 311 : API for RESTful Web Services : continued ...

2009-01-21T21:04:00.000-08:00

Now, there is a third REST framework that implements JSR 311 (JAX-RS). Today, RESTEasy reached version 1.0.0GA.

http://www.jboss.org/resteasy/

JSR 311 : API for RESTful Web Services

2009-01-20T15:59:00.000-08:00

In the Sakai community, there is a lot of activity going on around RESTful support using EntityBroker and or SData. This effort takes palce in both the current Sakai 2 as well as the K2 envioronment. EB and SData may be a good fit, but we may also want to look at emerging and existing APIs and frameworks that implemnt JRS 311, JAX-RS.

While I continue to experiment with REST based frameworks and APIs, a colleague of mine brought Sun's JSR 311 reference implementation called Jersey to my attention:
https://jersey.dev.java.net/

Here is a great overview of using Jersay:
http://wikis.sun.com/display/Jersey/Overview+of+JAX-RS+1.0+Features

Previously, I have written about Restlet. Restlet also has a JRS 311 extension. Here is an articel that explores this feature:
http://www.javaworld.com/javaworld/jw-12-2008/jw-12-rest-series-2.html?page=1

Exploring REST using Restlet

2009-01-03T16:11:00.000-08:00

If you want to experiment with the REST architectural style in Java, I recommend that you have a look at Restlet:

http://www.restlet.org/

This lightweight REST "framework" is quite easy to understand lets you build RESTful web applications with ease.

The tutorials located on the Restlet web site are quite basic. I found this example:

http://www.2048bits.com/2008/06/creating-simple-web-service-with.html

... which actually demonstrates how to do CRUD operations using Restlet and JSON.

gitweb allowing to view explicitly exported repositories

2008-12-31T15:11:00.000-08:00

If you want to configure gitweb to view only selected repositories, you can do so by configuring the $export_ok variable in the "/etc/gitweb.conf" file.

You have to define the "$export_ok" variable, by assigning it some file name.

e.g.
$export_ok = "gitweb-export-ok"

Then, you have to touch a file in the repositorie's "repository/.git/" directory:

e.g.

touch /opt/repositories/sakai/authz.git/.git/gitweb-export-ok

That's it. Now, gitweb will only list repositories that have the "gitweb-export-ok" file in the ".git" directory.

The gitweb documentation is located here:

http://git.or.cz/gitwiki/Gitweb

Using JavaRebel During GWT Development in Eclilpse

2008-12-27T14:53:00.000-08:00

A couple of weeks ago, I read about JavaRebel for the first time:

http://www.zeroturnaround.com/javarebel/

Now, I had some time to experiment with it. Currently, I am working on the UCD Sakai gradebook, which uses Google's GWT. Developing in GWT is great and fast. One area that could use some speedup with respect to JavaRebel's capabilities is working in GWT hosted mode, and making server side code changes. Such a change requires that you restart the GWT hosted mode runtime in order for the changes to take effect.

I watch the JavaRebel IDE support video:
http://www.zeroturnaround.com/blog/javarebel-boosting-eclipse-plugin-development/

... which shows how easy it is to configure eclipse to enable JavaReble. Details are listed here as well:
http://www.zeroturnaround.com/javarebel/installation/#configuration

All you have to do is to edit your Eclipse runtime configuraiton by adding the following jvm args:

java -noverify -javaagent:javarebel.jar

... which in my case are:

-noverify -javaagent:/Users/thomas/lib/javarebel.jar -XstartOnFirstThread -Xmx768M

That's it. Now, I am able to make server side code changes and it all just works. Whenever, JavaReble detects modified classes, it prints information to the Eclipse console such as:

JavaRebel: Reloading class 'org.sakaiproject.gradebook.gwt.sakai.DelegateFacadeImpl'

This should work equally well within the normal Sakai development environment using tomcat, which I will try to do next...

--Thomas

The Eclipse executable launcher was unable to locate its companion shared library

2008-10-05T21:33:00.000-07:00

After doing a routine eclipse upgrade, v3.4, via the automatic upgrade
agent, eclipse wouldn't start anymore. I got the following error
message:

The Eclipse executable launcher was unable to locate its companion
shared library.

Some folks just reinstall eclipse but if you don't want to go
through the trouble of installing all of your needed plugins, here is
a quick way to fix this:

If you launch Eclipse via the shell, you get the following error message:

localhost : eclipse/Eclipse.app/Contents/MacOS/eclipse

dlopen(../../../plugins/org.eclipse.equinox.launcher.carbon.macosx_1.0.100.v20080509-1800,
2): image not found

I just copied over the old version of the plugin and that seemed to work:

cp -R plugins/org.eclipse.equinox.launcher.carbon.macosx_1.0.101.R34x_v20080731
plugins/org.eclipse.equinox.launcher.carbon.macosx_1.0.100.v20080509-1800

The startup takes a bit longer than usual. This happened on Mac OS X,
and I am not sure if other platforms are affected as well.

Cluster Service Using MessageService (JMS)

2008-01-31T23:14:00.000-08:00

I have moved the cluster service sakai_2-4-x branch that uses the new MessageService from my personal repository into my new Sakai contrib subversion space.
https://source.sakaiproject.org/contrib/tamsler/cluster/branches/sakai_2-4-x/

Sakai Cluster Service using MessageService

2008-01-22T09:31:00.000-08:00

Over the weekend, I have been working on the Sakai cluster service so that it uses the MessageService instead the DB in cases where it makes sense. Things are shaping up pretty good. Most parts are working but I am still trying to figure out some ActiveMQ v5.0.0 bugs. ...

Sakai Message Service

2008-01-10T20:48:00.000-08:00

I finally got around to work on the Sakai MessageService again. At the end of 2007, I converted Aaron's initial work into a pure MessageService. The API is simple. It allows you to get a Connection from the JMS ConnectionFactory. The Sakai MessageService uses ActiveMQ, which is a well known JMS implementation.

Currently, the MessageService source code is located in contrib:
https://source.sakaiproject.org/contrib/messageservice

... we will use the following confluence page to document this project:
http://confluence.sakaiproject.org/confluence/x/PoGi