Only my share

Currently I’m working at the Telecommunication Company (Bakrie Telecom). I’m a staff of IT Billing Prepaid Development Department. The main function of this department is to build a variety of interfaces between IT Application whether it is build by other IT teams or by the third party vendors, to Bakrie Telecom ‘s Network Element such as SMSC (Short Message Service Center), IN (Intelligent Network), HLR (Home Locator Register) and any others standard TELCO Network Element.

My Manager is a PERL Hacker. He can do his magic with just a few of key stroke to accomplish variety of job or script, for example to parse the large CDR files, make a network connection to the Network Elements (for provisioning process) or connect to the Database. So in my first career in this company, I have to read preexisting of codes and I’m sure I got a lot of thing from it. But I don’t know why something missing in my mine. PERL is not really comfortable to program with (for me). Maybe, this is because my strong background as a Java programmer. So after about six months working for this company, I decided to write some of my new development jobs using Java Technology.

But after some development job has been done using my favorite Java Technology, I became to realize that there are some difficulties when I had a kind of development jobs that has a lot of parsing tasks. As we know, it’s very hard or maybe complex to accomplish such a job in Java programming language because of the lack of expressiveness of this language.

But now, the situations are totally different, I got a Groovy Programming language as second standard programming language in Java platform. So with this language I can accomplish a lot of job that is hard to do with Java Programming language with more enjoyment and fun.

In this article I want to show some examples of how Groovy programming Language can be more expressive than PERL.

1. Read a text file

In this section assumed that we’re going to dump a text file located at local directory c:/mylovepoet.txt

This is my code in groovy:

/**
Reading a text file located at c:/mylovepoet.txt using Groovy
*/
new File(“c:/mylovepoet.txt”).eachLine{ line ->
println line
}

This is my code in PERL

/**

Reading a text file located at c:/mylovepoet.txt using PERL

*/
open(INPUT, “c:/mylovepoet.txt”);

while(<INPUT>) {
$line = $_;
$line =~ s/\r|\n//gi;
print “$line\n”;
}

close(INPUT);

2. List Manipulation

In this example we have the list of programming language names, from this list we want to extract the programming language name that contains special characters such as ‘+’ or ‘#’. We can accomplish this job by the following Groovy and PERL script:

/**
List usage in Groovy
*/

pl_list = [‘B’, ‘C’, ‘C++’, ‘JAVA’, ‘C#’]
pl_with_special_char_list = pl_list.grep(/^\w(\+|#)+\w*$/)

and this is my script in PERL

/**
List usage in PERL
*/

@pl_list = (‘B’, ‘C’, ‘C++’, ‘JAVA’, ‘C#’);
@pl_with_special_char_list = ();
$i = 0;

for($pl (@pl_list)) {
if($pl =~ /^\w(\+|#)+\w*$/) {

$pl_with_special_char_list[$i] = $
$i++;
}

}

This article have no intention to prove that Groovy is better than PERL, but this article just want to show us that Groovy can be more expressive than PERL.

I have read lots of user posting at various pages and none of them would work.
Finally, I found a way to do this correctly and hope this will help to some of you.

Follow the simple steps:

1. To set the environment variables :

echo ‘export JAVA_HOME=/opt/btel/java/jdk1.5.0_16′ > /etc/profile.d/jdk.sh

echo ‘export PATH=$JAVA_HOME/bin:$PATH’ >> /etc/profile.d/jdk.sh

2. You have to source the file you just created by typing:
source /etc/profile.d/jdk.sh

3. Test if Java environment is successfully installed by typing in this in the shell:
java -version

James Strachan is the founder of the Groovy Project. His inspiration of this project was started when he and his wife were waiting for the late plane schedule at the airport. He decided to visit Internet Cafée at the Airport, while his wife was going for shopping. When he was browsing from one web page to the others web page he decided to visit Python official Web Site. When he learned this language, he realized that there is a large amount of beautiful language features in Python that do not exist in his beloved programming language and platform technology, Java.

James Strachan and Bob McWhirter founded the Groovy project in 2003, recognizing that application development in Java is characterized by using multiple frameworks and gluing them together to form a product. They designed Groovy to streamline exactly this kind of work. At the same time, Richard Monson-Haefel met James, who introduced him to Groovy. Richard immediately recognized Groovy’s potential and suggested the submission of a Java Specification Request (JSR-241).

But what is the reaction of Sun Microsystem about the born of this language? Do they feel it as the other Java language competitor? No Guys, They don’t see Groovy as Java’s rival but rather as a companion that attracts brilliant developers who might otherwise move to Ruby or Python and thus away from the Java platform. Since the JSR has been accepted, Groovy is the second standard language for the Java VM (besides the Java language itself).

Goes back to 1991, when a group of Sun engineers, led by Patrick Naughton and Sun Fellow (and all-around computer wizard) James Gosling, wanted to design a small computer language that could be used for consumer devices like cable TV switchboxes. Since these devices do not have a lot of power or memory, the language had to be small and generate very tight code. Also, because different manufacturers may choose different central processing units (CPUs), it was important not to be tied down to any single architecture. The project got the code name “Green.”

The requirements for small, tight, and platform-neutral code led the team to resurrect the model that some Pascal implementations tried in the early days of PCs. What Niklaus Wirth, the inventor of Pascal, had pioneered, and UCSD Pascal did commercially, was to design a portable language that generated intermediate code for a hypothetical machine. (These are often called virtual machines—hence, the Java Virtual Machine or JVM.) This intermediate code could then be used on any machine that had the correct interpreter. The Green project engineers used a virtual machine as well, so this solved their main problem.

The Sun people, however, come from a UNIX background, so they based their language on C++ rather than Pascal. In particular, they made the language object oriented rather than procedure oriented. But, as Gosling says in the interview, “All along, the language was a tool, not the end.” Gosling decided to call his language “Oak.” (Presumably because he liked the look of an oak tree that was right outside his window at Sun.) The people at Sun later realized that Oak was the name of an existing computer language, so they changed the name to Java. In 1992, the Green project delivered its first product, called “*7.” It was an extremely intelligent remote control. (It had the power of a SPARCstation in a box that was 6 inches by 4 inches by 4 inches.) Unfortunately, no one was interested in producing this at Sun, and the Green people had to find other ways to market their technology. However, none of the standard consumer electronics companies were interested. The group then bid on a project to design a cable TV box that could deal with new cable services such as video on demand. They did not get the contract. (Amusingly, the company that did was led by the same Jim Clark who started Netscape—a company that did much to make Java successful.)

<!–[if gte mso 9]> Normal 0 false false false EN-US X-NONE X-NONE MicrosoftInternetExplorer4 <![endif]–><!–[if gte mso 9]> <![endif]–> The Green project (with a new name of “First Person, Inc.”) spent all of 1993 and half of 1994 looking for people to buy its technology—no one was found. (Patrick Naughton, one of the founders of the group and the person who ended up doing most of the marketing, claims to have accumulated 300,000 air miles in trying to sell the technology.) First Person was dissolved in 1994.

While all of this was going on at Sun, the World Wide Web part of the Internet was growing bigger and bigger. The key to the Web is the browser that translates the hypertext page to the screen. In 1994, most people were using Mosaic, a noncommercial Web browser that came out of the supercomputing center at the University of Illinois in 1993. (Mosaic was partially written by Marc Andreessen for $6.85 an hour as an undergraduate student on a work-study project. He moved on to fame and fortune as one of the cofounders and the chief of technology at Netscape.) In the SunWorld interview, Gosling says that in mid-1994, the language developers realized that “We could build a real cool browser. It was one of the few things in the client/server mainstream that needed some of the weird things we’d done: architecture neutral, real-time, reliable, secure—issues that weren’t terribly important in the workstation world. So we built a browser.” The actual browser was built by Patrick Naughton and Jonathan Payne and evolved into the HotJava browser that we have today. The HotJava browser was written in Java to show off the power of Java. But the builders also had in mind the power of what are now called applets, so they made the browser capable of executing code inside web pages. This “proof of technology” was shown at SunWorld ‘95 on May 23, 1995, and inspired the Java craze that continues unabated today.

The big breakthrough for widespread Java use came in the fall of 1995, when Netscape decided to make the Navigator browser Java enabled in January 1996. Other licensees include IBM, Symantec, Inprise, and many others. Even Microsoft has licensed Java. Internet Explorer is Java enabled, and Windows ships with a Java virtual machine. (Note that Microsoft does not support the most current version of Java, however, and that its implementation differs from the Java standard.) Sun released the first version of Java in early 1996. It was followed by Java 1.02 a couple of months later. People quickly realized that Java 1.02 was not going to cut it for serious application development. Sure, you could use Java 1.02 to make a nervous text applet that moves text randomly around in a canvas. But you couldn’t even print in Java 1.02. To be blunt, Java 1.02 was not ready for prime time.

The big announcements about Java’s future features trickled out over the first few months of 1996. Only at the JavaOne conference held in San Francisco in May of 1996 did the bigger picture of where Java was going become clearer. At JavaOne the people at Sun Microsystems outlined their vision of the future of Java with a seemingly endless stream of improvements and new libraries.

The big news of the 1998 JavaOne conference was the upcoming release of Java 1.2, which replaces the early toy-like GUI and graphics toolkits with sophisticated and scalable versions that come a lot closer to the promise of “Write Once, Run Anywhere”™ than their predecessors. Three days after (!) its release in December 1998, the name was changed to Java 2.

Since then, the core Java platform has stabilized. The current release, with the catchy name Java 2 Software Development Kit, Standard Edition version 1.3, is an incremental improvement over the initial Java 2 release, with a small number of new features, increased performance and, of course, quite a few bug fixes. Now that a stable foundation exists, innovation has shifted to advanced Java libraries such as the Java 2 Enterprise Edition and the Java 2 Micro Edition.

Hello everyone.. this is my blog.. this is a blog about Java, Groovy , Grails and their related technologies.. if you’re looking ffor love poetry or something disgusting like that.. oh sorry u arrived at the wrong place..he..he..he.. enjoy our live guys..