Sun Solaris Installation

Had a chance to install Sun Solaris 10 on a Solaris machine today with a 64-bit AMD Opteron processor. The machine came installed with Windows XP 64 bit (first time seeing it too) but we didn’t have the password to access the system.

The installation was quite straightforward with its auto-boot GUI installation wizard, although it asked damn lots of questions from network settings to locale BEFORE asking the user to assign disk space for the installation. (imagine the situation when you configured everything but did not have enough disk space for it.

The end result of it is a unix system (with /etc /var /bin), and two GUI apps (CDE – Common Desktop Environment & Java Desktop) which are Windows-like GUI systems. The CDE resembles more like X-Win while Java Desktop mimics Windows closer (with a “Start” button and taskbar). Configuration is still as weird as normal Unix, since I’m not that Unixy.

The weirdest part was before installation we used a “self-burnt” DVD to try install Solaris 10 x86 Update 2. The CD-ROM boots and stucks at “Loading stage2…”. Google say its a known bug when installing from SCSI DVD-ROM drives but ours is IDE (I think). Popping the CD out throws us into GRUB (GRand Unified Bootloader), but we can’t start the install wizard despite trying those “boot” and “kernel” commands.

In the end we resorted to using an “older” original version of Sun Solaris 10 x86, also DVD.

– ifconfig = ipconfig
– DNS nameservers is set in etc/resolv.conf


UltraVNC is a flavour of VNC — its an open source project in SourceForge. It provides all basic VNC features: connecting to remote machine, perform mouse/keyboard tasks on remote machine, transfer files, etc. It even allows connection via HTTP using a Java Viewer, possibly allowing it to cross firewalls.

Configuration is straightforward with a single password, but I’ve yet to see if it can integrate into the Windows Authentication.

So far UltraVNC has served me well and hasn’t given me serious problems. Server installs cleanly, and the client is light and doesn’t even need installation. A simple unzip and the viewer can be run.


VMWare allows you run an OS inside your OS, eg. Run Linux in your Windows machine, or Windows in Linux. A very useful program I think.

I installed my WinXP Pro in an WinXP Pro machine, and used the VM as a test platform to try out software without corrupting my actual system. Can be also used to test if some software is spyware-like. Once I made a complete installation, I made a “copy” of the OS so I have a clean WinXP installation anytime.

Working within the VM is exactly like having another machine, much like what VNC provides, except the VM is not any physical machine anywhere else. The VM has its own BIOS, hard disk space and IP address… I could ping from my host to VM and VM to host, very real.

The only annoyance was trying to transfer files between my host OS and the VM. This is especially necessary when I want to copy installation files over. Shared folders didn’t really work out, so I had to use another machine’s shared folder. Perhaps there exists an easier way for file transfer from host to VM.

I give VMWare 10 out of 10.

Effective Java (Review)

4. Avoid creating duplicate objects
5. Eliminate obsolete object references

12. Minimize accesibility of classes and members

21. Replace enum constructs with classes

23. Check parameters for validity
27. Return zero-length arrays, not nulls

29. Minimize the scope of local variables
30. Know and use the libraries
31. Avoid float and double if exact answers are required
32. Avoid strings where other types are more appropriate
33. Beware the performance of string concatenation
36. Use native methods judiciously
37. Optimize judiciously

39. Use exceptions only for exceptional conditions
47. Don’t ignore exceptions

So you know how to code…

Most entry programmers learn how to program procedurally first, understanding that program instructions run one after another. Subsequently they learn control flow (if/else/for/while) and functions to modularize their code.

With these, one can almost write amazing programs. So where should we go from here?

For OO langauges like Java/.Net, I think there are two directions from here. One is to go lower level, to understand the foundation of the language, syntax, types, basic classes, including OO concepts like encapsulation, inheritance and polymorphism. This can be translated towards the Java Programmer certification. The other is to go higher level, to understand software architecture, data structures and design patterns. This will allow for better software that may be more efficient, maintainable and/or scalable.

The two directions are not XOR (one but not the other). Instead they are both as important. Looking at how other people write may also help in grasping style and technique, even identifying anti-patterns (style/design that should be AVOIDED).


JMF allows you to work with media – audio and video. Working with here means input (reading in from file/device), processing (encoding/decoding/multiplexing) and output (to file/network/screen).

Nitty-gritty details are mostly shielded from the programmer, yielding a clean interface for use. In fact once we completed our audio streaming, converting it to video streaming was almost a one-liner change for the Format class. However since we need to separate the components clearly (content vs transport), we had to try tear JMF apart. In fact JMF handled so much of RTP that we just need to give it a ip/port and off it goes.

The flexibility of the framework theoratically allows all forms of media to be processed, however it is currently limited to certain codecs and formats, maybe due to the need to interact with native hardware/OS, or licensing issues. We had some problems interacting with webcams, likely issue to be the webcam drivers are application specific, only their own apps know how to access the webcam. Hopefully more webcam providers make their cams OS-generic, such that it can be recognized by Windows. This way it is more likely JMF will be able to detect it.

Another issue we bumped into is that JMF binds to AWT. For displayable components like Video visual and Video controls, it is returned as an AWT component. Since we use SWT it could be a chore to code bridges.

Because of performance, JMF comes in certain performance packs, which probably have certain algorithms in native code so it runs faster/better by making use of the OS/hardware. (accelerator? processor opcodes?)