“The time has come…to talk of many [technologies].” –Lewis Carroll(‘The Walrus and the Carpenter’)
Web
Host Your Projects On Internet Using Google Project Hosting
2After a long time, Google has come up with a (yet another ‘free’ and ‘beta’!) service that interests me very much. I have no use for an online spreadsheet or a photo album application, though Google Notebook was a useful addition. Now comes the impressive free project hosting service for the open source software projects, which adds to many other good free hosting services available, like Sourceforge.net, Tigris.org, Savannah.org etc. The main highlights of Google’s hosting service are: the ease of use/administration(no lengthy forms to be filled, no waiting for the approval etc), source control with customised version of Subversion software and project search functionality. On the face of it, it looks like a service seriously lacking in terms of features, but that is one of the main reasons that makes it stand out from the other project hosting services, in my opinion.
Many a times, all I had wanted was a source control repository(CVS or Subversion) to host my projects and easy management of which users have the write access to it. The free service provided by cvsdude.com looked to fit the bill well for me initially, but the 2MB limit on the free plan turned out to be very restrictive very soon. Their paid service is too costly for someone needing ‘just a place on the internet to store/share the project files.’ In this context, Google’s free Subversion service(with [expandable] 100MB storage limit) is like an ideal fit for my requirements.
Creating and administering a project is a total breeze with the Google’s new hosting service. Go to the home page of the service, click the ‘Create a new project’ link, fill out the most essential information about the project(project name, small description, long description, license) and you are done. You can start hosting your project right away, no approvals from Google are needed.
Do remember to note the project name and the url that is created for the project; you will need it to access the project in the future, as no link to the owned projects is present on the google account’s home page once you login into the hosting service. Once the project is created, you need a suitable Subversion client(as needed in almost all the other similar services) to upload the project to the subversion repository. A list of such desktop Subversion clients is available at Tigris website. Once the project files are uploaded to the Subversion repository, others can download them by checking a copy out using a subversion client(instructions available on the project web page) or browse the source code from with in the browser(the interface to view the source code from the browser is not as good as in Sourceforge(ViewCVS), but it gets the job done.
What is lacking in Google’s service, though, is a way to download the project files by the general users. Only the instructions on how to check out the project files anonymously from the Subversion repository are included and the project owners will have to host a tarred or zipped release version of their software at some other server and provide a link to it from the project page(custom links can be added from the administration page).
If you want to put any other information related to the project, say some documentation etc(apart from the basic description entered during the project creation), you need to put that elsewhere too(Google may suggest Google Base or Google Pages for this). A link from where to download the binaries/source of the latest release, a little bit of documentation should be good candidates to be added to such a project specific page. It will be highly desirable to have such a web page integrated with the hosting service itself.
The trend of categorising the resources using tags can be seen in all sort of applications these days, Drupal and MoveableType being two examples. Instead of categorising the hosted projects under only one category(or a few), the project owners can assign a few descriptive tags to their projects with the Google’s hosting service. This will be helpful in searching a project from all the hosted projects. Google calls these tags ‘Labels’ and there is not limit to the number of tags that can be applied to a project. A utility that allows cricket scores to be displayed on a mobile phone developed using J2ME, for example, can be tagged with ‘cricket’, ‘mobile’, ‘J2ME’ labels. I wonder how effective the project search functionality will be if some of the administrators chose to use every possible label that there is to describe the type of their projects.
Members can be added to the project by the project owner from the administration page. They need a google account to be a part of the project.
The only other major feature in Google’s project hosting service(apart from subversion repository) is Issue Tracking. Anyone can submit an issue to a project and the owner can configure what kind of issues are supported by the project.
While developers seeking a feature-rich project hosting platform might be unimpressed with the watered-down hosting service provided by Google and may continue to find comfort at places like sourceforge.net and tigris.org, for a large section of open source developers, the features like free source control repository and ease of adminstration should prove to be sufficient. It would be interesting to see what new features Google will come up with for their project hosting service(if they were to ask me, I would vote for service-wide search functionality for the source code) in the near future.
Create ASP.NET 1.0 & 2.0 Applications On GNU/Linux and Windows Using Mono XSP
6This post assumes that Mono is installed on your system. The following links should help if it is not installed.
Installing Mono on Gentoo and Ubuntu 5.10
Installing Mono and XSP on Ubuntu 6.06
Installing Mono and XSP on Fedora
Installing Mono XSP on Gentoo
#emerge xsp xsp2
Installing Mono XSP on Debian/(K)Ubuntu
#sudo apt-get install xsp xsp2
Installing Complete Mono Environment(Mono, GTK#, XSP) on MS Windows
- Download the Mono installation file for MS Windows from the Mono website.
- Run the installer and follow the installation wizard.
Go to the Mono menu in the Start menu(Start->All Programs->Mono[version]) to access all the applications installed as part of Mono.
Your First ASP.NET 1.0 Application Using Mono XSP
- First create a directory to store the ASP.NET files and change to that directory. You can create the directory in your home directory.
sh# mkdir aspnet && cd aspnet
- Create a sample ASP.NET page. Copy and paste the following code in two separate files(hello.aspx and hello.aspx.cs).
hello.aspx
[html]
<%@ Page language="c#" src="hello.aspx.cs"
Inherits="HelloApp.HelloPage" AutoEventWireup="true" %>
Welcome to my page!
[/html]hello.aspx.cs
[csharp]
using System;
using System.Web.UI.WebControls;namespace HelloApp
{
public class HelloPage : System.Web.UI.Page
{
protected Label message;
protected Button greet;
protected TextBox name;public void OnGreetClick(Object sender, EventArgs e)
{
message.Text = “Hello, ” + name.Text;
}
}
}
[/csharp] - From the same directory(‘aspnet’), start the XSP server:
sh# xsp
(you can press ENTER to terminate the XSP server process)
- Open a web browser, type the url http://localhost:8080/hello.aspx and press ENTER. You should see a web page with a text box and a message. Enter a name in the text box and click the “Greet” button to see the personalised greeting displayed.
On MS Windows, go to the Mono menu in the Start menu(Start->All Programs->Mono[version]), select “Mono[version] Command Prompt” menu item. Create a directory(say ‘c:\programs\aspnet’), change to that directory and copy the above two files in that directory. From the same directory, run ‘xsp’ commad to start the XSP webserver. Open a web browser and access the url http://localhost:8080/hello.aspx.
Your First ASP.NET 2.0 Application Using Mono XSP
To develop ASP.NET 2.0 applications using Mono XSP server, start ‘xsp2′ webserver instead of ‘xsp’. Create a test ASP.NET 2.0 page(say ‘hello2.aspx’) and copy it in a folder. Run the following command from the same folder:
sh# xsp2
Go to http://localhost:8080/hello2.aspx to test the ASP.NET 2.0 page.
Why I Switched to Google’s GMail Hosted Domain Service
5When I got the invitation to test the beta version of Google’s GMail Hosted Domain Service(HDS), I couldn’t make an immediate decision whether I should switch to it or not. Agreed I should have made such a decision before requesting for an invite from Google but initially I was of the thinking that I can manually control where the MX records for my domain point to, so it will be an easy switch between Google and my hosting provider’s service. I checked it out when I actually got the invitation from Google and found to my utter surprise that customers are given direct access only to some of the DNS records and MX records are not one of them. Going through a quick comparision between the services provided by my hosting provider and by Google, I finally decided to go with Google. Here are the reasons why.
There is no doubt that Google Mail provides a fast and easy to use interface which in my opinion is better than any other email interface available today. [Converstation Stacks + Labels + Filters] has become an essential feature set for my day-to-day email management activities and I could now hope to get the same interface for my domain email accounts too. One thing that I was sorely missing from my hosting provider’s email services is the mailing lists: they didn’t support mailing lists at all(which would have overloaded their servers in their opinion). Google’s HDS makes creation of mailing lists easier than creating a google group. This feature infact was what finally prompted me to switch to Google. One drawback of this feature in its current form is that all the members of such a mailing list must have their email accounts at my domain – I can’t add someone with a usual GMail or Yahoo account. This forces me to maintain two different mailing lists – one at my domain for those who have email accounts at my domain and a Google Group for the rest.
When I first learnt about Google’s HDS, I was under the impression that it doesn’t support a ‘Catch-all’ address that will catch all the emails that are sent to non-existent email account ids under my domain name. I guess this was the case when the service was initially launched but now a ‘Catch-all’ email account can be easily created. Some people also reported that HDS is curiously hosted on Google servers and not on GMail servers, hence there may be considerable downtime on these servers when it gets started to be used on a larger scale. Don’t ask me to explain the logic behind this claim, its not mine.
Google Calendar, Google Chat and data storage space independent of the hosting provider were the other reasons why I switched to Google’s service. Below are some screenshots of Google’s HDS:
Login page looks similar to GMail’s login page:
Administration Interface for Google Hosted Domain Email Service
The service cannot be used until you point your MX records to Google’s servers.
MX Records should point to these Google Servers
The Inbox looks the same as that of GMail’s interface.
Movable Type 3.3 Beta To Be Released On May 31
1Its close to one year now since the 3.2 version of the Movable Type blog publishing software was released last year. Jay Allen, Product Manager at Six Apart, has announced yesterday that the first beta of the next version of the software, Movable Type 3.3, will be released on May 31.
Good news: We’ve got a new version of Movable Type on the way, and we wanted to let you know that the beta is coming soon. We plan to start the Movable Type 3.3 beta test on Wednesday, May 31.
The highlight this time around about the beta development stage is that a separate blog will be serving as a common place for everyone to keep informed(and get technical support) about the latest developments with the beta product. There is also a tight 3-week deadline for beta testing this time, informs Jay Allen. So whoever is a Movable Type fan and would like to get their hands dirty by test driving its multiple beta versions that would be released in the coming next few weeks, get ready and be prepared for the D-day.
You can read the announcement here:
Coming soon: Movable Type 3.3 (beta)
Update: More details about the new features of the Beta version to be released are here: What’s new in Movable Type 3.3?
Should I Be Developing Ajax Applications using Google Web Toolkit(GWT)?
0So why should an Ajax developer be interested in the recently released Google Web Toolkit(GWT)? One possible reason could be to overcome the shortcomings of the typical Ajax web development model as noted in my earlier post. Firstly, a framework always provides a head start to a project, allowing the developers to worry only about writing the application logic; user interface elements, the plumbing work needed for the communication between the client and the server are provided by the framework itself. The more specific benefits of using the Google Web Toolkit are:
- The developer is relieved from the thankless job of understanding every single way in which the browsers differ from one another in handling the same web page, allowing them to create websites such that all these web browsers handle a page in (roughly) the same way.
- GWT allows the developers to interact with the browser’s history stack which means that the Ajax applications created using GWT can allow the users to use the ‘Back’ and ‘Forward’ buttons of the web browser and to bookmark the various pages of the website.
Refer to points 2 & 3 in my earlier post.
- Developers can use a more modular and statically typed programming language in Java to create the interface and other components instead of hacking their way out with Javascript. Ultimately, its still the JavaScript code that is generated and served to the web browser, but GWT provides an abstraction layer that shields the developers from having to do much with the JavaScript language. The flip side of this is that for pure interface code, Javascript might offer a more natural solution than Java language when it comes to creating web pages; see the discussion below.
Refer to point 1 in my earlier post.
Being able to use Java to create Ajax applications also means better integration with the rest of the Java web development technologies like JSP, JSF, etc(note that code written using GWT uses the Java Web UI class library which is not related to any of the Java standard libraries and this code is statically translated to Javascript and HTML code before making available to the server. Integration would be limited to sharing something like a Java component between a JSP page and the code written using GWT). This may not appeal to those who are using other server-side technologies like PHP and ASP.NET.
Java language also boasts of better programmer IDEs and tools with good support for Unit Testing and Refactoring. In fact, GWT itself has good JUnit integration through easy to use class libraries in the package com.google.gwt.junit.
Javascript code can still be embedded within the Java code if only the services of the Javascript language are going to solve a particular problem, by using the Javascript Native Interface(JSNI)(on the lines of JNI). See this for more information.
- The biggest advantage of using GWT for creating Ajax applications is the relative ease with which the data can be communicated between the server and the client by just creating serializable Java objects.
- Good support for debugging. Eclipse IDE and GWT host mode form a good combination for convenient debugging of the GWT applications.
Having said all this, I am not a big fan of static translation of one programming language to the other. If it were as unified as in ASP.NET(see ASP.NET WebParts; all the translation happens at run-time), I would have welcomed it whole-heartedly. But different programming languages are created to solve different problems, and they are optimized to that specific job. I hate Javascript language for many reasons(as I do in case of Java) but still believe that Javascript is better oriented towards creating client-side code for the web browsers than Java language is(when the intention is to create a web interface). Are we going to use Java idioms here or are we going to try to imitate the Javascript idioms in the Java code? How many Java libraries are supported by the GWT SDK tools? What about the unsupported libraries whose functionality is needed for the application?
Secondly, the entire translation process is lengthy and inefficient: create an empty GWT application using the GWT SDK, fire up your favourite Java editor(eg: Eclipse) and create the Java source files in it, translate these Java files to Javascript + HTML files and finally integrate them with the rest of the server-side code(PHP, JSP etc). But there are advantages we get out of this investment as noted in the above mentioned points.
Not all the standard Java libraries are supported by GWT. For example, only java.lang and a part of java.util are supported by the GWT tools, which means the code written using Java libraries not supported by GWT cannot be translated by the GWT tools. The developer needs to make a call whether to achieve the desired functionality by writing custom Java code or by writing the code in Javascript.(I would be tempted to go the second way as that would allow me to use the same code in other applications that don’t make use of GWT).
By the way, why don’t we have the access to the GWT source code? Isn’t Google a big supporter of the Free Software community?
For developer centric GWT related discussion, go to the GWT Support Forums.
Related Post: A Case Against Ajax Web Development Model
Recent Comments