This week's giveaway is in the Beginning Java forum.
We're giving away four copies of Bad Programming Practices 101 (e-book) and have Karl Beecher on-line!
See this thread for details.
Win a copy of Bad Programming Practices 101 (e-book) this week in the Beginning Java forum!

Kelvin Chenhao Lim

Ranch Hand
+ Follow
since Oct 20, 2007
Cows and Likes
Total received
In last 30 days
Total given
Total received
Received in last 30 days
Total given
Given in last 30 days
Forums and Threads
Scavenger Hunt
expand Ranch Hand Scavenger Hunt
expand Greenhorn Scavenger Hunt

Recent posts by Kelvin Chenhao Lim

For what it's worth, it seems that the mobile app & game development industry is growing pretty fast in Singapore. Unfortunately, Java qualifications tend to be less relevant in this domain, but it might be worth a shot if you're game (pardon the pun!) to go into this type of software development.

You'll probably see a lot of Java work relating to government / defence-related contracts, but (as noted above) many of these jobs require Singapore citizenship or PR status. I spent the last 3+ years doing this, and in my opinion the work challenge was very interesting and the financial compensation was very good (relative to other software jobs in Singapore).
8 years ago
Great score! Congratulations, Lukas!
10 years ago
Congrats! It seems to take most people around 2-4 weeks to receive their certification package from Sun, though it's possible that you may get it slightly earlier or later.
10 years ago
Hamraj's question is a good one, though. Personally, I do agree that Java should at least issue a warning when you assign a long to a float or double, or an int to a float. But it is what it is, unfortunately. Still, it's good that you're at least aware of the possibility of losing precision, since a surprising number of programmers I work with don't even know about that.

Originally posted by Serge Petunin:
When you cast an integer number to a float or a double number, you can loose precision anyway.

This isn't always true. An int will always be exactly representable in a double, since double values use 52 bits for the mantissa. But long values may indeed lose precision as you mentioned.

Originally posted by Sid Robin:
I assume option D is also right

Nope. Runtime's gc() method is a non-static method, so you can't invoke it without an instance of Runtime.
It seems that Sun usually keeps at least two versions of the SCJP available at any given time, so the SCJP 5 is very likely to remain available until the release of SCJP 7 (or whatever the next version's called). In fact, the SCJP 1.4 is still available right now, and probably will continue to be available for another year or so. You're definitely not going to see the SCJP 5 go away anytime soon.
Unbeatable score! Congratulations!
10 years ago
Hi Serg,

Welcome to Javaranch. Basically, the issue here is that Java does not allow lower bounds for type parameters, i.e. "<T super Foo>" is always invalid syntax. It does allow lower bounds for wildcards, e.g. "<? super Foo>".

You may want to check out this other thread from last week where we briefly discussed this same issue.
Aside from the issues that Ulf pointed out, are you also sure you want to start a new JVM to run your sub-application? Depending on exactly what you want to achieve, you may find the Reflection API more useful and appropriate. Things get slightly complicated if the .class files aren't already in your current classpath (you may need to create a new class loader), but this may still be better than using Runtime.exec().

Originally posted by Mohammad Mujeeb:
Is the SCJP book by Kathy and Bert Bates at par with Head first JSP and servlets or are there better books available?

Well, Kathy and Bert also co-wrote Head First Servlets & JSP, so you're definitely in very safe hands.
My guess is that a typical StringBuffer implementation starts off with an array of a certain size (which I believe you can also set as a constructor parameter), and whenever it needs more space, it simply creates a new array with double the capacity, and copies the old array elements over to the new array. From a computer science perspective, this is a simple way to achieve good amortized performance, despite the occasional array copying cost.
Great score, Kota! Congratulations!
10 years ago
Hi Karthik,

You'll find lots of helpful information in the SCJP FAQ. In my opinion, the answer to your question will depend on your certification goals. If your primary aim is to get one of the "higher" Sun certifications (SCBCD/SCWCD/etc), then I suppose it doesn't quite matter so much which SCJP version you take, since any of them will qualify you to take the higher exams.

But if you're interested in getting some value out of the SCJP itself, then you definitely want to take either the SCJP 1.6 or 1.5 instead of 1.4. Many important new language features were added in Java 1.5, and you'll probably need to learn them for your job anyway, so a SCJP 1.5 certification is undoubtedly more valuable than 1.4 as far as your own skills development is concerned. Also, Java 1.4 is rather outdated by now (the current version is 1.6), and the whole point of certification is to demonstrate your mastery of the latest technology in the market. If I were an interviewer, I would definitely question why you chose to take the SCJP 1.4 when more recent exams have been available for well over two years. (And I would look unfavorably on those who reply that they chose the SCJP 1.4 because it's easier!)