Tuesday, December 15, 2009

The year so far

The year that was 2009 for me has once again proved to be with ups and downs. Many of my dreams were fulfilled, but many more remain an unfinished business.
In studies, I am currently doing my masters in Computer Applications and needless to say, this year, I etched towards the goal of getting a full fledged degree in computers. In my actual software development world, I've started working upon my career as a freelance software developer and have started contributing in Open Source World in many ways (both as a developer and a helper as well as in promoting its philosophy).
Due to paucity of time, I am unsatisfied, and at times, frustrated with myself with the inability to learn technical stuff (its a big world out here and there is so much to learn). As 2009 eases into the pages of history, this time I wouldn't make any new year resolutions as the last year ones were never fulfilled(I am always cribbing about breaking such stuff).
As I write this, I am having my internal examinations this week and time is of essence, so I'll have to cut this crap shortly. Just after writing this, I am reflecting upon myself, what is going to happen in future, when I'll be having even lesser time for myself that currently is in my disposal ?
Wasted about 15 minutes on this rant ... stopping right NoW.

Friday, October 9, 2009

Learning Ruby has always been refreshingly easy.
But thanks to ruby koans, this has been made more easier.
See :
Recommended for intermediate Rubists (people like me, who adore this gem of a language!), this is a fun filled and agile way of learning ruby concepts via unit testing.
Just unpack the distribution and view the README.rdoc file for more information.

Here, simply pass the unit tests and you will gain 'enlightment' as you move along. It's just like a textbook in action, or rather, an activity based learning. Currently I am playing it as a game and hopefully I'll finish it

example of my ruby koans

sumit@darkstar004:~/Desktop/edgecase-ruby_koans$ rake
(in /home/sumit/Desktop/edgecase-ruby_koans)
/usr/bin/ruby1.8 path_to_enlightenment.rb
/usr/lib/ruby/1.8/rake.rb:905: warning: Insecure world writable dir /home/sumit/ant/bin in PATH, mode 040777

Thinking AboutAsserts
test_assert_truth has expanded your awareness.
test_assert_with_message has expanded your awareness.
test_assert_equality has expanded your awareness.
test_a_better_way_of_asserting_equality has expanded your awareness.
test_fill_in_values has expanded your awareness.

Thinking AboutNil
test_nil_is_an_object has expanded your awareness.

test_calling_methods_in_other_objects_require_explicit_receiver has expanded your awareness.
test_calling_private_methods_in_other_objects has expanded your awareness.

Thinking AboutControlStatements
test_if_then_else_statements has damaged your karma.

You have not yet reached enlightenment ...
<"FILL ME IN"> expected but was

Please meditate on the following code:
./about_control_statements.rb:19:in `test_if_then_else_statements'

learn the rules so you know how to break them properly

Note: the stack trace of my passed tests would increase, but then, who is complaining?
Just at the last line, is a random quote, which adds to the mystry factor of the whole setup.
For more info. about this, do write in here !

adiĆ³s for now

Sunday, September 27, 2009

Born out of Boredom

Phew! What a day it was. First of all, it started off by giving my maths exam in college. It was regarding Optimization Techniques, a subject that I currently hate the most. Afterwards, me and my classmates spent more than a hour canvassing our juniors about our upcoming technical event (hope this does'nt goes in vain).
Currently, I am studing javafx, the newer approach for building GUIs in java platform. As mentioned in my earlier posts, i was initially skeptical about this technology. However, just by going through the first chapter of the Apress Pro javafx 1.2 platform, much of my fears have been allayed. Like other pro series, this book does'nt disappoints and covers nearly the entire breadth of the topic and tops off with two examples(rather intriguring, i'd say). I was also worried about the fast pace of this bleeding edge technology, but as release cycles are slow (6months to one year), it is quite an assurance for me. To start off with, I'll be doing GUI programming in java after nearly a three year hiatus because arcane topics like AWT are to be covered in my course this semester, so javafx ought to be refereshing for me. Also, my experience with GUI has never been exactly a satisfying one.
Me, the newbie in javafx, is currently playing around with this yet-another-scripting-language for the jvm and i'd say that its nicely done (expecially the intrgration with Netbeans).
More about this stuff later.

Friday, September 25, 2009

Ebooks for you

I generally get innundated with request from my friends for e-books as you can quickly consult 4-5 books on a given topic as well as save paper.

The files come in two formats: CHM and PDF.

CHM files are basically bundled HTML files and can be extracted to plain HTML.


PDF files are best viewed in Foxit Reader

Surfing today, I came upon this nice website http://www.flazx.com
that hosts a variety of such ebooks.

My request to all subsequent users, please do purchase the original print version, if you find the book useful as it then helps both you and the publisher (and subsequently, the author).

Monday, September 7, 2009

Getting Started With Rails 2

Getting started with Rails 2.0 -A truly Agile Web Development
Rails is a web application framework that enables us to create dynamic, functional and architecturally  well designed websites with ease.

Getting Started:
In Ubuntu Linux, simply type:-
sudo apt-get install rails
Now accept the non standard packages (if there is a warning)

To create a rails application, simply go to the appropriate base folder and type
rails "Application Name"
This would generate all the basic files/folders needed for our application.Note that in Rails 2.0, we need to specify the database of our choice as the default database id sqllite3.To use any other database like MySql, we need to type
rails -D mysql "Application Name"
Make sure that you have the appropriate database application installed at this step. Now look at the database configuration at "Application Directory"/config/database.yml file. In my case, this shows the following data :

For now, lets only concentrate on the development section of the file.
Adapter means the library used to interact with rails. If you do not have the appropriate library, and try to use the database, you would face errors.In the database entry, name an appropriate database name(default or your own liking – whichever you prefer). Then specify username and password. Note that in development environment, we generally leave the password as blank (us lazy programmers :) ). In that case, you still need a space after password: . This is because the space acts as a delimiter (alongwith colon) between the name and value pairs in the file. Lastly, the socket refers to the file that mysql is to be connected from rails on the local computer. This is generated automatically, but you may want to change it if you have more than one distribution of mysql on your machine(In my case, this mysql is installed with lampp distribution).Now we need to create our database. For this, simply type :
This will create the development database.Alternatively, you can even create all the databases

Now before you get bored, lets jump into some serious development work. Keeping the agile manifesto in mind, we need to perform our iteration 0. In rails, this can be done by the scaffold utility. Again, be Very sure of the rails distribution that You are using and the Documentation/Book you are consulting as there is a lot of difference between Rails 1.x and 2.x families. In Rails 2.0 simply type the following command inside your application base directory:
ruby script/generate scaffold Movie title:string about:text url:string
This generates a lot of files (Models, Views and of course, Controllers) for the scaffold. Before commencing with anything, however, keep this in mind that a Scaffold is temporary (just like wooden struts that hold the roof of your house while the roof gets constructed) and should not be used for production code.

Note that the Scaffold name is Movie and it contains name:value pairs of data. You can even have a look into the database and we'll see a table created with name as prural form of our scaffold.Inside the table, rails auto generates a primary key as well as columns having creation and updation status of the records (all this without a single piece of sql/programmer intervention).

After doing this, simply start the server by running the following at command line :
ruby script/server start

This is our initial display of the application. Now play around with the data(perform crud operations to feel the power of this framework).
Note that using scaffold is the exception, not the norm while creating Rails application.

A page view of some newly entered data.
We can even perform validation in the form of models i.e. only the model needs to be refactored in order to perform this task. To do this, simply navigate to the /app/models directory in your rails application. Since in this example, I've created Movie as my model, there would be a movie.rb file in the model directory. It has the following code initially:
class Movie < ActiveRecord::Base


Clearly, the Model has class as Movie and it subclasses the Base class from ActiveRecord module. Inside this, simply insert the folowing piece of code (quite self explaining):
validates_presence_of :title,:about,:url
Now restart/refresh the web browser to observe the change. This time, try performing some validation errors to see the difference.

Thus we can observe the ease of use and the agility of the process involved in the development of a rails application.
Rails is a emerging framework, it is something that is 'bleeding edge' . For up to date information, do look for blogs and discussions on the web. In near future (by end of 2009), Merb framework is going to be integrated with Rails to form Rails 3. So be excited till then.
The following books are my prime sources in learning ruby on rails:

Beginning Ruby On Rails (Wrox)-Steven Holzner
Building Dynamic web 2.0 Websites with Ruby On Rails (Packt Publishing)-A.P. Rajshekhar
Agile Web Development with Rails Second edition (ThePragmatic Bookshelf)-Dave Thomas, David Heinemeier Hansson
Simply Rails 2 (SitePoint)-Patrick Lenz

Tuesday, July 28, 2009

Why open source is needed

When it comes to softwares, a typical user thinks about Windows OS, MicroSoft Office as it is, by and large, the de-facto interface for the most people while computing.
However, such softwares' source code(that is the primary information to how these things work) is protected from the users due to proprietary copyrights and self-centered motives, thereby, effectively stopping all of us to give 'shape' to it in order to enhance it further. Basically, all proprietary stuff owned by big companies like Microsoft, Apple, Oracle, and so on is available only after paying them money in addition to being limited by the technical constraints of their products. So people, and developers, that use them are basically dancing to the companies' tunes.

I am not cribbing about these technologies. Sure, I really appreciate the way Windows has shaped up personal computing, Mac OS makes me drool, the list is quite huge. But it is really demeaning to observe that these cos. do a lot of unethical practices to promote their stuff. Interestingly, Microsoft always claim that their Windows is faster, safer, and so on, which is a big piece of lie, and people have seen it again and again with each release of their windows OS that it is not the case. Similarly, Mac has put an Iron Curtain around their Iphone Application development, limiting innovation and at the same time, squeezing out moolah from their customers, who have to pay exorbitant prices for using any application.

While it is initially skeptical from the perspective of a non-technical person to use a seemingly 'Free' technology due to its hacked-assembled manner as well as the complexity involved in its use, the landscape is fast changing. We are seeing user-friendly Linux distros like Ubuntu, increasingly useful applications for a variety of tasks and at the same time, increasing reliance, particularly amongst the biggies mentioned above, to cast on to the benefits of open sourced stuff.

To contribute in a open source software, I have repeatedly said, and would reiterate that you do not need to have a guru like knowledge in any computer field. Most of the FOSS projects also require skills like creativity in form of graphics, animation as well as in stuff like language translation.

The future
Its a turning point for businesses and industries (we are coming out of the recession corner), and people are looking again for constant innovation. Be it LAMP in small businesses or open sourced SOA in big ones, FOSS is the way to go for the entire business community as it is the cost-effectiveness that has being noticed in an important way. Thus, for the time to come, FOSS would continue its meteoric rise in importance amongst all types of softwares.

Please note that the above views are my own and may not be solely constructed as truth without further consultation. So basically, don't come after me with a lawsuit based on what I've posted above.

Monday, June 29, 2009

JavaFx- Skeptical Student's point of view

Why JavaFx right now? This is a question that has led me to be skeptical about this technology. As of now, the 1.2 version is out which requires at least a java 6 update 13 JDK, which essentially means that this technology is growing at an immense rate. However, the market out there of RIAs is quite ripe and in the next few years is going to be the ‘in’ thing. Keeping that in picture, a lot of companies have brought out their platforms (like silverlight, flex, etc). Only time will tell us the fate of these technologies as it is their adoption by various mobile/hardware vendors, which will decide what would be the preferable one amongst them, when it comes to their marketability.
Sun Microsoft is currently developing and promoting their JavaFx and this reminds me of JSF, which was launched in a similar fashion. Based on my observations, I’ve drawn quite a lot of parallels amongst them. Both have excellent integration with the Netbeans IDE as well as compatible with other products as well. Excellent documentation and tutorials are available for these (thanks to efforts by sun and everybody else). The development style of both is quite revolutionary and, I’d say, surprisingly pleasing if you’ve had the right tools.
However, JSF didn’t quite achieved what it was meant to do- a replacement of struts. The ui model is complicated for many and for me, jsf does still have those dark corners which make me hesitant to use them. Here, I am not going against JSF, but I’d like to make a point that currently, frameworks like spring have brought in innovative technology and are currently, the most sought-after when it comes to job requirements. However, as frameworks mature, like JSF, there comes a bit of stability as well as integration like what Jboss Seam did to JSF, increasing flexibility and keeping it simple(or even more easy).
So, what lies in store for a student?
Keeping in view the current market status, investing one’s time in JavaFx looks like a risky proposition to me as arguably, one can learn technologies like LAMP (configuration and app. development) to be marketable instead of this JavaFx scripting language (just comparing job prospects, and not the technologies here).
On the sidenote, JavaFx is one of the most promising and exciting technology but the pace of its development certainly is a source of concern as not everyone has an adequate bandwidth to cope up with the frequent updates. For a student, it’ll require a lot of efforts (or time) to keep abreast with the latest changes in JavaFx, a thing which we do not have the luxury of as a vast majority needs to build their skills in basic programming and then, enterprise development.
As a personal note, although JavaFx looks quite promising to me (I’ve been hearing about this for an year now), there are enough reasons for me to postpone the learning of this technology as currently, I’d just wait and watch.

Thursday, June 11, 2009

Be Heard!

In order to increase the traffic on your blogs, you need to market them. Apart from the word-of-mouth publicity, you'll need some technology to back yourself. This is akin to having a P.R. manager of your blog.
A ping (not to be confused with the ping command in operating systems that resolve a dns address) is basically a XML-RPC (xml Remote Procedure Call) that allows the destination server to register your blog and its new post. Since there is intense competition amongst these blog ping allowable servers, so you have to manually ping these servers separately.
Some of these are:
ping O matic

These are knowledge sharing websites and act as brokers of information between your blog and the general internet users.
To ping, you need a client. Stupidzombie is one such free software that runs on java and is quite easy to use.
Lastly, after pinging, you can expect increase in traffic/hits on your blog and thereby make you one step closer to being a professional blogger.

Monday, June 8, 2009

Is sex a taboo over internet ?

Seems like we cyborgs have moved back into dark ages.Microsoft's newest search engine(currently in beta), bing is reportedly blocking search queries like sex.
My opinion is still divided as on one hand, it is a right step in curbing the menace of pornography over internet and, on the other, is an open threat of a corporation that is trying to dictate what internet should be.

Currently in beta, the indian version on bing reports sex search as: "The search sex may return sexually explicit content.
To get results, change your search terms."
One wonders whether it'll cause any good as if a person is intended to search for a lascivious content, a search engine is not an effective stopping solution for it. Rather, we'll need to regulate these websites, which, unfortunately are quite profit making concerns.
So, just blocking the users from the result will not be enough for Microsoft as they'll have to hold some sort of agreement with all other search engines.

Friday, May 15, 2009

Developing Web 2.0 components rapidly using Zembly

It’s been a revelation as I've used the Zembly platform from sun microsystems. It is basically an online IDE to develop your web 2.0 applications (aka social apps) which are then hosted on various social networking websites for all to see and use.

When I received an email about a blogging contest about this platform, I was initially sceptic about the technologies as I am not much of a fan of these platforms. Earlier, I had some frustrating experiences with these technologies(as they require a mashup of html,css,javascript,xml without a decent program development environment) and frankly speaking, wasn’t keen on developing them

Today, due to a chance introduction into a really cool technology (it was quite whirlwind), my efforts have been renewed. After a few days, when my semester exams are over, this would be a great technology to keep me busy this summer.

Application development has been a breeze in zembly as the widgets are created in a wizard like process and in addition to the standard editor, we get a wysiwyg ide which is amazingly customizable. The icing of the cake, however, is the ability to search and add readymade resources which can solve the problem of reinventing the wheel in these type of applications.
Currently, i've just started using this platform, but in near future, I am planning to induct the collaboration feature into my application development process which will further enhance the quality of applications that we (the team of developers constructing the widget) will create. This is not all as the website offers an excellent public rating system to determine as to where my application stands. In addition to an excellent web-based IDE, the zembly also offers various documentation tools and thoughtful features like a time line(see below).

On a sidenote, I've observed about the integration of this technology with various other services(social networking websites) as well as platforms(iphone, for instance). However, there was no integration/offering from the sun itself (I'll have to research here), which was baffling for me, considering the amount of attention they generated when javafx was launched. So my initial response towards this technology has been upbeat, but as it is new, not much resources are available for learning. Hopefully, this changes in the near future. For any further queries, do post here/mail me about the same.

Sunday, March 29, 2009

Annotations for java 6
Well, this title itself is a misnomer as there is no such new feature included in java 6 (aka Mustang). However, the necessary thing is that in java 6, annotations find a heavy usage in the newer and updated API instead of just three annotations in java 5. So it is quite imperative that we understand this nifty change in the language.
Annotations do not directly affect our programs but change the way our programs are processed by other tools and libraries.
The annotations facility was introduced as JSR-175 in jdk 1.5 and has been formalized through JSR-269 in jdk 1.6.
There has been a considerable debate about this addition regarding the location of the application configuration (xml vs. annotation).
Typically you would never have to create annotations in the normal course of application development but there are extensible options for this too. An annotation type is just an interface with @interface keyword.
public @interface ProjectStatus{
String status() default "[Not-Started]";
Now we can use it to annotate declarations as a modifier like public, static, private, etc. The annotation consists of a @ followed by its type name and optionally, a list of element-value pairs. All annotation types implicitly extend the java.lang.annotation interface. The values can be any one of the following:
A wrapper class
VariableElement (like an enum constant)
AnnotationMirror (will further return a map of values, if any)
List< ? extends AnnotationValue > (if the value is an array)
Annotation Type Declaration (Meta Annotations)
This is the meta content for annotation itself as it provides library support for annotations. These are:
Documented :In this, annotations with a type are to be documented by javadoc and similar tools by default. Through this, annotations become a part of th public API of their elements.
Inherited :This shows that the annotation type is automatically inherited. If this is present, a query is thrown to the annotation type on a class declaration. On its unavailability, all the superclasses are searched until the top of the hierarchy, Object is reached. If no superclass in this type has the annotation, the query will indicate that the particular class has no such annotation.
Retention :This is used to set the scope of annotations(SOURCE,CLASS,etc). This is important if the meta annotation type is used directly for annotation. However, if the meta-annotation type is used as a member type in another annotation type, this will have no effect.
Target :This indicates the type of programming element(ElementType.FIELD,ElementType.METHOD,etc) where the annotation type is applicable. On its presence, the compiler will enforce a restriction upon the usage of that particular annotation
public @interface BookElement{
The annotations processing is one area which underwent a change in java 6.
In java 5, a library called as Mirror API was used which contained 2 parts – one for processor (com.sun.mirror.apt) and other for support classes that modeled the language. In java 6, the processor piece has been relocaled to javax.annotation.processing. This provides facilities for declaring and allowing annotation processors to communicate with an annotation processing tool. However, this feature is not going to be used much in normal developmental tasks.
A basic processor would be:
import java.util.Set;
import javax.annotation.processing.*;
import javax.lang.model.*;
import javax.lang.model.element.*;
@SupportedSourceVersion ( SourceVersion.RELEASE_6 )
@SupportedAnnotationTypes ( "*" )
public class PrintProcessor extends AbstractProcessor
public boolean process ( Set < ? extends TypeElement > annotations, RoundEnvironment environ ){ //NOTE: these arguments would be provided by the annotation processing tool framework.
if ( !environ.processingOver ( ) ){
for ( TypeElement element : annotations ) {
//process annotations here
System.out.println ( element.getQualifiedName ( ) + "(" + element.getNestingKind ( ) + ")" );
return false;
On parsing, if we get a malformed annotation, then we'll throw a AnnotationFormatError. Likewise, if we attempt to access an annotation object whose type has changed, then it results in AnnotationTypeMismatchException. As annotations is still an evolving feature in java, the use of newer versions of certain annotation in a processor may raise a UnknownAnnotationValueException.
The javax.annotation Package
This package has 5 annotation types and although these are meant to be used in enterprise edition, these are bundled as a standard API in java 6. An overview of these annotations
Generated: Is used to mark the auto-generated code in a source file. This can be used to differentiate between human and IDE generated code.
Resource: Marks a resource that is needed by the application. This is a form of dependency injection as the container will automatically inject an instance of resource when the component is initialized. This name is the jndi name of the resource.
Resources: Similar to resource, takes an array of resource for multiple resources. This is populated using multiple Resource annotations.
PostConstruct: Used on a method that needs to be executed after dependency injection is done for further construction.
PreDestroy: Used on methods that release resources upon finalization of the object in the container.
InitialContext init=new InitialContext();
DataSource ds=(DataSource) init.lookup(“jdbc/__bookDbPool”);
Connection connect=ds.getConnection();

Same functionality with annotation reduces much of the ‘boilerplate’ code.
@Resource(name = ”jdbc/__bookDbPool”)
DataSource ds;

Connection connect=ds.getConnection();

Similarly, we can use other annotations
@Resource(name=”jms /__defaultFact”)
public void initialize(){
public void cleanup (){
The java.sql and javax.sql packages
Among other thoughtful additions in jdbc 4.0 api, there has been a fundamental change in the way we are going to handle data at its lowest abstraction. They simplify the object-relational mappings. Here, we create a query interface that decouples the query from the logic to some extent.
interface CustomizedQuery extends java.sql.BaseQuery{
DataSet getAllOfficeEmployees();
int clearOffice();
Here, we are just decorating different queries using annotations from Note that we are returning a DataSet instead of a ResultSet from a @Select annotation, while the @Update simply returns the number of records affected. The java.util.DataSet is a standard data structure that can be populated/deleted and used directly in our business logic.
The usage of data items is quite easier:
CustomizedQuery custom = connection.createQueryObject(CustomizedQuery.class);
DataSet rows=custom.getAllOfficeEmployees();
The java.xml package
In this package and its subpackages, annotations find a heavy usage. Speaking strictly in terms of enhancements in java6, the XML Data Bindings Specification(JAXB) has been updated to its 2.0 version. Thus, a lot of change has been done in javax.xml.bind package. For instance, there are more than 30 annotations defined in javax.xml.bind.annotation package. A complete description of these, however, would merit a complete article on its own.
Web Services
The java6 has brought web services into the domain of a desktop application developer. Here too, annotations play a major role in easing the developmental process.
import javax.jws.*;
public class WebService1{
public String method(){
return “Web service method”;
The 2 basic annotations displayed here identify this class as a web service. As the name of @WebService annotation is not specified, it defaults to the class name. The benefit of using this approach is that a lot of work gets automatically done from automated tool like wsgen.
Similarly, we can leverage annotations in javax.jws.soap package to create SOAP bindings. Through their usage, we can connect to existing web services with ease
Thus, we are observing simplification of application development through the increased use of annotations which is not just limited to javase, but in java ee as well as in other frameworks like struts2, hibernate, etc. to name just a few. This means that sooner than later we'll have to adopt this technique as it is increasingly being used.
Sumit Bisht

Saturday, March 7, 2009

Cleaning Your Removable Drives

This instruction is meant for those geeks who just want to do something cool in their spare time. Many a times, we are faced with the problem of virus removal when we connect to the outside world of our computer. This also includes offline and asynchronous connectivity through removable 'pen' drives for transfer of data.

It is not uncommon to observe the fact that when we use our flash drives in different computers, they commonly get infected with viruses and we have to use commercial antivirus software to clean them or, even worse, format them and seeing all our data being wiped out.

Thus, I have devised a somewhat crude but effective technique to 'clean' your removable drives without using any antivirus software.

Actually, when our pen drives do get infected, a file known as autorun.inf gets modified. This is a hidden file in windows and as the name suggests, is automatically run whenever we insert that drive to perform any task. Commonly, virus programs hijack at this juncture leading to spreading of infection amongst different computers. In windows, a common dialog comes asking for permission from the user to select what to do in this initial stage.

Fig.1    Asking for permission from the user in normal state

Here, the drive inserted is a healthy one as it shows a removable disk icon.

But, if it is infected, the above dialog box becomes:

Fig.2    Asking for permission from the user in infected state

As soon as you select ok, the script in autorun.inf gets executed and virus starts running.

Also, the disk icon becomes with the same dangerous effects as the above dialog box.

My Remedy

I've tried to solve this through my Ubuntu operating system. It is a debian linux based human-friendly os which is surprisingly easy to use.

Here, just open terminal window to initiate command line operations that we will require firstly in order to gain the necessary permissions. To do this, we'll require the use of chmod command.

Here, just get to the root of your disk and type

chmod 777 autorun.inf

This ensures that all permissions are granted to you. Alternatively, you could modify this to suit your requirements.

Once you've gained these permissions, you can view and subsequently edit the contents of autorun.inf in a text editor.

Now, just select everything and hit the delete to wipe out everything.

Congratulations, you have deleted the malicious program from your drive.

A word of caution

If the virus was creating .exe files corresponding to every folder, then to wipe them out, just search the disk contents in windows.

Now sort these using the 'Type' tab:

Here, select the .exe files that are of the folder type 'These would have a folder icon' and delete them.


Well, this was my solution that required some hacking. This solution is not foolproof and should work on common virus infections. Remember, these hacks are helpful if you are careful enough to observe the minute differences in infected disks and take remedial measures without allowing malicious scripts/programs to run.These in no manner are absolutely secure and have only been recently used by me in a limited number of tests. So, there remains a scope for improvement in this regard.

Do tell me about your thoughts. I'd love to ponder over them.

Saturday, February 28, 2009

Open-Sourced Programming

One of my desired goal has been achieved. I've started contributing actively in open soured projects.
This was essential for me to get some experience and exposure in developing software.

On sourceforge website(http://sourceforge.net), I've been a member for quite a bit of time but was unable to join the desired projects.So here are some of my recommendations for starting up:

1. Look for a project of your interest that you can contribute in. For example, if you are comfortable in 'C' programming language, then look for a 'C' programmer requirement.
2. Not all projects require programming skills. So my advice is to arm yourself with all of your knowledge. You never know, when your documentation skills, for example, may be required.
3. Be honest and truthful about yourself.Well, this hardly merits a note, but again, t is quite important to be so.
4. READ the project details.
Yes! this is most important as project details by the admin determine what exactly, he or she is looking for. This is also important to stimulate your imterest in the project.
5. Do look for a nice project, not just the technology you want.
6. Lastly, i'd say as in every organization, you will start from the lowest rung of the ladder.

Having said that, I followed these principals somewhat loosely and have started as a GUI Developer in the Pundict project (https://sourceforge.net/projects/pundict/)
This is a Punjabi~English translation dictionary which uses the XDXF format (which is xml based) for maintaining its data.
The beauty of this application is that it runs on any platform ( as it is java based) and through its open-sourced dictionaries in XDXF format, it is extensible to a very large extent.
The implications of my application are that it can be used as a tool to learn new languages, and, in process, save many languages from becoming extinct.
Initial view of the dictionary