Free Download Software

One of the most common questions I receive from clients lately is: “Which API should I use?”  Unfortunately it is not a simple answer; ESRI provides three APIs and two ADFs which include; JavaScript API, Flex API, Silverlight API and the .Net and Java Web.ADFs.  I answer the question with a combination of questions needed to isolate the answer.  For example:

What version of ArcGIS server are you running?

• The ArcGIS APIs are only supported at the 9.3 version.  Any version bellow ArcGIS Server 9.3 would require the Web.ADF.

Is browser plug-ins an option?

• ArcGIS Server APIs for Flex and Silverlight require browser plug-ins. If your application cannot require a plug-in, the JavaScript API or one of the Web. ADFs will need to be your choice. 
• The ArcGIS Server API for Flex requires the Flash plug-in, which 99% of Internet clients seem to have. The Silverlight plug-in has not yet reached the same level of ubiquity, but can be expected to gain ground.  Plug-ins come in different versions, which may also present a hurdle in getting end users to experience the Web site in the way you expect. If you choose to use Flex or Silverlight, it is wise to consider how flexible you are to upgrade plug-in versions. The ArcGIS API for Flex requires Flash Player 9 or above. The 1.0 release of the ArcGIS API for Silverlight requires Silverlight 2 or above.

How quick do you want to get it done?

• Web.ADF out-of-the-box is the fastest way to deploy, followed by Flex, JavaScript, and then Silverlight.  To get a client jumpstarted they have the following options;  the sample Flex viewer template can be downloaded and configured using an xml file.  JavaScript can be added to an html page and edited using note pad.  Silverlight requires Visual Studio and Expression Blend and the sample template has some quality issues.

Which platform are your developers most comfortable with?

• Many beginning developers find the JavaScript and Flex easier to learn than the Web.ADF or Silverlight, but Silverlight and ADF have the power of the .NET framework behind it.  I suggest choosing a platform that your staff already knows and can save you ramp-up costs.  However, we are seeing a lot of community based support for the Flex API, lots of contributed samples and code snippets. We expect to see the same sort of community support for the Silverlight API as well. Additionally, the .NET ADF can become fairly heavy if a lot of customized functionality is needed. This can impact performance.

What Integrated Development Environment (IDE) is needed?

• When you choose an API, you are also making choices about the environment where you’ll spend your time coding. Flex developers use Adobe Flex Builder 3.  .Net and Silverlight developers use Visual Studio or Visual Web Developer Express. Expression Blend is another option for Silverlight developers. Java developers use Eclipse or NetBeans. JavaScript programmers probably have the most choices, including the option to just write code in a text editor.  Cost of the IDE may also a factor.

Do you need to edit features over the Web?

• GISi already has a limited editing framework for the APIs.  The .Net and Java ADFs offer access to fine-grained ArcObjects, which can be used to edit feature geometries. The ADFs contain out-of-the-box tasks for basic Web editing operations. If you need to build an application with Web editing fast and now, go with the ADF.  More editing features are planned for the JavaScript, Flex, and Silverlight APIs at the release of ArcGIS Server 9.4 in 2010.

What is the industry trend?

• I’m definitely seeing a trend away from the ADFs and towards the APIs.  Out of the APSs it’s a close race.  Flex has come out of the gates fast and has a bit of a lead on the others, but Silverlight has Microsoft behind it and ESRI is definitely working close to Microsoft.

After answering questions like these, the clients usually have a clear answer.  Several of my answers might be subjective, so I try to keep my personal perspective or opinion and desires out of the equation, unless asked directly.

Last month I Spotified the Billboard charts by using the Billboard and Spotify APIs.  However, I wasn’t actually able to create real Spotify playlists since the Spotify web API doesn’t allow creating or manipulating playlists.  But now I’m a premium Spotify user and as a premium user I can use the libspotify / despotify API to do just about anything that the official Spotify client can do.  With my new found Spotify superpower, I revamped my Billboard charts creator to create real Spotify playlists:

The Spotified Billboard Singles Charts

Instead of having to click on every song to listen to it, just click on the chart – this will open the Spotify playlist – hit play and you’ll be in Billboard chart heaven (or hell, depending on your music taste).

To interact with Spotify I used Jotify – a Java client library (based on despotify)  for Spotify.  Jotify is  well written, full featured library written by Felix Bruns (who has been extremely helpful in answering my questions).   I highly recommend Jotify.

Very basics law of java.

1. package directant;  // like namespace or under a same folder

2.  import javax.swing.*; import java.awt.*;  // like include

3. Must have main

public class Main {
public static void main(String[] args){
// call gui window

}
}

Just a small but a very handy.
##############################################
1. GUI – will eat time – we used seperate GUI builder jvider.com
2. Action collect centrally
3. Programming
##############################################

Main.java
=========

// Simple Ant procedurepackage directant;
/** * * @author shamun */public class Main {
/**     * @param One main execute     */    public static void main(String[] args) {        // Other tasks can be done here.                // Calling GUI        Gui gui = new Gui();        gui.setVisible(true);    }
}

Gui.java
=======
package directant;

import javax.swing.JPanel;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.UIManager;

import javax.swing.UnsupportedLookAndFeelException;

import java.awt.*;

import java.awt.event.*;

/**

*

* @author shamun

*/

public class Gui extends JFrame implements ActionListener{

static Gui theGui;

JPanel pnPanel0;

JButton btBut0;

JButton btBut1;

public static void main( String args[] ) throws UnsupportedLookAndFeelException{

try

{

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

}

catch ( ClassNotFoundException e )

{

}

catch ( InstantiationException e )

{

}

catch ( IllegalAccessException e )

{

}

catch ( UnsupportedLookAndFeelException e )

{

}

theGui = new Gui();

}

public Gui(){

super( “TITLE” );

pnPanel0 = new JPanel();

GridBagLayout gbPanel0 = new GridBagLayout();

GridBagConstraints gbcPanel0 = new GridBagConstraints();

pnPanel0.setLayout( gbPanel0 );

btBut0 = new JButton( “shamun”  );

gbcPanel0.gridx = 1;

gbcPanel0.gridy = 2;

gbcPanel0.gridwidth = 15;

gbcPanel0.gridheight = 4;

gbcPanel0.fill = GridBagConstraints.BOTH;

gbcPanel0.weightx = 1;

gbcPanel0.weighty = 0;

gbcPanel0.anchor = GridBagConstraints.NORTH;

gbPanel0.setConstraints( btBut0, gbcPanel0 );

pnPanel0.add( btBut0 );

btBut1 = new JButton( “foo”  );

gbcPanel0.gridx = 7;

gbcPanel0.gridy = 11;

gbcPanel0.gridwidth = 11;

gbcPanel0.gridheight = 4;

gbcPanel0.fill = GridBagConstraints.BOTH;

gbcPanel0.weightx = 1;

gbcPanel0.weighty = 0;

gbcPanel0.anchor = GridBagConstraints.NORTH;

gbPanel0.setConstraints( btBut1, gbcPanel0 );

pnPanel0.add( btBut1 );

setDefaultCloseOperation( EXIT_ON_CLOSE );

setContentPane( pnPanel0 );

pack();

setVisible( true );

// Mannually created – Attach button actions

btBut1.addActionListener(this);

btBut1.addActionListener(new EventCentral());

}

// Mannually created

public void actionPerformed(ActionEvent e) {

//throw new UnsupportedOperationException(“Not supported yet.”);

System.out.print(“First thread \r\n”);

}

}// End of GUi

EventCentral.java
===============

// namespace

package directant;

// includes

import java.awt.event.*;

// Event Actions are listening on here.

public class EventCentral implements ActionListener {

// Not in use, we can use it as __construct.

public EventCentral(){}

// This is getting trigger by Gui.Java

public void actionPerformed(ActionEvent e) {

System.out.print(“Second thread \r\n”);

}

}

Performance:

Prefer SWING to use. Performance issues and latest. Eeven if SWING is written on top of Awt. Most other experts advised also that both maybe used by with correct implementations.

Default:

Swing GUI prefered

Java we dont have Pointer ( *) and Preprocessor (#if or #define)  like (ADA and C we have)

For example:
=========

int main(void)
{
    struct tag *st_ptr;         /* a pointer to a structure */
    st_ptr = &my_struct;        /* point the pointer to my_struct */
    strcpy(my_struct.lname,"Shamun");
    strcpy(my_struct.fname,"Foo");
    printf("\n%s ",my_struct.fname);
    printf("%s\n",my_struct.lname);
    my_struct.age = 63;
    show_name(st_ptr);          /* pass the pointer */
    return 0;
}

@Good:

Java uses References ( like c/c++)

@Bad:

we cant make easyly this:  System.out.print(“Hello world”);  like this: echo “Hello world”;

- www.hecl.org – implemented somthing like that.

Java compiled file like: Main.java to Main.class

Now in case you lost it you can go back by decompiling it, that means its not secured. Using dcompiler tools ( i dont use it, this is for my research purpose)

java -jar filename.jar

Just a small but a very handy.
##############################################
1. GUI – will eat time
2. Action collect centrally
3. Programming
##############################################

Main.java
=========
package directant;

import javax.swing.*
import java.awt.*;

public class Main {
public static void main(String[] args){
// call gui window

}
}

Gui.java
=======
package directant;

EventCentral.java
===============

Introduction:

Many IDE made life easier, but there is some time comes we really cant do simple basic run/compile/etc etc, by thanking to all IDE’s. Just few notes when lonely situations.

Less talk:

Unix/Linux/Windows shell mode:

#javac

$javac sourcode.java (this will compile and make sourcode.class)
#java

$java sourcode (this will execute the sourcecode.class)

$java -jar buildedfile.jar (will execute the jar )

Just a small but a very handy.
##############################################
1. GUI – will eat time
2. Action collect centrally
3. Programming
##############################################

Main.java
=========
package directant;

import javax.swing.*
import java.awt.*;

public class Main {
public static void main(String[] args){
// call gui window

}
}

Gui.java
=======
package directant;

EventCentral.java
===============

The JSR 316 (Java EE 6) has been approved by the “Executive Committee for SE/EE”. See the vote result details here.

It is interesting to see that the Web Profile has no optional component. In fact all these guys are required:

• Servlet 3.0
• JavaServer Pages (JSP) 2.2
• Expression Language (EL) 2.2
• Debugging Support for Other Languages (JSR-45) 1.0
• Standard Tag Library for JavaServer Pages (JSTL) 1.2
• JavaServer Faces (JSF) 2.0
• Common Annotations for Java Platform (JSR-250) 1.1
• Enterprise JavaBeans (EJB) 3.1 Lite
• Java Transaction API (JTA) 1.1
• Java Persistence API (JPA) 2.0
• Bean Validation 1.0
• Managed Beans 1.0
• Interceptors 1.1
• JSR-299 1.0
• JSR-330 1.0

You can find all specs (Java EE 6, Web Profile and Managed Bean) here. Looks like there are now three standards that less or more do (somehow) Dependency Injection:

• Managed Beans
• JSR 299
• JSR 330

As the Managed Bean was optional for a JSF 2.0 implementation, it is now (somewhat) required to be implemented. Well Apache MyFaces did that already… And, of course, the JSF RI /Mojarra/ did that too.

Note : This article is copied from JavaRanch for my easy reference in the future as this is a common question with the interviewers

Getting in Touch with your Inner Class

One Object shares deeply personal feelings. Next… on a very, special, Campfire Story.

Being an object like me isn’t as fun as you might think.

It gets lonely…

Out here…
on the heap…
alone.

Not to mention the horror, the emotional devastation when you feel your last reference slip away and it hits you — you’ve just become food for the garbage collector.

But you know what helps? Having an inner class. An inner class can ease the loneliness… as long as somebody makes an instance of that inner class. All I really want is someone to bond with.

Someone to share my most private thoughts (and variables and methods). Someone who knows EVERYTHING about me. An intimate relationship shared between two objects — an outer and an inner.

I’m very protective of my inner class. If somebody wants to instantiate my inner class, they MUST go through me– an object of the outer class.

My inner class can’t exist on its own. I, as an instance of the outer class, can live on my own (however unhappily). You don’t have to make an instance of an inner class in order to have an instance of the outer class. But you can NEVER make an instance of my inner class without an outer object to “bind” it to.

My inner class needs me.

We have that special bond.

It makes life on the garbage-collectible heap bearable.

Here’s how to do a little object matchmaking of your own:

class Outer
{
private int size ;
private String thoughts = “My outer thoughts”;

class Inner
{
String innerThoughts = “My inner thoughts”;

void doStuff()
{
// inner object has its own “this”
System.out.println( innerThoughts );

// and it also has a kind of “outer this”
// even for private data of outer class
System.out.println(thoughts);
}
}
}

OK, but nothing really happens until somebody makes an instance of BOTH classes…

class TestMe
{

public static void main( String args[] )
{
// instantiate me, the outer object
Outer o = new Outer();

// Inner i = new Inner();
// NO! Can’t instantiate Inner by itself!

Outer.Inner i = o.new Inner();
// now I have my special inner object
i.doStuff();
// OK to call methods on inner object
}

}

You can also instantiate both the outer class and inner class at the same time:

Inner i = new Outer().new Inner();

I know that looks odd, but it shows that you need an outer object, so that you can ask it to make an inner object. In this example, you didn’t even keep a reference to the outer object… only the inner object, “i”. The inner object “i” still knows its outer object… its “outer this”. (By the way, there is no keyword “outer this” — that’s just a concept for the way inner objects behave. They behave as if the outer object’s variables were their own.)

I hate static!

You’ve probably heard about static inner classes. Well, they don’t deserve to be called inner classes!

A static inner class (an inner class marked as static) looks like this:

class Outer
{
static class Inner
{
}
}

I don’t like them because they don’t give me that special object-to-object bond. In fact, static inner classes aren’t even supposed to be called inner classes at all. Technically, they are “top-level nested classes“.

A static nested class can be instantiated, but the object created doesn’t share any special relationship with an outer object.

The static nested class is tied only to the outerclass, not an instance of the outer class.

Outer.Inner i = new Outer.Inner();

That’s why you can make an instance of the static nested class withouthaving an instance of the outer class, just the way you can call static methods of a class without having any instances of that class. A top-level nested class is little more than another way to control namespace.

But let’s go back to inner classes; they’re so much more meaningful. And did you know that I can bond with an instance of my inner class even when I don’t know the NAME of my inner class? For convenience, you can get an instance of an inner class and make that inner class at the same time.

It works like this…

Imagine you (the programmer) are making your nice GUI program and you decide that you need to know when the user clicks your GO button. “I reckon I need an ActionListener object”, you say to yourself. So you type:

goButton.addActionListener([object goes here]);

And then you slap your forehead as you realize… “I can’t make aninstance… I don’t even HAVE an ActionListener class!”

You never made yourself a class that implements the ActionListener interface.

Not a problem.

You can create a new class which implements the ActionListener interface, AND make an instance of that new class – all inside the parameter to the Button object’s addActionListener() method.
How cool is that?

It looks like this:

goButton.addActionListener
(
new ActionListener()
{
public void actionPerformed( ActionEvent e )
{
doImportantStuff();
}
}
);
It works like this:

new ActionListener()

says to the compiler: “Create an instance of a new, unnamed class whichimplements the ActionListener interface…”

And after that opening curly brace (shown above in green) you define the new unnamed class…

public void actionPerformed( actionEvent e )
{
doImportantStuff();
}

That actionPerformed method is the same one you would be forced to define in any class which implements the ActionListener interface. But this new class has no name. That’s why its called an anonymous inner class.

And notice that you did not say “new MyActionClass()”. You said, “new ActionListener()”. But you aren’t making an instance of ActionListener, you’re making an instance of your new anonymous class which implements the ActionListener interface.

“But wait!” you say, “What if I don’t want to implement an interface… what if I want to make an anonymous inner class that extends another class?”

Once again, No Problem-o.

Whatever you say after the “new” as in “new Something()”, if Something is an interface, then the anonymous class implements that interface (and must define all the methods of that interface). But if Something is a class, then your anonymous class automatically becomes a subclass of that class. This is perfect for the event adapter classes like WindowAdapter.

Finally, don’t forget to close the parameter to the  goButton.addActionListener(

by finishing off with a closing parentheses and the semicolon ending that statement…
);

Programmers always seem to forget that last little semicolon way down there, since the statement started waaaaaay up above somewhere.

Danger Danger!

Now I feel compelled to warn you about one thing with anonymous inner classes, or any other inner class that you define inside a method (as opposed to inside the class but NOT inside a method). The inner class can’t use local variables from the method in which the inner class is defined!
After all, at the end of that method, the local variables will be blown away. Poof. Gone. History. That inner object you created from that inner class might still be alive and kickin’ out on the heap long after that local variable has gone out of scope.
You can, however, use local variables that are declared final, because the compiler takes care of that for you in advance. But that’s it — no method parameters from that method, and no local variables.

Another warning about all inner classes is that they can’t declare any static members unless they are compile-time constants and are primitives or Strings. (This does not apply to static nested classes, of course). But don’t worry — the compiler will stop you if you try.

Finally, you should know that some programmers really dislike inner classes, and especially anonymous ones. Some folks claim they’re not very object-oriented, and others get their feathers ruffled over “encapsulation violations” because the inner object can access the private data of the outer object.

Well you know what I say?
That’s the point!

It’s that special relationship, that intimate bond, that makes inner classes so practical. Otherwise you’d have to make constructors for your inner class, and pass references to variables, etc. when you instantiate the inner class… all the things you have to do with a plain old non-inner class, which you have to treat like an outsider.

But when you’re trying to decide if inner classes are right for you, please… think of me…

the poor, lonely, object…

on the heap…

alone .

I know you’ll do the right thing.

(Oh, and don’t feel compelled to stop at just ONE inner class and inner object… there’s nothing in the Java spec that says outer objects have to be monogamous)
The end.

(Editor’s note: this story represents the opinion of the author — an Object — and does not necessarily reflect the views and opinions of the CowGirl, Javaranch, Bert, or any of the cows)

One of our esteemed audience members, David Lu, writes:

That Outer class gets involved in some slutty relationships. At first, it all seems very nice and romantic to have a special inner class to share with, but I then came to realize that the outer class can have affairs with other inner classes.

Then, the outer class starts having “anonymous” inner class relationships! The outer class doesn’t even know their names! What is going on here? One night stands? Hookers? Free Love? I’m shocked!

The Outer class has no further comments.

cd tutorial proactive

Jazz yang sangat berbakat Marc Antoine seniman telah mengeluarkan CD-nya berjudul cruisin. Saya sangat percaya diri dan senang untuk mengumumkan bahwa saya percaya Marc Antoine penggemar dan penggemar Jazz akan senang dengan yang satu ini. Dengan rilis cruisin Marc Antoine S keunggulan artistik adalah ditampilkan sebagai penuh Antoine sekali lagi telah menyampaikan koleksi lagu brilian yang bisa sangat baik menjadi dia karya terbaik-to-date.

Ini adalah hari yang langka memang bahwa saya mendapatkan sebuah CD dari seorang seniman yang saya dapat dengan jujur mengatakan tidak memiliki lagu yang buruk dalam kelompok. Aku lebih dari senang untuk mengumumkan bahwa S persis apa yang harus saya katakan tentang ini. TIDAK hanya ada yang buruk dalam kelompok. Tidak ada cd tutorial proactive pengisi di sini sama sekali.

Salah satu hal-hal baik dan menyegarkan tentang CD ini adalah cara Cd Tutorial semua seniman yang berpartisipasi tampaknya benar-benar menikmati diri mereka sendiri. Campurkan bahwa dengan keseluruhan presentasi dan kau Ve punya salah satu Marc Antoine S paling mengesankan yang pernah rilis.

Jika Anda bahkan agak ke musik Jazz Anda akan menikmati album ini. Keseluruhan cruisin adalah rilis yang hebat. Aku berikan ganda saya thumbs up. Anda tidak akan kecewa dengan satu lagu.

Sementara seluruh album ini beredar lagu yang benar-benar menonjol adalah lagu – On The Strip lagu – Indian Summer dan melacak – Fuego.

Bonus saya Pick dan salah satu yang mendapat Sore … seperti dalam amp quot Stuck On Ulangi amp quot adalah lagu – Mas Que Nada. Ini adalah trek yang hebat

Cruisin Release Notes

Marc Antoine cruisin awalnya dirilis pada Juni tentang GRP Records label.

CD Track List Follows

. Mas Que Nada

. On The Strip

. Cruisin amp

. Sierra Bella

. Just Chillin amp

. Java Montmarte

. Indian Summer

. Karibia Morning

. Fuego

Personil Marc Antoine gitar keyboard bass programming Jerry Hei terompet Michael Davis trombon Larry cd tutorial proactive Williams flute Ricky Peterson Philippe Saisse piano keyboard Alex Al Dave Carpenter bass Peter Erskine Lil amp John Roberts drum Luis Conte perkusi Patti Austin background vokal .

Produser Tommy LiPuma Paul Brown Philippe Saisse.

Hai frend..! ketemu lagi di Java Lesson 7, kali saya menulis tentang penulisan class, attributnya dan metode. Silahkan diperhatikan listingnya, baca perjelasannya dan diamati.

Line 1 : class Tabungan {
Ini adalah deklarasi kelas, yang mana di dalam kelas ini dapat kita isi konstruktor, metode, dan atribut.
Line 2 : public int saldo = 0;
Nah, klo diatas kita membicarakan tentang atribut, inilah salah satu atribut dari kelas Tabungan dengan modifier “public” yang berarti atribut ini dapat diakses oleh kelas lain. Dan atribut ini diberi nilai awal 0.
Line 3 : Tabungan(int initsaldo){
Ini yang kita sebut konstruktor, yaitu metode atau fungsi yang namanya sama dengan nama kelasnya. Konstruktor berfungsi untuk menjalankan perintah didalam bloknya ketika

Penjelasan :
Line 4 : do
Perintah do adalah perintah untuk menjalankan statemen yang ada di dalam bloknya ( tanda kurawal / line 5 dan line 8 )
Line 5 : {
Ini adalah pembuka blok untuk perintah do
Line 6 & 7 : Statemen yang berada dalam blok do
Line 8 : }
Ini adalah penutup blok untuk perintah do
Line 9 : while(a<10);
Berbeda dengan while sebelumnya, while yang ini berada dibelakang statemen yang akan di ulang (statemen line 6 dan 7).

Log dalam programming digunakan untuk kepentingan development dan production. Saat development kita ingin info yang sedetail-detail saat aplikasi berjalan. Log yang sering digunakan dalam java salah satunya adalah Log4j. Saat digunakan, biasanya log4j menggunakan konfigurasi yang ada di file log4j.xml. Untuk JBoss 4.2.x sendiri file konfigurasinya adalah jboss-log4j.xml, terdapat di dalam ~\jboss-4.2.x\server\default\conf\.
Dalam file tersebut dapat kita set treshold (batasan) dari log yang akan ditampilkan dari yang tertinggi ERROR,WARN,DEBUG dan INFO. Kalau tresholdnya di set INFO , maka semua level (ERROR,WARN, DEBUG,INFO) log akan di tampilkan.
Output dari log4j sendiri bisa berupa tampilan di console, dalam file, database atau dikirimkan ke email tertentu.
Treshold menjadi penting kala aplikasi memasuki proruction. File log yang ukurannya akan terus menerus bertambah, semakin detail levelnya, INFO misalnya, semakin besar file log yang dibuat. Di JBoss, file log nya adalah server log, by defualt dan bisa di ubah dengan mengubah file jboss-log4j.xml pada line
dan server.lognya diganti.

A policy file in Java is an ASCII text file and can be edited in a text editor or the graphical Policy Tool Utility polocytool. It can be started from the command prompt like:

C:\Documents and Settings\ranjan>policytool

Following is a very good tutorial on this tool:

policytool – Policy File Creation and Management Tool

Please see the .pdf file for more information. I need to perform operations to the attached matrix set. Must be solved using Matlab and program must be written in Java, C++ or anything of your choice… (Budget: $30-250, Jobs: C/C++, Java, Javascript, Python)
Bid on this project

Yep. Sunday afternoon, I was this close to nuking the linux partition on my laptop. Monday, a lack of blank CDROM disks saved me.
I have … three linux machines in the house, not counting commodity items like a TiVo and such. One backup machine, one media machine, and my desktop machine. The backup machine is frozen at Debian unstable sometime four years ago — it works, and upgrades of working boxes scare me. The media machine I keep up to date, again tracking Debian unstable. I recently lost a drive on my last 1.3 kernel machine, a truly ancient and no-longer-used NAT box. My desktop machine has Ubuntu (I think Ibex) on it; but that machine mostly is used as a Windows box.

For the last nearly 10 years, however, my work laptop has been my primary development machine. I’ve been fortunate to be involved in Java development for the bulk of that time; non-GUI Java development no less. Telemetry systems, compilers, logic database servers, etc. For me, the environment is Eclipse and Java. The OS is somewhat less relevant than it is for others. (In the old days of Java 1.0, the environment was Emacs and Make. Make + Java == headaches.) (Some would say Emacs is an OS. Heh.)

So Why Run Linux At All?
Every oneof my work laptops (a succession of Dell’s broken by a Thinkpad) has come with Windows installed; somewhere in 2003-2005, Blackdown’s JDK became available, before Sun was willing to support Linux. Prior to that, the Windows JVM was faster than the Solaris JVM for concurrent operations; for a long while Solaris’s JDK was mired in green_threads and such. But even the early Blackdown JDK delivered better performance on Linux than Sun’s own JDK did on Windows — I went where the speed was. Plus, for server applications, Java really was ‘write-once-run-everywhere’. So I worked hard to keep that Linux partition running as laptops came and went.

What Went Right?
When I got my current laptop, a Dell D830, over two years ago, I decided to stray from my Debian roots. The last laptop had introduced SATA, and has been a real pain to get Debian installed on as SATA support was new and wifty. This time around I decided to try a stock Ubuntu install; Gutsy Gibbon I think. It just flew in. Installation was trivial. I waded through the GCJ junk and got Sun’s JDK installed. Again, the same programs on the same machine under Java were faster under Linux than under Windows XP. Life was good.

Sure, suspend/resume was a fond hope, Flash lagged in terms of support, yatta-yatta. But for me, Eclipse + Linux + Java was fast, fast, fast.

What Went Wrong?
I kept up the install, moving from Gutsy to Hardy to Ibex. Things stayed good. I liked KDE3.

Then I updated to Jaunty and I noticed something. For the first time, Java under XP was nearly as fast as Java under Linux. It didn’t seem that Windows had gotten any better, rather it seemed like there was more gunk in the works in Ubuntu. Plus, either within the release or on purpose, I tried KDE 4.0. It wasn’t that I didn’t like KDE 4; but it just didn’t help me work any better, at a cost of familiarlity (I was compiling KDE 2 for Solaris a lifetime ago; I liked KDE3). Suspend/Resume were still missing, and Nvidia seem to hit a pothole with their drivers. Multihead was still a pain in the ass when you moved between multiple setups daily.  I found myself sticking to Windows more often. In the last three months, I use Windows exclusively.

Then Karmic came around. I thought “Hey, there has been lots of rumbling about laptop support; maybe they fixed a bunch of stuff”. So I dist-upgraded. That did not go well; lots of stuff was in odd states, partial packages, strange error messages, general weirdness. I figured, I’d steadily upgraded across multiple releases — moving my partitions across machines — maybe it was time for a clean install? So I burned a CD, tar’d up my home directory, and installed from scratch.

Karmic is neat! Lots of stuff that just works, lots of eye-candy, cool.

Except.

It was slow as molasses.

I mean, ridiculously slow. I have a test suite (all Java) that I run multiple times a day. Around a thousand tests, across the creation and deletion of twenty-plus database servers. Under Windows it takes around 2000 seconds. Left to run overnight, it took over 4.5 hours on the exact same machine under Karmic.

9X Slower? WTF?

Turkey Troubleshooting
My family had a stay-at-home Thanksgiving. My girls watched Mythbusters for hours. I spent most of it installing various Linux distros and trying things. It was painful, and ultimately fruitless, but for an accident.

First, I realized the cpu frequency scaling was keeping my processors at 800Mhz, instead of 2.2Ghz. Further rooting revealed that cpufreqd, when installed, had a rule to limit the frequency to 800Mhz when the temp went above 55C. That was a bit low for my chip, so I removed that rule for the purposes of investigation. That was fun; I could force the system to run at 2.2Ghz, but the temp show up past 95C! I halted the tests before things got melty. (BTW, if you don’t bother to check your CPU speed, you can just be plagued by the feeling that your machine is slow, never realizing it is running slowly. The Gnome CPU Freq applet is a help here.)

No ACPI fan registered at all. The I8K modules see the fan, and can even make it spin faster, but after 3-5 seconds the fan would slow down. Still the system would zoom up past 80C.

Switching back to Windows gave me my first clue — the fan came on, louder than it ever was under Linux, and spun madly for around five minutes. Running the tests showed the CPU temp never getting above 70C. Perhaps there were fan control issues? I found various comments to this effect, lots of random cpufreq comments in the kernel changelogs, and a number of really interesting bug reports in Launchpad. This forum post sums things up nicely. Lots of frustration, apparently since Jaunty, precious few answers.

I ran through Debian Stable, Fedora 12 (very nice), and Arch Linux (also nice if you are willing to spend a bit more time managing your system). Gentoo looked attractive, but I was too cranky by that point. All the systems performed the same, with minimal fan speed and lots of overheating. Only Fedora seemed to match the polish of Ubuntu; only Arch matched the package management of Debian/Ubuntu. FWIW.

Sunday night I bagged it; resigning myself to leaving Linux behind for at least a while. I don’t really have time for a distro I have to work to maintain. This laptop is a tool. My boss will happily fail to pay me for screwing around with Linux.

Eureka!
I went into the office Monday, and I had a problem. The last distro I had installed, Arch, never picked up my Windows XP partition as bootable, and it wasn’t in the Grub menu. I could noodle around in Grub, or I could just install Ubuntu again. Hey, they might fix it someday? Maybe in Lucid?

We couldn’t find a blank CD. What are the odds? Then we found an old one, but Brasero under Arch failed to burn it. Blech.

Then my Release Engineer/IT Guy/Resident Mad Scientist says he thinks he has one already made up. We run Ubuntu on a batch of Dell servers, so it is plausible. (any guesses where this is going?) But he doesn’t have Karmic Desktop — he has Karmic Server.

What the hell — I use the laptop as a server for all intents and purposes anyway, so what could it hurt?

I got it installed, then I installed X, gnome-core, sun-java6, and Eclipse. Ran my test. Blinked. Listened as the fans spun mightily.

Temp never got above 67C. Tests completed in 1799 seconds. Ha! Victory!

Dance of the happy coder!

Wha-at Happened?
Got me. I have some theories.

• no acpid running. NO acpi modules installed. Yes, this means no suspend/resume — I don’t miss it. Boot is so fast I don’t care anymore. I suspect the kernel ACPI code of being … not quite happy with my D830.
• different kernel — Ubuntu server installs the PAE kernel by default. What else might be different in that kernel?

Something is now keeping it’s grimy paws out of the BIOS’s way when it comes to fan control. Someone with more time than I have can work their way incrementally from an Ubuntu Server install to an Ubuntu Desktop install and figure out where the tripwire is.

But Ubuntu Server saved Linux for me.

Suppose you are trying to run the simple Java class in the current directory where you have the .class file also. Suppose you have GetProps.class file in C:\Test directory and the command you run is the following:

C:\Test>java GetProps

and you are getting the following exception:

Exception in thread "main" java.lang.NoClassDefFoundError: GetProps
Caused by: java.lang.ClassNotFoundException: GetProps
        at java.net.URLClassLoader$1.run(Unknown Source)
        at java.security.AccessController.doPrivileged(Native Method)
        at java.net.URLClassLoader.findClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClass(Unknown Source)
        at java.lang.ClassLoader.loadClassInternal(Unknown Source)
Could not find the main class: GetProps.  Program will exit.

Then probably the reason is that the current directory in not in classpath environment variable. So add the current directory “.” in the classpath or you run the above command as the following:

C:\Test>java -classpath “.” GetProps