Saturday, September 5, 2009

Top 10 errors Java programmers make

Making mistakes is the common human nature, but we need to ensure that we shouldn't do repetitive mistakes. There are a few mistakes usually all Java programmers do irrespective of their experience. They are......

10. Accessing non-static member variables from a static method.

public class StaticDemo
public String my_member_variable = "somedata";
        public static void main (String args[])
// Access a non-static member from static method
System.out.println ("This generates a compiler error" +
my_member_variable );
main is a static method. So, we must create an instance of the class if we want to access the non-static members of the class.

9. Mistyping the name of the method while overriding

public class MyWindowListener extends WindowAdapter {
// This should be WindowClosed
public void WindowClose(WindowEvent e) {
// Exit when user closes window

Compilers won't pick up on this one, and the problem can be quite frustrating to detect. In the past, I've looked at a method, believed that it was being called, and taken ages to spot the problem. The symptom of this error will be that your code isn't being called, or you think the method has skipped over its code. The only way to ever be certain is to add a println statement, to record a message in a log file, or to use good trace debugger (like Visual J++ or Borland JBuilder) and step through line by line. If your method still isn't being called, then it's likely you've mistyped the name.

8. Comparision assignment (= instead of ==)

Fortunately, even if you don't spot this one by looking at code on the screen, your compiler will. Most commonly, it will report an error message like this : "Can't convert xxx to boolean", where xxx is a Java type that you're assigning instead of comparing.

7. Comparing two objects ( == instead of .equals)

When we use the == operator, we are actually comparing two object references, to see if they point to the same object. We cannot compare, for example, two strings for equality, using the == operator. We must instead use the .equals method, which is a method inherited by all classes from java.lang.Object.

Here's the correct way to compare two strings.

String abc = "abc"; String def = "def";

// Bad way
if ( (abc + def) == "abcdef" )
// Good way
if ( (abc + def).equals("abcdef") )

6. Confusion over pass by value and pass by reference

This can be a frustrating problem to diagnose, because when you look at the code, you might be sure that its passing by reference, but find that its actually being passed by value. Java uses both, so you need to understand when you're passing by value, and when you're passing by reference.

When you pass a primitive data type, such as a char, int, float, or double, to a function then you are passing by value.

When you pass a Java object, such as an array, a vector, or a string, to a function then you are passing by reference. Yes - a String is actually an object, not a primitive data type. So that means that if you pass an object to a function, you are passing a reference to it, not a duplicate. Any changes you make to the object's member variables will be permanent - which can be either good or bad, depending on whether this was what you intended.

On a side note, since String contains no methods to modify its contents, you might as well be passing by value.

5. Writing blank Exception handlers

I know it's very tempting to write blank exception handlers, and to just ignore errors. But if you run into problems, and haven't written any error messages, it becomes almost impossible to find out the cause of the error.

4. Forgetting that Java is 0-based index

3. Preventing concurrent access to shared variables by threads

When writing multi-threaded applications, many programmers (myself included) often cut corners, and leave their applications and applets vulnerable to thread conflicts. When two or more threads access the same data concurrently, there exists the possibility (and Murphy's law holding, the probability) that two threads will access or modify the same data at the same time. Don't be fooled into thinking that such problems won't occur on single-threaded processors. While accessing some data (performing a read), your thread may be suspended, and another thread scheduled. It writes its data, which is then overwritten when the first thread makes its changes.

Such problems are not just limited to multi-threaded applications or applets. If you write Java APIs, or JavaBeans, then your code may not be thread-safe. Even if you never write a single application that uses threads, people that use your code WILL. For the sanity of others, if not yourself, you should always take precautions to prevent concurrent access to shared data.

How can this problem be solved? The simplest method is to make your variables private (but you do that already, right?) and to use synchronized accessor methods. Accessor methods allow access to private member variables, but in a controlled manner. Take the following accessor methods, which provide a safe way to change the value of a counter.

public class MyCounter
private int count = 0; // count starts at zero

public synchronized void setCount(int amount)
count = amount;

public synchronized int getCount()
return count;

2. Capitalization errors

This is one of the most frequent errors that we all make. It's so simple to do, and sometimes one can look at an uncapitalized variable or method and still not spot the problem. I myself have often been puzzled by these errors, because I recognize that the method or variable does exist, but don't spot the lack of capitalization.

And.. last but not the least.....

1. NULL Pointers!!!!

Null pointers are one of the most common errors that Java programmers make. Compilers can't check this one for you - it will only surface at runtime, and if you don't discover it, your users certainly will.

When an attempt to access an object is made, and the reference to that object is null, a NullPointerException will be thrown. The cause of null pointers can be varied, but generally it means that either you haven't initialized an object, or you haven't checked the return value of a function.

Many functions return null to indicate an error condition - but unless you check your return values, you'll never know what's happening. Since the cause is an error condition, normal testing may not pick it up - which means that your users will end up discovering the problem for you. If the API function indicates that null may be returned, be sure to check this before using the object reference!

Another cause is where your initialization has been sloppy, or where it is conditional. For example, examine the following code, and see if you can spot the problem.

public static void main(String args[])
// Accept up to 3 parameters
String[] list = new String[3];

int index = 0;

while ( (index < i =" 0;">

This code (while a contrived example), shows a common mistake. Under some circumstances, where the user enters three or more parameters, the code will run fine. If no parameters are entered, you'll get a NullPointerException at runtime. Sometimes your variables (the array of strings) will be initialized, and other times they won't. One easy solution is to check BEFORE you attempt to access a variable in an array that it is not equal to null.

Courtesy :

Sunday, August 30, 2009

Run Commands

Program Run Command
Accessibility Controls access.cpl
Accessibility Wizard accwiz
Add Hardware Wizard hdwwiz.cpl
Add/Remove Programs appwiz.cpl
Administrative Tools control admintools
Adobe Acrobat ( if installed ) acrobat
Adobe Distiller ( if installed ) acrodist
Adobe ImageReady ( if installed ) imageready
Adobe Photoshop ( if installed ) photoshop
Automatic Updates wuaucpl.cpl

Basic Media Player mplay32
Bluetooth Transfer Wizard fsquirt

Calculator calc
Ccleaner ( if installed ) ccleaner
C: Drive c:
Certificate Manager cdrtmgr.msc
Character Map charmap
Check Disk Utility chkdsk
Clipboard Viewer clipbrd
Command Prompt cmd
Command Prompt command
Component Services dcomcnfg
Computer Management compmgmt.msc
Compare Files comp
Control Panel control
Create a shared folder Wizard shrpubw

Date and Time Properties timedate.cpl
DDE Shares ddeshare
Device Manager devmgmt.msc
Direct X Control Panel ( if installed ) directx.cpl
Direct X Troubleshooter dxdiag
Disk Cleanup Utility cleanmgr
Disk Defragment dfrg.msc
Disk Partition Manager diskmgmt.msc
Display Properties control desktop
Display Properties desk.cpl
Display Properties (w/Appearance Tab Preselected ) control color
Dr. Watson System Troubleshooting Utility drwtsn32
Driver Verifier Utility verifier

Ethereal ( if installed ) ethereal
Event Viewer eventvwr.msc

Files and Settings Transfer Tool migwiz
File Signature Verification Tool sigverif
Findfast findfast.cpl
Firefox firefox
Folders Properties control folders
Fonts fonts
Fonts Folder fonts
Free Cell Card Game freecell

Game Controllers joy.cpl
Group Policy Editor ( xp pro ) gpedit.msc

Hearts Card Game mshearts
Help and Support helpctr
Hyperterminal hypertrm
Hotline Client hotlineclient

Iexpress Wizard iexpress
Indexing Service ciadv.msc
Internet Connection Wizard icwonn1
Internet Properties inetcpl.cpl
Internet Setup Wizard inetwiz
IP Configuration (Display Connection Configuration) ipconfig /all
IP Configuration (Display DNS Cache Contents) ipconfig /displaydns
IP Configuration (Delete DNS Cache Contents) ipconfig /flushdns
IP Configuration (Release All Connections) ipconfig /release
IP Configuration (Renew All Connections) ipconfig /renew
IP Configuration (Refreshes DHCP & Re-Registers DNS) ipconfig /registerdns
IP Configuration (Display DHCP Class ID) ipconfig /showclassid
IP Configuration (Modifies DHCP Class ID) ipconfig /setclassid

Java Control Panel ( if installed ) jpicpl32.cpl
Java Control Panel ( if installed ) javaws

Keyboard Properties control keyboard

Local Security Settings secpol.msc
Local Users and Groups lusrmgr.msc
Logs You Out of Windows logoff

Malicious Software Removal Tool mrt
Microsoft Access ( if installed ) access.cpl
Microsoft Chat winchat
Microsoft Excel ( if installed ) excel
Microsoft Diskpart diskpart
Microsoft Frontpage ( if installed ) frontpg
Microsoft Movie Maker moviemk
Microsoft Management Console mmc
Microsoft Narrator narrator
Microsoft Paint mspaint
Microsoft Powerpoint powerpnt
Microsoft Word ( if installed ) winword
Microsoft Syncronization Tool mobsync
Minesweeper Game winmine
Mouse Properties control mouse
Mouse Properties main.cpl
MS-Dos Editor edit
MS-Dos FTP ftp

Nero ( if installed ) nero
Netmeeting conf
Network Connections control netconnections
Network Connections ncpa.cpl
Network Setup Wizard netsetup.cpl
Notepad notepad
Nview Desktop Manager ( if installed ) nvtuicpl.cpl

Object Packager packager
ODBC Data Source Administrator odbccp32
ODBC Data Source Administrator odbccp32.cpl
On Screen Keyboard osk
Opens AC3 Filter ( if installed ) ac3filter.cpl
Outlook Express msimn

Paint pbrush
Password Properties password.cpl
Performance Monitor perfmon.msc
Performance Monitor perfmon
Phone and Modem Options telephon.cpl
Phone Dialer dialer
Pinball Game pinball
Power Configuration powercfg.cpl
Printers and Faxes control printers
Printers Folder printers
Private Characters Editor eudcedit

Quicktime ( if installed ) quicktime.cpl
Quicktime Player ( if installed ) quicktimeplayer

Real Player ( if installed ) realplay
Regional Settings intl.cpl
Registry Editor regedit
Registry Editor regedit32
Remote Access Phonebook rasphone
Remote Desktop mstsc
Removable Storage ntmsmgr.msc
Removable Storage Operator Requests ntmsoprq.msc
Resultant Set of Policy ( xp pro ) rsop.msc

Scanners and Cameras sticpl.cpl
Scheduled Tasks control schedtasks
Security Center wscui.cpl
Services services.msc
Shared Folders fsmgmt.msc
Sharing Session rtcshare
Shuts Down Windows shutdown
Sounds Recorder sndrec32
Sounds and Audio mmsys.cpl
Spider Solitare Card Game spider
SQL Client Configuration clicongf
System Configuration Editor sysedit
System Configuration Utility msconfig
System File Checker Utility ( Scan Immediately ) sfc /scannow
System File Checker Utility ( Scan Once At Next Boot ) sfc /scanonce
System File Checker Utility ( Scan On Every Boot ) sfc /scanboot
System File Checker Utility ( Return to Default Settings) sfc /revert
System File Checker Utility ( Purge File Cache ) sfc /purgecache
System File Checker Utility ( Set Cache Size to Size x ) sfc /cachesize=x
System Information msinfo32
System Properties sysdm.cpl

Task Manager taskmgr
TCP Tester tcptest
Telnet Client telnet
Tweak UI ( if installed ) tweakui

User Account Management nusrmgr.cpl
Utility Manager utilman

Volume Serial Number for C: label
Volume Control sndvol32

Windows Address Book wab
Windows Address Book Import Utility wabmig
Windows Backup Utility ( if installed ) ntbackup
Windows Explorer explorer
Windows Firewall firewall.cpl
Windows Installer Details msiexec
Windows Magnifier magnify
Windows Management Infrastructure wmimgmt.msc
Windows Media Player wmplayer
Windows Messenger msnsgs
Windows Picture Import Wizard (Need camera connected) wiaacmgr
Windows System Security Tool syskey
Windows Script host settings wscript
Widnows Update Launches wupdmgr
Windows Version ( shows your windows version ) winver
Windows XP Tour Wizard tourstart
Wordpad write

Zoom Utility igfxzoom

Java History

JDK 1.0

Codename Oak. Initial release

JDK 1.1

Major additions included:

J2SE 1.2

Codename Playground.

J2SE 1.3

Codename Kestrel. The most notable changes were:

J2SE 1.4

Codename Merlin. This was the first release of the Java platform developed under the Java Community Process as JSR 59. Major changes included:

J2SE 5.0

Codename Tiger. (Originally numbered 1.5, which is still used as the internal version number.) Developed under JSR 176, Tiger added a number of significant new language features:

  • Generics: Provides compile-time (static) type safety for collections and eliminates the need for most typecasts (type conversion). (Specified by JSR 14.)
  • Metadata: Also called annotations; allows language constructs such as classes and methods to be tagged with additional data, which can then be processed by metadata-aware utilities. (Specified by JSR 175.)
  • Autoboxing/unboxing: Automatic conversions between primitive types (such as int) and primitive wrapper classes (such as Integer). (Specified by JSR 201.)
  • Enumerations: The enum keyword creates a typesafe, ordered list of values (such as Day.MONDAY, Day.TUESDAY, etc.). Previously this could only be achieved by non-typesafe constant integers or manually constructed classes (typesafe enum pattern). (Specified by JSR 201.)
  • Swing: New skinnable look and feel, called synth.
  • Varargs: The last parameter of a method can now be declared using a type name followed by three dots (e.g. void drawtext(String... lines)). In the calling code any number of parameters of that type can be used and they are then placed in an array to be passed to the method, or alternatively the calling code can pass an array of that type.
  • Enhanced for each loop: The for loop syntax is extended with special syntax for iterating over each member of either an array or any Iterable, such as the standard Collection classes, using a construct of the form:
            void displayWidgets (Iterable<Widget> widgets) {
for (Widget w: widgets) {

This example iterates over the Iterable object widgets, assigning each of its items in turn to the variable w, and then calling the Widget method display() for each item. (Specified by JSR 201.)

  • Fix the previously broken semantics of the Java Memory Model, which defines how threads interact through memory.
  • Automatic stub generation for RMI objects.
  • static imports
  • 1.5.0_18 (5u18) is the last release of Java to officially support the Microsoft Windows 9x line (Windows 95, Windows 98, Windows ME). Unofficially, Java SE 6 Update 7 ( is the last version of Java to be shown working on this family of operating systems.
  • The concurrency utilities in package java.util.concurrent.
  • Scanner class for parsing data from various input streams and buffers.

J2SE 5.0 entered its end-of-life on April 8, 2008 and will be unsupported by Sun as of October 30, 2009.

Java SE 6

Codename Mustang. As of this version, Sun replaced the name "J2SE" with Java SE and dropped the ".0" from the version number. Internal numbering for developers remains 1.6.0. This version was developed under JSR 270.

During the development phase, new builds including enhancements and bug fixes were released approximately weekly. Beta versions were released in February and June 2006, leading up to a final release that occurred on December 11, 2006. The current revision is Update 16 which was released in August 2009.

Major changes included in this version:

  • Support for older Win9x versions dropped. Unofficially Java 6 Update 7 is the last release of Java shown to work on these versions of Windows. This is believed to be due to the major changes in Update 10.
  • Scripting Language Support (JSR 223): Generic API for tight integration with scripting languages, and built-in Mozilla Javascript Rhino integration
  • Dramatic performance improvements for the core platform, and Swing.
  • Improved Web Service support through JAX-WS (JSR 224)
  • JDBC 4.0 support (JSR 221).
  • Java Compiler API (JSR 199): an API allowing a Java program to select and invoke a Java Compiler programmatically.
  • Upgrade of JAXB to version 2.0: Including integration of a StAX parser.
  • Support for pluggable annotations (JSR 269)
  • Many GUI improvements, such as integration of SwingWorker in the API, table sorting and filtering, and true Swing double-buffering (eliminating the gray-area effect).

Java SE 6 Update 10

Java SE 6 Update 10 (previously known as Java SE 6 Update N), while it does not change any public API, is meant as a major enhancement in terms of end-user usability. The release version is currently available for download.

Major changes for this update include:

  • Java Deployment Toolkit, a set of JavaScript functions to ease the deployment of applets and Java Web Start applications.
  • Java Kernel, a small installer including only the most commonly used JRE classes. Other packages are downloaded when needed.
  • Enhanced updater.
  • Enhanced versioning and pack200 support: server-side support is no longer required.
  • Java Quick Starter, to improve cold start-up time.
  • Improved performance of Java2D graphics primitives on Windows, using Direct3D and hardware acceleration.
  • A new Swing look and feel called Nimbus and based on synth.
  • Next-Generation Java Plug-In: applets now run in a separate process and support many features of Web Start applications.

Java SE 6 Update 12

This release includes the highly anticipated 64-bit Java Plug-In (for 64-bit browsers only), Windows Server 2008 support, and performance improvements of Java and JavaFX applications

Java SE 6 Update 14

Java SE 6 Update 14 (6u14) was released as of May 28, 2009.

This release includes extensive performance updates to the HotSpot JIT compiler, compressed pointers for 64-bit machines, as well as support for the G1 (Garbage First) low pause garbage collector.

Some developers have noticed an issue introduced in this release which causes debuggers to miss breakpoints seemingly randomly. Sun has a corresponding bug, which is tracking the issue. The workaround applies to the Client and Server VMs. Using the -XX:+UseParallelGC option will prevent the failure. Another workaround is to roll back to update 13.

Java SE 6 Update 16

As of August 11, 2009, Java SE 6 Update 16 is available, fixing the issue which caused debuggers to miss breakpoints introduced in update 14.

Java SE 7

Java 7 (codename Dolphin) is the next version of Java, currently in the planning and development stages. The Dolphin Project began in August 2006 and is tentatively scheduled for release in 2010. New builds including enhancements and bug fixes are released approximately weekly.

New features that may be integrated in Java 7 include:

  • JVM support for dynamic languages, following the prototyping work currently done on the Multi Language Virtual Machine,
  • A new library for parallel computing on Multi-core processors,
  • Superpackages (JSR 294), which are a way to define explicitly in a library or module which classes will be visible from outside of the library,
  • Swing Application Framework, an infrastructure common to most desktop applications, making Swing applications easier to create.
  • Replacing the existing concurrent low-pause garbage collector (also called CMS or Concurrent Mark-Sweep collector) with the G1 garbage collector.
  • Various small language changes, grouped in a project called Project Coin. These changes are still evaluated but could include: Strings in switch, more concise calls to constructors with type parameters, or multi-catch in exceptions.

Eclipse Debugging Shortcuts

F5 Step into
F6 Step over
F7 Run to return
F8 Resume
F9 Relaunch last
F11 Run/debug last
Ctrl F11 Run
Ctrl Shift B Toggle breakpoint
Ctrl D Display
Ctrl Q Inspect
Ctrl R Run to line
Ctrl U Run snippet

Some of the Sayings.....I like

“A clever person solves a problem. A wise person avoids it. -- Einstein”

How to improve your skills as a good programmer

Today I thought of finding what qualities made me a good programmer... So started googling and I got an interesting article in wikiHow. and it tells us how to improve our skills as a good programmer. I thought it will be useful for everyone who wants to be a good programmer.

  1. Gather complete requirements.
    Take the time to write down what the end product needs to achieve. Clarity of thought at this stage will save a lot of time down the line.
  2. Write an implementation plan (or model).
    • For something small and self-contained, this might just be a basic flowchart or an equation.
    • For larger projects, it helps to break it into modules and consider what job each module must do, how data gets passed between modules, and within each module how it will function.
    • Although it is fun to dive straight into code, it is equally tedious to spend hours debugging. By taking the time to design the structure on paper, you will drastically reduce your debugging time (and you may also spot more efficient ways of doing things even before you write the first line of code).
  3. Add Comments to your code.
    Whenever you feel your code needs some explanation, drop some comments in. Each function should be preceded by 1-2 lines describing the arguments and what it returns. (Comments should tell you why more often than what. Remember to update the comments when you update your code!)
  4. Use naming conventions for variables.
    It will help you keep track of what type the variable is and also what it's purpose is. Although this means more typing than x = a + b * c, it will make your code easier to debug and maintain. One popular convention is Hungarian notation where the variable name is prefixed with its type. e.g. for integer variables, intRowCounter; strings: strUserName. It doesn't matter what your naming convention is, but be sure that it is consistent and that your variable names are descriptive. (See Warnings below)
  5. Organize your code.
    Use visual structure to indicate code struture. i.e. indent a code block that sits within a conditional (if,else,...) or a loop (for,while,...) Also try putting spaces between a variable name and an operator such as addition, subtraction, multiplication, division, and even the equal sign (myVariable = 2 + 2). As well as making the code more visually elegant, it makes it much easier to see the program flow at a glance. (See tips on indentation below)
  6. Test.
    Start by testing it with inputs that you would typically expect. Then try inputs that are possible but less common. This will flush out any hidden bugs. There is an art to testing and you will gradually build up your skills with practice.
    Write your tests to always include the following:
    • Extremes: zero and max for positive values, empty string, null for every parameter.
    • Meaningless values, Jibberish. Even if you don't think someone with half a brain might input that, test your software against it.
    • Wrong values. Zero in a parameter that will be used in a division, negative when positive is expected or a square root will be calculated. Something that is not a number when the input type is a string, and it will be parsed for numeric value.
  7. Practice. Practice. Practice.
  8. Be prepared for change.
    In a realistic working environment, requirements change. However, the clearer you are at the start about the requirements and the clearer your implementation plan, the less likely those changes will be down to misunderstanding or "Ah, I hadn't thought of that" scenarios.
    • You can take an active role in improving clarity of thinking by presenting your requirements document or your implementation plans before coding to ensure that what you are planning to create is actually what's been asked for.
    • Structure the project as a series of milestones with a demo for each block. Approach the programming one milestone at a time - the less you need to think about at any moment, the more likely you will think clearly.
  9. Start simple and work towards complexity.
    When programming something complex, it helps to get the simpler building blocks in place and working properly first.
    For example, let's say you want to create an evolving shape on screen that follows the mouse and where the degree of shape change depends on mouse speed.
    • Start by displaying a square and get it to follow the mouse, i.e. solve movement tracking on its own.
    • Then make the size of the square relate to mouse speed, i.e. solve speed-to-evolution tracking on its own.
    • Finally create the actual shapes you want to work with and put the three components together.
    • This approach naturally lends itself to modular code writing, where each component is in its own self-contained block. This is very useful for code reuse (e.g. you want to just use the mouse tracking in a new project), and makes for easier debugging and maintenance.
  • Start small, aim for things that you most likely will be able to achieve, and work your way up.
  • Tutorial sites are an excellent resource as well.
  • Reading the work of others (source code) is an excellent means of improving ones skills. Better still, work your way through their code by eye, working out the flow and what happens to the variables. Then try to write your own code to do the same thing (or maybe even improve on it). You'll quickly learn why things need to be written a certain way and you'll pick up some useful tips on how to write efficiently.
  • Talk to other programmers. People can often be a good resource for information, particularly when starting out. Find out whether there's a group of programmers who meet up locally.
  • Have fellow programmers read your code. You would be surprised what they know that you may have never thought of before!
    Don't know any professional programmers? Find an online forum that's dedicated to your chosen programming language / operating system.
    • If you go down this route, read and observe the forum etiquette. There are lots of good hearted experts willing to help out... if asked the right way.
    • Remember to be polite because you're asking for a favour, don't get frustrated if you don't understand everything at once, and also don't expect them to want to review 10,000 lines of code. Instead ask simple, single-focus questions and post just the relevant 5-10 lines of code that it relates to. That way you're most likely to get a positive response.
    • But before you start posting, do a search - your question has almost certainly been encountered and solved already.
  • Keep your past work, it is a good point of reference.
  • Keep your code visually elegant, not because it's pretty but because it makes it easier to read... essential when you come to make a change in 6 months' time. This means using TAB indentation to differentiate lines of code that are encapsulated (if, for, while, etc...). Read more about code indenting.
  • Find an editor that uses colour-coded syntax-highlighting. It really helps to separate comments from keywords from numbers from strings, etc. (Better still, use an IDE. See below.)
  • Double check spelling/syntax. A slight mistake can cause a lot of stress.
  • Use a debugger tool. Instead of placing statements in your code to output variable values or "Got here", a debugger tool will let you step through your code line by line so that you can see where it's going wrong.
  • Change one thing at a time when debugging and then test your corrections before moving on the next item.
  • Separating (packaging) your reusable code from your application-specific code will over time lead to a large, debugged, reusable (without copy/paste) library full of handy utilities. This will aid in writing more powerful and stable applications in less time as your library grows.[1]
  • After each bigger segment of work, take a break doing something else, then review what you have written with a fresh mind; rethink and rewrite it, making it more effective and elegant by using less code. Repeat until perfect.
  • A program such as Visual Basic .Net can cost a lot of money to purchase and upgrade, and it's syntax style is very different than most other languages. If you MUST use visual basic, go out and download Visual Studio Express Beta 2 2005 from or you may buy the student or learning editions.
    Remember programming languages like Java, PHP, Python and Ruby, available at no cost. Also, if you want to (must) use a Microsoft but not Visual Basic, there are free open source IDEs for C#, whose syntax resembles Java, etc.
  • Use an IDE (Integrated Development Environment). A good IDE will have a colour-coded editor built it, with code hints and code completion that make editing faster and less prone to spelling mistakes. It will usually have a debugger built in too.
  • Use version control management. Tools like CVS or SVN make it even easier to track code changes and bugs. Once you get used to it you won't look back.
  • Customers and bosses aren't concerned with how your program works nearly so much as they are with how well it works. Think bottom line. Clients are intelligent, but busy. They won't care what kind of data structures you're using, but they will care if it speeds up performance by 10%.
  • Save your work frequently as you go along or you risk losing hours and hours of work to a computer crash or lock-up. If you ignore this warning now, it's a lesson you will learn the hard way!
  • In step 4, Hungarian notation (indicating a variable's type as a prefix) should be used with caution. It can lead to inconsistency when edited, or particularly if ported to another language / operating system. It is of most use in 'loosely typed' languages, that don't require you to pre-declare the type of a variable.
  • Copying and pasting others' code is a bad habit, especially if you weren't supposed to see the source. But all things considered, taking small portions from an open source program could be a learning experience. Just don't completely copy a program and attempt to take credit for it.
  • Always test your code
  • Don't copy code from another program unless you have permission or the license permits it, like Open Source licenses.
  • Make regular backups of your application code onto another hard drive or portable device, that way you will have a copy if your computer dies or becomes unavailable - remember to keep the copy in a secure place.
Things You'll Need
  • Ideas
  • IDE (Integrated Development Environment)
  • Computer
  • Reference books or web tutorials


Sunday, July 12, 2009

Good Sites for Effective Business Communication

Hi Friends..,

Today I thought to improve my business communication.. So I have gone through some of the sites which I found interesting...I also find it useful for u if I share with u!!

Saturday, July 4, 2009

Blogging...for the first time

Hey Guys..

Like many other guys i also thought of blogging so that i can reach many people. But no idea about what to completely disguised.....then I thought of blogging on issues like social importance, technology (Obviously because am a software professional.....can't stop myself from typing in something about technology.So....), etc...