Unique But United - Students with great minds

first time use this blog

2011-06-30T14:11:00.001+05:30

hai

first time use this blog

2011-06-30T14:11:00.000+05:30

hai

What is the "Chief Executive Officer"?

2009-06-28T15:31:00.001+05:30

A "Definition"

The definition of "chief executive officer" (almost always) depends on whether a business is a corporation or not, that is, whether it (usually) has a board of directors or not. In an organization that has a board of directors, the "chief executive officer" is (usually) the singular organizational position that is primarily responsible to carry out the strategic plans and policies as established by the board of directors. In this case, the chief executive reports to the board of directors. In a form of business that is usually without a board of directors (sole proprietorship, partnership, etc.), the "chief executive officer" is (usually) the singular organizational position (other than partnerships, etc.) that sets the direction and oversees the operations of an organization.

Major Roles of the Position of Chief Executive Officer

LEADER
· Advises the Board
· Advocates / promotes organization and stakeholder change related to organization mission
· Supports motivation of employees in organization products/programs and operations

VISIONARY / INFORMATION BEARER
· Ensures staff and Board have sufficient and up-to-date information
· Looks to the future for change opportunities
· Interfaces between Board and employees
· Interfaces between organization and community

DECISION MAKER
· Formulates policies and planning recommendations to the Board
· Decides or guides courses of action in operations by staff

MANAGER
· Oversees operations of organization
· Implements plans
· Manages human resources of organization
· Manages financial and physical resources

BOARD DEVELOPER
· Assists in the selection and evaluation of board members
· Makes recommendations, supports Board during orientation and self-evaluation
· Supports Board's evaluation of Chief Executive

WHY EMPLOYEES LEAVE ORGANISATIONS? - Azim Premji, CEO- Wipro

2009-06-28T15:28:00.001+05:30

Every company faces the problem of people leaving the company for better pay or profile.

Early this year, Mark, a senior software designer, got an offer from a prestigious international firm to work in its India operations developing specialized software. He was thrilled by the offer.

He had heard a lot about the CEO. The salary was great. The company had all the right systems in place employee-friendly human resources (HR) policies, a spanking new office, and the very best technology, even a canteen that served superb food.

Twice Mark was sent abroad for training. "My learning curve is the sharpest it's ever been," he said soon after he joined.

Last week, less than eight months after he joined, Mark walked out of the job.

Why did this talented employee leave?

The answer lies in one of the largest studies undertaken by the Gallup Organization. The study surveyed over a million employees and 80,000 managers and was published in a book called "First Break All The Rules". It came up with this surprising finding:

If you're losing good people, look to their manager .... manager is the reason people stay and thrive in an organization. And he 's the reason why people leave. When people leave they take knowledge, experience and contacts with them, straight to the competition.

"People leave managers not companies," write the authors Marcus Buckingham and Curt Coffman.

Mostly manager drives people away?

HR experts say that of all the abuses, employees find humiliation the most intolerable. The first time, an employee may not leave, but a thought has been planted. The second time their thought gets strengthened. The third time, he looks for another job.

When people cannot retort openly in anger, they do so by passive aggression. By digging their heels in and slowing down. By doing only what they are told to do and no more. By omitting to give the boss crucial information. Dev says: "If you work for a jerk, you basically want to get him into trouble. You don 't have your heart and soul in the job."

Different managers can stress out employees in different ways - by being too controlling, too suspicious, too pushy, too critical, but they forget that workers are not fixed assets, they are free agents. When this goes on too long, an employee will quit - often over a trivial issue.

Talented men leave. Dead wood doesn't

Hands-on with Fujitsu's teeny tiny laptop

2009-06-28T15:16:00.003+05:30

Fujitsu's new ultra tiny laptop is LifeBook U810.

The U810 is a hybrid between an ultraportable convertible tablet and a UMPC (that's ultramobile PC). We've always liked UMPCs in theory, but these pocket-sized systems, including the OQO model 02 and Sony VAIO UX390, were more like suped-up smart phones than actual computers. There's only so productive you can be on a BlackBerry-style thumb keyboard.

The new LifeBook U810 takes a different approach, mimicking a traditional laptop's form factor, shrunk down to a 5.6-inch swiveling touchscreen, along with a fairly full-featured keyboard, fingerprint reader, Bluetooth, and Wi-Fi (but no EVDO yet). It runs Intel's A110 CPU and had 1GB of RAM and Vista Premium.

The street date for this $999 mini-laptop is Sept. 18, so look for a full review then, but be forewarned: We're holding the black-and-white European version in this photo. The U.S. version is only going to be available with an all-black design. Apparently some focus group types decided that white gadgets aren't hot anymore in the American market (come to think of it, even the iPhone and new iPod Touch are black--maybe there's something to this).

An Interview with Bjarne Stroustrup

2008-05-02T22:36:00.001+05:30

C++ creator Bjarne Stroustrup discusses the evolving C++0x standard, the education of programmers, and the future of programming.

By James Buchanan, Dr. Dobb's Journal

Mar 27, 2008

URL:http://www.ddj.com/cpp/207000124

JB: When did you first become interested in computing, what was your first computer and what was the first program you wrote?

BS: I learned programming in my second year of university. I was signed up to do "mathematics with computers science" from the start, but I don't really remember why. I suspect that I (erroneously) thought that computing was some sort of applied math.

My fist computer was the departmental GIER computer. It was almost exclusively programmed in Algol-60. My first semi-real program plotted lines (on paper!) between points on the edge of a superellipse to create pleasant graphical designs. That was in 1970.

JB: When you created C++, was the object oriented programming (OOP) paradigm (or programming style) obviously going to gain a lot of popularity in the future, or was it a research project to find out if OOP would catch on?

BS: Neither! My firm impression (at the time) was that all sensible people "knew" that OOP didn't work in the real world: It was too slow (by more than an order of magnitude), far too difficult for programmers to use, didn't apply to real-world problems, and couldn't interact with all the rest of the code needed in a system. Actually, I'm probably being too optimistic here: "sensible people" had never heard of OOP and didn't want to hear about it.

I designed and implemented C++ because I had some problems for which it was the right solution: I needed C-style access to hardware and Simula-style program organization. It turned out that many of my colleagues had similar needs. Actually, then it was not even obvious that C would succeed. At the time, C was gaining a following, but many people still considered serious systems programming in anything but assembler adventurous and there were several languages that—like C—provided a way of writing portable systems programs. One of those others might have become dominant instead of C.

JB: Before C++, did you "just have to create C++" because of the inadequacy of other languages, for example? In essence, why did you create C++?

BS: Yes, I created C++ in response to a real need: The languages at the time didn't support abstraction for hard systems programming tasks in the way I needed it. I was trying to separate the functions of the Unix kernel so that they could run on different processors of a multi-processor or a cluster.

JB: Personally, do you think OOP is the best programming paradigm for large scale software systems, as opposed to literate programming, functional programming, procedural programming, etc.? Why?

BS: No programming paradigm is best for everything. What you have is a problem and a solution to it; then, you try to map that solution into code for execution. You do that with resource constraints and concerns for maintainability. Sometimes, that mapping is best done with OOP, sometimes with generic programming, sometimes with functional programming, etc.

OOP is appropriate where you can organize some key concepts into a hierarchy and manipulate the resulting classes through common base classes. Please note that I equate OO with the traditional use of encapsulation, inheritance, and (run time) polymorphism. You can choose alternative definitions, but this one is well-founded in history.

I don't think that literate programming is a paradigm like the others you mention. It is more of a development method like test-driven development.

C++0x

JB: In your paper, "The Design of C++0x" published in the May 2005 issue of the C/C++ User's Journal, you note that "C++'s emphasis on general features (notably classes) has been its main strength." In that paper you also mention the most change and new features will be in the Standard Library. A lot of people would like to see regular expressions, threads and the like, for example. Could you give us an idea of new classes or facilities that we can expect to see in C++0x's Standard Library?

BS: The progress on standard libraries has not been what I hoped for. We will get regular expressions, hash tables, threads, many improvements to the existing containers and algorithms, and a few more minor facilities. We will not get the networking library, the date and time library, or the file system library. These will wait until a second library TR. I had hoped for much more, but the committee has so few resources and absolutely no funding for library development.

JB: Have you or others working on C++0x had a lot of genuinely good ideas for new classes or facilities? If so, will all of them be used or will some have to be left out because of time and other constraints on developing a new standard? If that is the case, what would most likely be left out?

BS: There is no shortage of good ideas in the committee or of good libraries in the wider C++ community. There are, however, severe limits to what a group of volunteers working without funding can do. What I expect to miss most will be thread pools and the file system library. However, please note that the work will proceed beyond '09 and that many libraries are already available; for example see what boost.org has to offer.

JB: When would you expect the C++0x Standard to be published?

BS:The standard will be finished in late 2008, but it takes forever to go through all the hoops of the ISO process. So, we must face the reality that "C++0x" may become C++10.

JB: Concurrent programming is obviously going to become important in the future, because of multi-core processors and kernels that get better at distributing processes among them. Do you expect C++0x will address this, and if so, how?

BS: The new memory model and a task library was voted into C++0x in Kona. That provides a firm basis for share-memory multiprocessing as is essential for multicores. Unfortunately, it does not address higher-level models for concurrency such as thread pools and futures, shared memory parallel programming, or distributed memory parallel processing. Thread pools and futures are scheduled for something that's likely to be C++13. Shared memory can be had using Intel's Threading Building Blocks and distributed memory parallel processing is addresses by STAPL from Texas A&M University and other research systems. The important thing here is that given the well-defined and portable platform provided by the C++0x memory model and threads, many higher-level models can be provided.

Distributed programming isn't addressed, but there is a networking library scheduled for a technical report. That library is already in serious commercial use and its public domain implementation is available from boost.org.

Educating the Next Generation

JB: Do you think programmers should be "armed and dangerous" with their tools like compilers, editors, debuggers, linkers, version control systems and so on very early on in their learning or careers? Do you think that universities should teach debugging and how to program in a certain environment (e.g. Unix) as well, for example?

BS: I'm not 100% sure I understand the question, but I think "yes." I don't think that it should be possible to graduate with a computer science, computer engineering, etc. degree without having used the basic tools you mention above for a couple of major projects. However, it is possible. In some famous universities, I have observed that Computer Science is the only degree you can get without writing a program.

I'm not arguing for mere training. The use of tools must not be a substitute for a good understanding of the principles of programming. Someone who knows all the power-tools well, but not the fundamental principles of software development would indeed be "armed and dangerous." Let me point to algorithms, data structures, and machine architecture as essentials. I'd also like to see a good understanding of operating systems and networking.

Some educators will point out that all of that—together with ever-popular and useful topics such as graphics and security—doesn't fit into a four-year program for most students. Something will have to give! I agree, but I think what should give is the idea that four years is enough to produce a well-rounded software developer: Let's aim to make a five-or-six-year masters the first degree considered sufficient.

JB: What should C++ programmers or any programmer do, in your view, before sitting down to write a substantial software program?

BS: Think. Discuss with colleagues and potential users. Get a good first-order understanding of the problem domain. If possible, try to be a user of an existing system in that field. Then, without too much further agonizing, try to build a simplified system to try out the fundamental ideas of a design. That "simplified system" might become a throwaway experiment or it may become the nucleus of a complete system. I'm a great fan of the idea of "growing" a system from simpler, less complete, but working and tested systems. To try out all the tool chains before making too grand plans.

How would the programmer, designer, team get those "fundamental ideas of a design"? Experience, knowledge of similar systems, of tools, and of libraries is a major part of the answer. The idea of a single developer carefully planning to write a system from the bare programming language has realistically been a myth for decades. David Wheeler wrote the first paper about how to design libraries in 1951—56 years ago!

JB: What type of programs do you personally enjoy writing? What programs have you written recently?

BS: These days I don't get enough time to write code, but I think writing libraries is the most fun. I wrote a small library supporting N-dimensional arrays with the usual mathematical operations. I have also been playing with regular expressions using the (draft) C++0x library (the boost.org version).

I also write a lot of little programs to test aspects of the language, but that's more work than fun, and also small programs to explore application domains that I haven't tried or haven't tried lately. It is a rare week that I don't write some code.

JB: In your experience, have there been any features of C++ that newcomers to the language have had the most difficulty with? Would you have any advice for newcomers to C++ or have you found a way of teaching difficult features of C++ saving students a lot of trial and error?

BS: Some trial and error is inevitable, and may even be good for the newcomer, but yes I have some experience introducing C++ to individuals and organizations—some of it successful. I don't think it's the features that are hard to learn, it is the understanding of the programming paradigms that cause trouble. I'm continuously amazed at how novices (of all backgrounds and experiences) come to C++ with fully formed and firm ideas of how the language should be used. For example, some come convinced that any techniques not easily used in C is inherently wrongheaded, hard to use, and very inefficient. It's amazing what people are willing to firmly assert without measurements and often based on briefly looking at C++ a decade ago using a compiler that was hardly out of beta—or simply based on other people's assertions without checking if they have a basis in reality. Conversely, there is now a generation who is firmly convinced that a program is only well-designed if just about everything is part of a class hierarchy and just about every decision is delayed to run-time. Obviously programs written by these "true OO" programmers become the best arguments for the "stick to C" programmers. Eventually, a "true OO" programmer will find that C++ has many features that don't serve their needs and that they indeed fail to gain that fabled efficiency.

To use C++ well, you have to use a mix of techniques; to learn C++ without undue pain and unnecessary effort, you must see how the language features serve the programming styles (the programming paradigms). Try to see concepts of an application as classes. It's not really hard when you don't worry too much about class hierarchies, templates, etc. until you have to.

Learn to use the language features to solve simple programs at first. That might sound trivial, but I receive many questions from people who have "studied C++" for a couple of weeks and are seriously confused by examples of multiple inheritance using names like B1, B2, D, D2, f, and mf. They are—usually without knowing it—trying to become language lawyers rather than programmers. I don't need multiple inheritance all that often, and certainly not the tricky parts. It is far more important to get a feel for writing a good constructor to establish an invariant and understand when to define a destructor and copy operations. My point is that the latter is almost instantly useful and not difficult (I can teach it to someone who has never programmed after a month). The finer details of inheritance and templates, on the other hand, are almost impenetrable until you have a real-world program that needs it. In The Art of Computer Programming Don Knuth apologizes for not giving good examples of co-routines, because their advantages are not obvious in small programs. Many C++ features are like that in that: They don't make sense until you face a problem of the kind and scale that needs that feature.

JB: Do you have any suggestions for people who are not programmers and want to learn how to program, and want to learn C++ as their first language? For instance, there's a book called Accelerated C++: Practical Programming by Example by Andrew Koenig and Barbara E. Moo. This book's approach is to teach by using the STL and advanced features at an early stage, like using strings, vectors and so on, with the aim of writing "real" programs faster. Would you agree that it's best to begin "the C++ way" if you could call it that, instead of starting off with a strictly procedural style and leaving classes, the Standard Library and other features often preceded with "an introduction to OOP" much later in a book?

BS: I have had to consider this question "for real" and have had the opportunity to observe the effects of my theories. I designed and repeatedly taught a freshman programming course at Texas A&M University. I use standard library features, such as string, vector, and sort, from the first week. I don't emphasize STL; I just use the facilities to have better types with which to introduce the usual control structures and programming techniques. I emphasize correctness and error handling from day 1. I show how to build a couple of simple types in lecture 6 (week three). I show much of the mechanisms for defining classes in lectures 8 and 9 together with the ways of using them. By lecture 10 and 11, I have the students using iostreams on files. By then, they are tired, but can read a file of structured temperature data and extract information from it. They can do it 6 weeks after seeing their first line of code. I emphasize the use of classes as a way of structuring code to make it easier to get right.

After that comes graphics, including some use of class hierarchies, and then comes the STL. Yes, you can do that with complete beginners in a semester. We have by now done that for more than 1,000 students. The reason for putting the STL after graphics is purely pedagogical: after iostreams the students are thoroughly tired of "calculations and CS stuff," but doing graphics is a treat! The fact that they need the basics of OOP to do that graphics is a minor detail. They can now graph the data read and fill class objects from a GUI interface.

JB: I read an interview in Texas A&M Engineering Magazine where you said, "I decided to design a first programming course after seeing how many computer science students—including students from top schools—lacked fundamental skills needed to design and implement quality software..." What were these fundamental skills students lacked, and what did you put in your programming course to address this issue?

BS: I saw so many students who simply didn't have the notion that code itself is a topic of interest and that well-structured code is a major time saver. The notion of organizing code to be sure that it is correct and maybe even for someone else to use and modify is alien: They see code as simply something needed to hand in the answers to an exercise. I am of course not talking about all students or just students from one university or from one country.

In my course I heavily emphasize structure, correctness, and define the purpose of the course as "becoming able to produce code good enough for the use of others." I use data structures and algorithms, but the topic of the course is "programming" not fiddling with pointers to implement a doubly linked list.

And yes, I do teach pointers, arrays, and casts, but not until well after strings, vectors, and class design. You need to give the students a feel of the machine as well as the mechanisms to make the (correct) use of the machine simple. This also reflects comments I have repeatedly had from industry: that they have a shortage of developers who understand "the machine" and "systems."

JB: You have said that a programmer must be able to think clearly, understand questions and express solutions. This is in agreement with G. Polya's thesis that you must have a clear and complete understanding of a question before you can ever hope to solve it. Would you recommend supplementary general reading like G. Polya's book, How to Solve It along with reading books on programming and technique? If so, what books would you recommend?

BS: I avoid teaching "how to think." I suspect that's best taught through lots of good examples. So I give lots of good examples (to set a standard) including examples of gradual development of a program from early imperfect versions. I'm not saying anything against Polya's ideas, but I don't have the room for it in my approach. The problem with designing a course (or a curriculum) is more what to leave out than what to add.

JB: What are the most useful mathematical skills, generally, that a programmer should have an understanding of if they intend to become professional, in your view? Or would there be different mathematical skills a programmer should know for different programmers and different tasks? If this is the case could you give examples?

BS: I don't know. I think of math as a splendid way to learn to think straight. Exactly what math to learn and exactly where what kinds of math can be applied is secondary to me.

The Future of C++

JB: Your research group is looking into parallel and distributed systems. From this research, have any new ideas for the new C++0x standard come about?

BS: Not yet. The gap between a research result and a tool that can be part of an international standard is enormous. Together with Gabriel Dos Reis at TAMU, I have worked on the representation of C++ aiming at better program analysis and transformation (eventually to be applied to distributed system code). That will become important some day. A couple of my grad students analyzed the old problem of multi-methods (calling a function selected based on two or more dynamic types) and found a solution that can be integrated into C++ and performs better in time and space than any workaround. Together with Tom Gibbs from Lockheed-Martin, I developed a fast, constant-time, dynamic cast implementation. This work points to a future beyond C++0x.

JB: You have some thoughts on how programming can be improved, generally. What are they?

BS: There is immense scope for improvement. A better education is a start. I think that theory and practice have become dissociated in many cases, with predictably poor results. However, we should not fool ourselves into seeing education and/or training as a panacea. There are on the order of 10 million programmers "out there" and little agreement on how to improve education. In the early days of C++, I worried a lot about "not being able to teach teachers fast enough." I had reason to worry because much of the obvious poor use of C++ can be traced to fundamental misunderstandings among educators. I obviously failed to articulate my ideals and principles sufficiently. Given that the problems are not restricted to C++, I'm not alone in that. As far as I can see, every large programming community suffers, so the problem is one of scale.

"Better programming languages" is one popular answer, but with a new language you start by spending the better part of a decade to rebuild existing infrastructure and community, and the advance comes at the cost of existing languages: At least some of the energy and resources spent for the new language would have been spent on improving old ones.

There are so many other areas where significant improvements are possible: IDEs, libraries, design methods, domain specific languages, etc. However, to succeed, we must not lose sight of programming. We must remember that the aim is to produce working, correct, and well-performing code. That may sound trite, but I am continuously shocked over how little code is discussed and presented at some conferences that claim to be concerned with software development.

JB: An area of interest for you is multi-paradigm (or multiple-style) programming. Could you explain what this is for you, what you have been doing with multi-paradigm programming lately and do you have any examples of the usefulness of multi-paradigm programming?

BS: Almost all that I do in C++ is "multi-paradigm." I really have to find a better name for that, but consider: I invariably use containers (preferably standard library (STL) containers); they are parameterized on types and supported by algorithms. That's generic programming. On the other hand, I can't remember when I last wrote a significant program without some class hierarchies. That's object-oriented programming. Put pointers to base classes in containers and you have a mixture of GP and OOP that is simpler, less error prone, more flexible, and more efficient than what could be done exclusively in GP or exclusively in OOP. I also tend to use a lot of little free-standing types, such as Color and Point. That's basic data abstraction and such types are of course used in class hierarchies and in containers.

JB: You are looking at making C++ better for systems programming in C++0x as I understand it, is that correct? If so, what general facilities or features are you thinking about for making C++ a great systems language?

BS: Correct. The most direct answer involves features that directly support systems programming, such as thread local storage and atomic types. However, the more significant part is improvements to the abstraction mechanism that will allow cleaner code for higher-level operations and better organization of code without time or space overheads compared to low-level code. A simple example of that is generalized constant expressions that allows compile-time evaluate of functions and guaranteed compile-time initialization of memory. An obvious use of that is to put objects in ROM. C++0x also offers a fair number of "small features" that without adding to run-time costs make the language better for writing demanding code, such as static assertions, rvalue references (for more efficient argument passing) and improved enumerations.

Finally, C++0x will provide better support for generic programming and since generic programming using templates has become key to high performance libraries, this will help systems programming also. For example, here we find concepts (a type system for types and combinations of types) to improve static checking of template code.

JB: You feel strongly about better education for software developers. Would you say, generally, that education in computer programming is appalling? Or so-so? If you were to design a course for high school students and a course (an entire degree) for university students intending to become professional, what would you include in these courses and what would you emphasize?

BS: Actually, I just took part in an effort to do that for the four undergraduate years. Unfortunately, the descriptions you find of our program on the web is still a mix of new and old stuff—real-world programs can only be put in place in stages. The idea is to give the students a broad view of computer science during the first two years ("making them ready for their first internship or project") and then using the next two years to go into depth in some selected areas. During the first two years, the students get a fairly classical CS program with a slightly higher component of software development projects than is common. They have courses in hardware and software (using C++), there is some discrete math, algorithms and data structures, (operating and network) systems, programming languages, and a "programming studio" exposing them to group projects and some project management.

JB: In an ideal world for you, what will C++0x be in terms of all the goodies in the new Standard Library and language?

BS: Unfortunately, we don't live in an ideal world and C++0x won't get all the "goodies" I'd like and probably a fewer "minor" features than I would have liked. Fortunately, the committee has decided to try for more and smaller increments. For example, C++0x (whether that'll be C++09 or C++10) will have only the preparations for programmer-controlled garbage collection and lightweight concurrency, whereas we hope for the full-blown facilities in C++12 (or C++13).

I do—based on existing work and votes—expect to get:

Libraries
- Threads
- Regular expressions
- Hash tables
- Smart pointers
- Many improvements for containers
- Quite a bit support for new libraries
Language
- A memory model supporting modern machine architectures
- Thread local storage
- Atomic types
- Rvalue references
- Static assertions
- Template aliases
- Variadic templates
- Strongly typed enums
- constexpr: Generalized constant expressions
- Control of alignment
- Delegating constructors
- Inheriting constructors
- auto: Deducing variable types from initializers
- Control of defaults
- nullptr: A name for the null pointer
- initializer lists and uniform initialization syntax and semantics
- concepts (a type system for template arguments)
- a range-based for loop
- raw string literals
- UTF8 literals
- Lambda functions

For a more detailed description of both my ideals, the work of the ISO C++ standards committee, and C++0x, see my HOPL-iii paper: "Evolving a language in and for the real world: C++ 1991-2006. ACM HOPL-III" from earlier this year. Also, see the ISO C++ committee's web site where you can find more details than you could possibly want (search for "WG21" and look for "papers").

BS: C++ is often used in embedded systems, including those where safety and security are top priorities. What are your favorite examples and why do you think C++ is an ideal language for embedded systems especially where safety is a concern, aside from easy low-level machine access?

BS: Yes, and I find many of those applications quite exciting. Too often people think of computing as "what runs on a PC with a single user in front of it." Obviously, my Bell Labs background biases me towards noticing the uses of software in cell phones, telecommunications devices, and systems in general. So much of our infrastructure is invisible and taken for granted! "The gadgets" we can see. That's one reason I like embedded systems programming. Another is the stringent demands on correctness (even with some hardware malfunction) and performance. In such software, there is a need for clear design and precise expression of ideas that can challenge a language.

Among my favorite examples are the modern wind-power generators and the huge diesel engines that power the largest container ships. We can't talk about invisibility here, but then people don't see those huge "structures" as containing computers running software that is critical to their correct, efficient, and economical performance. I have also seen some interesting uses of C++ in aerospace, notably the new "Joint Strike Fighter" (the F-35), but my favorite is the higher levels of the Mars Rover software (scene analysis and autonomous driving). The whole Rover project is really a stunning success. Both Rovers have outlived their promised design life by a factor of 6 and are (as I write this) still working their way across Mars looking, prodding, and sending home data. Again, the Rovers themselves are just the visible part of a huge complex system: just try to imagine what it takes to get the data back to earth and analyzed. Almost all of computer science and almost all of our engineering skills are involved here somewhere. The range of skilled people involved is really hard to imagine. Too often we forget the people.

I don't think there exists an "ideal language" for these kinds of systems, but C++ is a good one. Part of the reason is that any large system, such as a cell phone or a Rover depends on its huge hidden infrastructure. Obviously, you don't have to use a single language for everything, but there are enough overlaping parts of applications for C++'s flexibility, generality, and concern for performance to come into play. Many languages deemed simpler achieve their simplicity through limiting their range of applications or by making great demands on the underlying hardware and (software) execution environments.

JB: Would you say that the document JSF++: Joint Strike Fighter Air Vehicle Coding Standards that can be found under your C++ links, under the point "For a look at how ISO C++ can be used for serious embedded systems programming" is generally a good guide for any embedded systems programming, and perhaps for other things as well?

BS: Yes, that's a good guide for the kind of applications for which it was written. For those, I'm convinced that it's the best of its kind; I helped write it. It is very important to note, though, that with experience, we will find improvements and if applied to areas for which it was not intended, it could do harm. For example, the JSF++ prohibits the use of free store (dynamic store) and exceptions, whereas for general programming you typically need to use those features to get the best code. However, for high-reliability, hard-real time code, the simple fact that a new and a throw can't (in general) be guaranteed to execute on a short, fixed, constant time makes them a no-no. I also recommend the ISO C++ committee's Technical Report on performance, which can also be found on my C++ page. It is primarily aimed at embedded systems programming, but discusses issues rather than lay out rules. Please also note that the JSF++ document is about half rationale: people should not be asked to do things "just because we say so." At least we can try to explain the reasons behind the rules.

In general, I think it essential that a coding standard is tuned to a specific application, organization, or application area. Trying to "legislate morality" for all users is counter-productive.

JB: What do you enjoy doing in your spare time? Have you read any books or watched any films lately that you liked, and if yes, why?

Spare time? I like to run and to sightsee when I have a chance (usually when traveling for something work-related). Taking photographs is an excellent excuse for spending a bit of extra time in interesting places. Spending time with family is a high priority, and a pleasure, of course. I read non-technical books essentially every day. That's mostly light reading to relax. I recently re-read some of Raymond Chandler's novels; they age well. I also just finished Terry Jones and Alan Ereira's "Barbarians" about how the Romans really were the destructive villains of the ancient world; that's a refreshingly different perspective. I have always been fascinated by history. There are so many parts of history that nobody would have believed it if it wasn't real—after all fiction has to be probable. And then, of course, you can't read just one book about history; you need to read a lot to understand the context of events and to avoid being sold a biased fairy tale version of something. Before that, I read Richard Dawkin's "Climbing Mount Improbable"; I basically have to re-learn biology because just about everything is new since I left school. Curiously, I'm often asked about my non-technical reading habits, so I posted a short list among my home pages.

James Buchanan is a programmer and freelance technical journalist. He can be contacted at praetorian.au@gmail.com.

Database Management System - Slides

2008-03-09T18:22:00.002+05:30

DBMS Slides are available in this link.

Download them.

kapil

2008-03-09T15:00:00.000+05:30

send me dbms notes

OOPL Comparison

2008-03-02T13:59:00.002+05:30

The following table shows some similarities and differences in features and the use of terms and concepts in Smalltalk, C++, and Java.

OO Concept/syntax	Smalltalk	C++	Java
Abstract class	Concept exists, no mechanism for enforcement	A class with a pure virtual function can't be instantiated	Classes may be declared abstract
Assignment operator	:=	=	=
Character constant	$c	'c'	'c'
Class	Class	Class	Class
Class method (corresponds to a message sent to the class rather than an instance)	Class method	Static function member	Class (or static) method
Class variable (data associated with the class, not an instance)	Class variable	Static data member	Class field
Comment	"Comment"	// Comment /* Comment */	// Comment /* Comment / /* Javadoc Comment **/
Dynamic binding	Unrestricted	Only subclasses of the declared class	Subclasses of the declared class or implementations of the declared interface
Equality test (see also identity test)	=	==	equals()
Finalization of instances before deletion (e.g., to release operating system resources)	Some implementations support finalize method	Destructor function	finalize method is standard
Garbage collection (automatic memory management)	Garbage collection is standard	No garbage collection - programmer explicitly manages memory	Garbage collection is standard
Identity test (see also Equality test)	==	same as equality	==
Inheritance	Single inheritance only	Multiple inheritance	Single inheritance only
Initialization of instances	Override new method	Constructor function	Constructor function
Instance data or state	Instance variable	Data member	Instance field
Interface contract (specifies the public interface to classes that implement it)	No corresponding construct	No corresponding construct	Interface
Message	Message	Member function call	Method invocation
Message send syntax	anObject doIt	anObject.doIt() (direct) pObject->doIt() (pointer)	anObject.doIt()
Method	Method	Member function	Method
Method argument syntax	methodName: argument (keyword method)	memberFunctionName(argument)	methodName(argument)
Method return	^ (caret)	return	return
Object (root of all classes)	Class Object	No corresponding class	Class Object
Operator overloading (an aspect of polymorphism; different operator behavior based on receiver type)	Any operator can be overloaded	Any operator can be overloaded	Only methods can be overloaded, not built-in operators such as +, - , *
Pointers	No explicit storage pointers	Explicit use of storage pointers and pointer arithmetic	No explicit storage pointers
Self (the object executing a method)	self	this (usually not written)	this (usually not written)
String constant	'string constant'	"string constant"	"string constant"
Subclass	Subclass	Derived class	Subclass
Superclass	Superclass	Base class	Superclass
Superclass method invocation	super	:: (scoping operator, more general than Smalltalk or Java capability)	super()

ASP.NET

2008-01-09T12:09:00.000+05:30

The Microsoft .NET Framework

The .NET Framework is the infrastructure for the Microsoft .NET platform.

The .NET Framework is an environment for building, deploying, and running Web applications and Web Services.

Microsoft's first server technology ASP (Active Server Pages), was a powerful and flexible "programming language". But it was too code oriented. It was not an application framework and not an enterprise development tool.

The Microsoft .NET Framework was developed to solve this problem.

.NET Frameworks keywords:

Easier and quicker programming
Reduced amount of code
Declarative programming model
Richer server control hierarchy with events
Larger class library
Better support for development tools

The .NET Framework consists of 3 main parts:

Programming languages:

C# (Pronounced C sharp)
Visual Basic (VB .NET)
J# (Pronounced J sharp)

Server technologies and client technologies:

ASP .NET (Active Server Pages)
Windows Forms (Windows desktop solutions)
Compact Framework (PDA / Mobile solutions)

Development environments:

Visual Studio .NET (VS .NET)
Visual Web Developer

This tutorial is about ASP.NET.

ASP.NET 2.0

ASP.NET 2.0 improves upon ASP.NET by adding support for several new features.

You can read more about the differences between ASP.NET 2.0 and ASP.NET in the next chapter of this tutorial.

ASP.NET 3.0

ASP.NET 3.0 is not a new version of ASP.NET. It's just the name for a new ASP.NET 2.0 framework library with support for Windows Presentation Foundation, Windows Communication Foundation, Windows Workflow Foundation; and Windows CardSpace.

These topics are not covered in this tutorial.

Differences between ASP and ASP.NET

ASP.NET has better language support, a large set of new controls and XML based components, and better user authentication.

ASP.NET provides increased performance by running compiled code.

ASP.NET code is not fully backward compatible with ASP.

New in ASP.NET

Better language support
Programmable controls
Event-driven programming
XML-based components
User authentication, with accounts and roles
Higher scalability
Increased performance - Compiled code
Easier configuration and deployment
Not fully ASP compatible

Language Support

ASP.NET uses the new ADO.NET.

ASP.NET supports full Visual Basic, not VBScript.

ASP.NET supports C# (C sharp) and C++.

ASP.NET supports JScript as before.

ASP.NET Controls

ASP.NET contains a large set of HTML controls. Almost all HTML elements on a page can be defined as ASP.NET control objects that can be controlled by scripts.

ASP.NET also contains a new set of object oriented input controls, like programmable list boxes and validation controls.

A new data grid control supports sorting, data paging, and everything you expect from a dataset control.

Event Aware Controls

All ASP.NET objects on a Web page can expose events that can be processed by ASP.NET code.

Load, Click and Change events handled by code makes coding much simpler and much better organized.

ASP.NET Components

ASP.NET components are heavily based on XML. Like the new AD Rotator, that uses XML to store advertisement information and configuration.

User Authentication

ASP.NET supports forms-based user authentication, including cookie management and automatic redirecting of unauthorized logins.

(You can still do your custom login page and custom user checking).

User Accounts and Roles

AS .NET allows for user accounts and roles, to give each user (with a given role) access to different server code and executables.

High Scalability

Much has been done with ASP.NET to provide greater scalability.

Server to server communication has been greatly enhanced, making it possible to scale an application over several servers. One example of this is the ability to run XML parsers, XSL transformations and even resource hungry session objects on other servers.

Compiled Code

The first request for an ASP.NET page on the server will compile the ASP.NET code and keep a cached copy in memory. The result of this is greatly increased performance.

Easy Configuration

Configuration of ASP.NET is done with plain text files.

Configuration files can be uploaded or changed while the application is running. No need to restart the server. No more metabase or registry puzzle.

Easy Deployment

No more server restart to deploy or replace compiled code. ASP.NET simply redirects all new requests to the new code.

Compatibility

ASP.NET is not fully compatible with earlier versions of ASP, so most of the old ASP code will need some changes to run under ASP.NET.

To overcome this problem, ASP.NET uses a new file extension ".aspx". This will make ASP.NET applications able to run side by side with standard ASP applications on the same server.

10 tricks for working more effectively in PowerPoint

2007-12-28T10:30:00.000+05:30

PowerPoint is a powerful presentation package, but most of us don’t use it often enough to learn its many timesaving tricks. The good news is that you don’t have to be an expert to get more mileage out of PowerPoint features. Here’s a look as some of the shortcuts and tricks you can use to put PowerPoint to work for you.

Note: This information is also available as a PDF download.

#1: If you don’t like the design, pick another

You can build a presentation from scratch, but most of the time a design template is more than adequate. These templates apply consistent design and formatting attributes from the first slide to the last. Click the Slide Design button on the Formatting toolbar to open the Slide Design task pane to get started. (In PowerPoint 2007, choose a design template from the Design group.)

You’re not stuck with a design once you choose it. At any time, even after the presentation is complete, you can choose another design. Simply select the one you want; you won’t lose any content.

You can also change the design for only selected slides, without actually removing the template from your presentation. In the Slide pane or Slide Sorter View, select the thumbnails that represent the slides you want to change. Next, click on the drop-down arrow beside the desired design in the Apply A Design Template list and choose Apply To Selected Slides (Figure A). (There’s no drop-down arrow in PowerPoint 2007; just right-click on the design.) PowerPoint will immediately update the selected slides.

Figure A

#2: Hone for focus

Resist the urge to crowd as much text as you can onto a single slide. If a busy slide doesn’t overwhelm your audience, it will most certainly distract them. Instead of listening to you, they’ll read ahead.

Once you have a rough draft of your presentation, review it with the following goals in mind:

Replace complete sentences with key words and phrases
Get rid of unnecessary clip art
Remove punctuation

By following these steps, you may reduce content by as much as half, and your presentation will be more focused.

#3: Don’t forget The end!

When you come to the end of your presentation, what comes next? If you click out of Slide Show View, your audience will get a behind-the-scenes peek at your work, and you probably want to avoid that. Instead, end your presentation with a slide that maintains the presentation’s master slide details but displays a simple message such as Thank you for your support or Thank you for coming.

Of course, the end slide doesn’t have to display a message. A blank slide might be adequate. You might even consider combining two end slides: Display a short thank you, or otherwise appropriate message, and follow it with a blank slide. That way, if you click out of the message slide, you’re still covered.

Professional presentations include a slide dedicated to ending the presentation. It protects you and cues your audience.

#4: Create your own AutoContent template

The AutoContent Wizard is a great place to start when you’re not sure what a presentation should cover. This wizard creates a new presentation using built-in templates, and you can customize the results.

What you might not know is that you can add an existing presentation to the AutoContent Wizard’s library. To do so, complete the following steps:

Launch the wizard by choosing New from the File menu.
Click the From AutoContent Wizard link in the New Presentation task pane.
Click Next in the wizard’s first pane.
Choose the most appropriate content template category and click Add (Figure B).
Locate your presentation file and click OK.
Quit the wizard.

At this point, the presentation you added is available to use as a content template. Don’t let a good, generic presentation go to waste. Most likely, you’ll have to customize it, but that’s true of any content template you choose.

The AutoContent Wizard isn’t available in PowerPoint 2007. Instead, use a themed template. Choose File from the Office menu and select New to get started.

Microsoft offers more free templates.

#5: Send a presentation to Word

PowerPoint can print views, but you can’t modify the results much. For instance, you can print handouts or even individual slides, but PowerPoint just prints a hard copy of your exact slides. If you want to enhance or format handouts, send the presentation to Word, which offers more flexibility. To do so, complete the following steps:

Choose Send To from the File menu.
Select Microsoft Office Word from the resulting submenu.
In the Send To Microsoft Office Word dialog (Figure C), choose one of the many send options. The Outline Only option sends only the content.
Click OK.

Figure C

Once your content is in Word, you can apply formatting and printing options that aren’t available to you in PowerPoint.

In PowerPoint 2007, you use the Publish command to send content to Word. Choose Publish from the Office menu and then choose Create Handouts In Microsoft Office Word.

When you do supply handouts, consider handing them out at the end of the presentation instead of at the beginning. Some people will pay more attention to your handouts than your presentation.

#6: Reverse those points

You probably know that you can display bullet points one at a time by choosing an animation scheme in the Slide Design task pane. Specifically, choose Fade In One By One from the Subtle section. What you might not know is that you can display bullet points in reverse order. The easiest way to reverse point order is to choose Show In Reverse in the Moderate section of the Animation Scheme task pane.

It’s a good idea to spend some time viewing all of the Animation Scheme options. It won’t take long, just a few minutes. Being familiar with all the effects is the key to using each appropriately. In addition, where animation is concerned, less is better than more — go easy and use animation only when you have a specific reason to and not just because you like a particular scheme.

You’ll find animation options on PowerPoint 2007’s Animations tab in the Animations group. Use the Animate drop-down list to choose the desired effect. The interesting advantage in 2007 is that as you choose an effect, PowerPoint displays it, so you can see it at work before you select it.

#7: Beware of busted GIFs

PowerPoint 2000 was the first version to support animated .gif files, but the viewer didn’t. (PowerPoint Viewer is a support application that lets others view your PowerPoint presentation, even if they don’t have PowerPoint installed locally.) Unfortunately, the older viewers don’t support .gif files. This limitation has the potential to spoil your otherwise flawless presentation.

The good news is that more recent viewers do support .gif files. In fact, they offer full-feature support all the way back to PowerPoint 97. If you’re still using an older version of PowerPoint — 97, 2000, or XP — the latest viewers will run your presentations, .gif’s and all. Microsoft offers a list of the different PowerPoint Viewer versions.

#8: Reverse slide print

Most printers allow you to print in reverse, but you can’t always get to individual printer options — especially with networked printers that are configured for all users by an administrator. If printing options are limited, you can still have PowerPoint print your slides in reverse order, with or without help from your printer:

Choose Print from the File menu. (In PowerPoint 2007, choose Print from the Office menu.)
Click the Slides option in the Print Range section.
Enter the range of slides in reverse order. For instance, if you want to print slides 1 through 10 in reverse order, enter 10-1 instead of 1-10. It’s an easy solution to implement.

PowerPoint will remember this setting until you change it or exit the presentation. Even if your printer has a reverse option available, you might find the PowerPoint route easier to take if you consistently print the same range of slides during the same work session, as your printer might not remember the setting.

#9: Reduce file size

PowerPoint files can be huge. If you send them via e-mail, you might find it takes a while to upload and download a presentation, especially if you or a recipient is still using a dial-up connection.

You probably use special software to compress the file before sending. You can also reduce the size of the original file by deleting the slide thumbnails. To do so:

Choose Properties from the File menu.
Click the Summary tab.
Locate the Save Preview Picture check box at the bottom of the dialog box (Figure D) , deselect it, and click OK.

Figure D

Doing this will save a huge hunk of KBs, even before you compress the file. If you disable the thumbnails, you can’t preview the file in the Open dialog box, but that seems like a small tradeoff for the KB savings.

This option is harder to find in PowerPoint 2007. From the Office menu, choose Prepare and then Properties. From the Document Properties drop-down list, choose Advanced Properties to find the Summary tab. You’ll still save some space, but not as much.

# 10: Control the pointer from the keyboard

During a slide show, PowerPoint hides the pointer five seconds after you display each slide, and then it disappears. When you click to view the next slide, the pointer becomes visible for another five seconds. You can control pointer display by clicking the icon in the bottom-left corner of the screen, but that’s a bit distracting in the middle of a presentation. Instead, consider controlling pointer visibility from the keyboard:

Ctrl + H hides the pointer immediately.
Ctrl + A displays the pointer immediately.

Once you use Ctrl + A to display the pointer, it’s fixed. There’s no five-second delay. You must use Ctrl + H if you want it to go away.

10+ Windows XP keyboard shortcuts to speed everyday tasks

2007-12-28T10:28:00.000+05:30

How expansive is your repertoire of Windows XP keyboard shortcuts? A lot of users learn a handful of shortcuts but turn their backs on a host of other ones that could come in handy. Check out the selection of shortcuts below and see if there aren’t a couple you didn’t know about that could be saving you some real time.

You can also download a PDF that lists 50+ Windows XP shortcuts.

The shortcuts

Keystroke	Function
Alt + Tab	Switches between open programs
Alt + F4 (in a program)	Closes the program
Alt + F4 (from the desktop)	Opens the Windows Shutdown/Restart dialog box
Alt + Enter	Opens the Properties page of a selected item
Alt + Esc	Cycles between open programs in the order they were opened
Alt + Spacebar	In the active window, this brings up the corner dialog box for Move, Size, Minimize, Maximize, or Close
Shift + Insert a CD/DVD	Inserts a CD/DVD without triggering Autoplay or Autorun
Shift + Delete	Permanently deletes an item (rather than sending it to the Recycle Bin)
Ctrl + Shift + Esc	Opens the Windows Task Manager
Ctrl + drag an icon	Copies that item
Ctrl + Shift + drag an icon	Creates a shortcut for the item
Right-click + drag an icon	Brings up a menu to copy, move, or create a shortcut for the item
F1	Opens Windows XP Help
F2	Highlights the label of a selected item for renaming
F3	Opens Windows search for files and folders
F5 (or Ctrl + R)	Refreshes an Internet Explorer page or other window
F6	Cycles through the elements that can be selected in a screen or window
F10	Selects the menu bar in the active program (usually the File menu) so that you can use the arrow keys to navigate through the menus and the Enter key to display one
Shift + F10	Displays a shortcut menu for an item (like right-clicking with the mouse)
Ctrl + Esc	Opens the Start menu

Roll your own shortcut

You can also create custom Windows XP shortcuts. Just right-click on the icon of a program or program shortcut, choose Properties, click the Shortcut tab, and enter a keystroke combination in the Shortcut Key field. Windows will let you assign only key combos that aren’t already taken.

How your tech resume should differ from a general resume

2007-12-28T10:27:00.001+05:30

Resume writing has almost become a science. There are a gazillion companies out there that exist only to help people create resumes that will garner interviews. While many of the standard resume suggestions work for any type of resume, there a few tweaks you’ll need to make in order to create a resume specifically for a position in IT. Here are some things to keep in mind when creating a tech resume:

You don’t have to stick with one page. Many sources will tell you a one-page resume is better, but that’s not necessarily true for a tech resume. For an IT position, you’ll need to showcase your technical skills as well as your customer-centric skills, so don’t be afraid to go to two pages. But try to keep it to two.
On the first page of your resume, include a summary of your qualifications. This is information not bound by dates of employment. You’re simply outlining your background and your general strengths.
Also on the first page, outline only your top qualifications. Focus on your familiarity with modern and emerging technology and don’t waste space on outmoded stuff. No hiring manager is going to care much about your expert knowledge of Windows NT.
Fill your online resume with lots of keywords. Hiring managers, in an effort to cut to the chase, may electronically search your resumes for the terms they’re looking for.
Run spell check but don’t trust it. Spell checking won’t flag correctly spelled words used incorrectly and may not catch tech terms and proper product names that are not part of the dictionary. For products, be sure to use the manufacturer’s spelling. Nothing kills your credibility faster than to say you’ve worked with a technology for years when that technology or acronym is incorrect on your resume.

The five worst things you can do in a meeting

2007-12-28T10:26:00.001+05:30

Here are five meeting offenses that will not only drive your co-workers crazy, but will also damage your reputation within the workplace.

Show up late - Occasionally there is an emergency that crops up that forces you to go into a meeting a few minutes late. But usually the culprit is poor time management. Consistently arriving late implies to your manager and your co-worker that you are either extremely disorganized or don’t really respect the rules that everyone else follows.
Bring your cell phone - Again, there could be special circumstances that would require having a cell phone in a meeting, such as a call from a doctor or your child’s school. But if your cell goes off at every meeting and it’s just your spouse needing to know if you’ll pick up some Pudding Pops after work, shame on you. This behavior shows a lack of respect as well as a lack of commitment to your job.
Have a side conversation - Nothing rankles a meeting leader more than two people having a whispered conversation separate from the topic at hand.
Don’t focus - Believe it or not, I’ve been in meetings when attendees have leafed through clothing catalogs or balanced their checkbook while the leader is talking. Trying to multi-task in a somewhat dull meeting might be tempting, but it’s very rude. And don’t think people don’t notice.
Talk just to hear yourself speak - It may be your way of raising your office profile, but hogging much of the meeting spotlight with philosophical ramblings will not do it. Be brief and succinct. Meetings are for communication; they are not your personal stage.

10 things you should do if you make a big mistake

2007-12-28T10:15:00.001+05:30

Note: This information is also available as a PDF download.

#1: If possible, come up with a plan to fix the problem

Don’t just walk away and wash your hands of the situation. True, other people might have to be involved in solving the problem. However, if you caused the problem, you are responsible for coming up with the plan to resolve it. The plan needs to address the actions that need to occur, the people who need to take them, and the amount of time you think the actions will take. The people involved most likely will be the boss, your co-workers, and any internal or external customers affected by the mistake.

#2: Come clean with your boss

Trying to cover things up rarely works. If and when your boss finds out, say, from someone else (worst of all from your boss’ boss), things will be even worse for you. In this kind of situation, it’s important that you be in control of the message. So as hard as it will be, you should summon up your strength, take a deep breath, and go talk to your boss.

#3: Let the boss know about that plan

In this situation, and in fact at any other time, never to go to the boss with just a problem. Go with a solution as well. In this case, go with the plan you developed and show the boss that, to at least some degree, you’re in control.

#4: Tell the affected parties

Let those affected by your mistake know what happened, but spare the technical details for now. Instead, focus on how the situation affects them: what limitations are in place, what functions are unavailable, and how long these limitations and lack of function are expected to last. Most important, offer any workarounds you can. Ask for their suggestions as well. If the mistake involves a system outage, perhaps some veteran techs can remember what they did in the old days, before that system was in place. If you have to and can do so, think about calling retirees for their ideas.

#5: Don’t blame others

You’re no longer in grade school. Trying to blame other people makes you look unprofessional, diminishing the opinion that others have of you. Conversely (and paradoxically), taking responsibility and admitting your mistake can win you respect. Your co-workers might end up thinking, “You know, even though [your name] messed up, it took a lot of character to admit it. [Your name] is a real stand-up person, and someone who can be counted on.”

#6: Stop looking back

Learning from the past can help prevent repeat mistakes. However, don’t confuse learning from the past with dwelling on the past. The latter involves endless self-recrimination and often self-pity, neither of which helps resolve the situation. If you find yourself dwelling on the mistake in this manner, stop it right now and read the next tip.

#7: Prepare and issue a “lessons learned” document

“Those who do not remember the past are doomed to repeat it.” “As a dog returns to its vomit, so a fool repeats his folly.” Maybe you’ve heard these or similar sayings. Their point is clear: We need to understand the mistake we made so that we can avoid it in the future. Documenting the mistake, and the steps taken to resolve it, are key in this regard. In doing so, be sure to cover the conditions that led to the mistake, the steps taken to correct it, and the measures taken to prevent its recurrence.

In my example of the bad SQL table, I ended up not only keeping my job, but I also kept my security officer user profile. However, we created a second user profile for me, one that lacked access to production data, which I was to use for testing and development work.

#8: Apologize to those affected

Mistakes often cost others in lost time and productivity and hence frustrate them. Consequently, even if you solve the problem, the people who were affected by it might still be upset if you never acknowledge that frustration. I’m not saying you have to be an Oprah or a Dr. Phil, but taking a second to apologize will go a long way toward restoring you to good graces. By doing so, you show you appreciate what they had to go through.

#9: Determine whether the mistake can occur elsewhere

This point relates to the “lessons learned” document. Here, however, you should consider other areas of the business, or other applications. To what extent do they have the same conditions, procedures, or people that could cause them to experience the same type of problem? You might want to alert those areas. They may answer that they have more competent staff, but that’s a risk you’ll have to take.

#10: Put the best face possible on what happened

Everyone focuses on the negative effects of a problem. There had to be some; otherwise, it wouldn’t have been a problem and wouldn’t have received such scrutiny. However, can you find any good things, no matter how small, that resulted from this problem? One of the most useful concepts I’ve learned is that of “reframing” the situation, that is, to change the way a person looks at it. In this case, reframing the problem might take the following form:

Yes, a problem occurred.
Yes, the system was unavailable.

BUT the good news is

It happened during a slow time.
It identified issues we need to address elsewhere in other systems.

Of course, in offering these arguments, it’s helpful if you can do so with a straight face.

The Do’s and Don’ts of successful interviewing

2007-12-28T10:11:00.002+05:30

My comments are in brackets.

Do:

Arrive on time.
Greet the interviewer by name. [Not his or her first name though until you are issued the invitation.]
Smile and shake hands firmly. [However, making a good impression is not dependent on how many knuckles you crush.]
Look alert and interested at all times. [Turn off the cell phone and PDA. Somebody’s going to post in the discussion and ask who’d be stupid enough to leave those on in an interview. I’ve been a witness to it; they’re out there.]
Speak firmly, clearly and loudly enough to be easily understood. [[A good suggestion but you just know someone reading it will go overboard, yelling and annunciating like a tourist in a foreign land.]
Look the interviewer in the eye while speaking. [If you’re shy this can be hard to do, but it does help.]
Structure your comments in a positive manner. [If you’re negative in a meeting in which you’re supposed to impress someone, what does that tell the interviewer about how you’ll be on the job?]

Don’t:

Exhibit overbearing, overaggressive, or egotistical behavior. [You don’t have to be brash or smug to come across as self-confident.]
Show a lack of interest or enthusiasm about the position or company. [Why even show up if you’re not interested?]
Appear excessively nervous. [This is easier said than done if you are actually, well, nervous, as most of us are in interviews. Just try to take some deep breaths beforehand and prepare yourself for possible questions.]
Overemphasize your compensation. [It was always a red flag to me as a manager when a job candidate asked what the salary was in the first 15 minutes.]
Make excuses for unfavorable factors in your work history. [It’s tempting, I know. But taking responsibility for yourself is the mature thing to do.]
Disparage past employers, managers, projects or technologies. [This would tell me that you’re going to do the same thing as an employee working for me.]
Answer only “yes” or “no” to questions. [It’s pretty awkward when you ask what you think is a probing question and get only a one-word answer in return. Don’t rattle on and on but try to expound a little just to show the interviewer that the wheels up there are turning.]

What hiring managers hate about your resume

2007-12-28T10:11:00.001+05:30

Grammatical/spelling errors
Too much information (or as GSG says, “I’m hiring you for a job. I don’t want to know about your 4 kids, that they are (in your opinion) little Einsteins, your dogs, your husband/wife, or your hobby of knitting little stocking caps for the poor little cold kittens.”)
Information provided that the interviewer can’t legally ask for (marital status, age, religion)
Unexplained date gaps in work experience
An overstatement of technical skills
Bad formatting (TiggerTwo hates “the failure to place the most important information in the top third of the page, lack of white space, a bunch of keywords that appear to exist only to be keywords, failure to provide a skills listing, use of less than 10 point font, and use of a difficult-to-read font.”)
“If you can’t tell from the resume alone if the owner is enthusiastic about (some aspects of) his previous job experiences, the resume is out.”
Not highlighting actual results delivered
Overly long resumes. According to frostbite, “anything more than 2 pages is a hard read, more than 4 is a tome.”

10 tips for writing a job-winning developer resume

2007-12-28T10:08:00.000+05:30

As seasoned job hunters know, the first step on the road to finding work is to write a resume that gets you the interview. Unfortunately, some of the traditional resume writing rules just do not work well in the software development industry. Here are 10 tips for writing a programmer resume that will increase your chances of getting the interview.

Note: This information is also available as a PDF download. For a more detailed look at this topic, see the blog post “Write a resume that will land you a programming job.”

#1: Provide a skills list up front

The hiring manager wants to know if you have the skills the company is looking for. An “experience” section gives managers a good idea of how much experience you have, but if you have a “skills” section at the top of the resume, their eyes go there first. Sure, you may be making it a bit easier for them to weed out your resume. But on the flip side, you might bring to their attention some skills they would otherwise overlook. At the very least, the hiring manager will appreciate the skills list.

#2: Make the experience interesting

Most developers on the market have written a data-driven Web site or desktop application. To give a bunch of examples of these on your resume is not impressive. What does impress a potential employer is experience that has something unique about it, showing you’ve done more than just “Hello World” level work. If you’ve been working under unique constraints or in environments with high levels of transactions or zero tolerance for failure, that looks very good to the person reading the resume. So show me how your experience is different, and I will see you as different.

#3: Root out grammar, spelling, and other common mistakes

Over the course of my time hiring, I have seen all sorts of grammar and spelling mistakes on resumes. One of the most embarrassing was when someone misspelled the name of the college he graduated from. Resumes do contain some unique grammatical conventions, and software development work in particular often revolves around acronyms or oddly spelled words. But that is really no excuse. Check your spelling and your grammar. This tip appears on just about every resume advice article I have ever read, but it clearly needs repeating.

#4: Education counts, but not for much

Unless you are just entering the job market for programming or are applying for a very specialized position, your education is not terribly important. Sure, you need to put it on your resume, but list it last, please. The hiring managers who need or want to know about it can find it, and the others won’t have to spend time on it. The world of programming changes often enough so that somewhere around seven years later, most schooling (except for “principles and theory” subjects, like mathematics or “pure” computer science) and certifications have little in common with the current working world reality.

#5: Get to the meat, quick

The traditional resume format includes a lot of information that’s just not needed, in the mind of the development manager. Your summary and possibly even the objective are two such sections. There really is no way to provide a summary that describes most programming pros in a way that is accurate, yet shorter than a resume itself. This is why most summary sections read like so much useless drivel: “Seasoned programmer with 10 years development,” followed by highlights of the skills section. Thanks, but no thanks.

The objective is often (but not always) just as useless. If you are looking for a change of pace, it offers a great way to keep the reader from pigeonholing you based on your skills and experience. The intermediate programmer looking to slide into a senior developer position can safely skip the objective. The senior programmer who wants to become a software architect or a DBA needs to state an objective. So avoid the summary at all costs, provide only useful objectives, and let the reader get to your skill set as quickly as possible.

#6: Formatting matters

The formatting of your resume is important. While the days of mailing resumes printed on premium stationery are long past, it is still a document that someone needs to read on a computer screen and on paper. That can be quite a balancing act, believe it or not. This is not the time to show off your inner Picasso, unless the position you are applying for is of a visually artistic nature. This is the time to enhance readability. That means using a larger font (10 to 12 points), a common font that all computers have (if your document format does not bundle fonts within it), and one that looks good both on the screen and off. My recommendations are Verdana, Arial, Tahoma, Calibri, and Helvetica.

Use enough whitespace so that the document does not seem too dense, which will turn readers off. At the same time, don’t waste so much space that it takes eight pages to print 200 words. Of course, the format of the file itself is important. My experience has been that 99.9% of the recruiters out there will ask for your resume in Microsoft Word format if you send it in any other format, so make sure that you can provide a document in the standard .doc format.

Always keep in mind that the resume is your primary tool for selling yourself. If readers can’t consume the information in it, whether due to technical issues or readability problems, they will quickly move on to the next resume.

#7: Be cautious with the length

Regardless of how your document is formatted, try to keep the length between two and four pages, unless there are extremely special circumstances. People who spend a lot of time doing short-term contract work can have longer resumes, and people just entering the job market can have shorter resumes.

Overall, it is tough to properly highlight your technical skills and more than one position in the traditional one-page resume format. Two pages should be the baseline for any intermediate or senior developer. But after about four pages, the reader’s eyes start to glaze over. Much like your education, the experience you had more than seven or eight years ago is not terribly relevant, but the hiring manager does like to see an arc of increasing responsibility or project difficulty.

#8: Properly document your history

Programming is not like most fields when it comes to employment history. For one thing, many programmers are contractors, which leads to an employment history that can look like a train. In addition, the dot-com bust is not too far behind us, and IT has always been an industry with a lot of bankruptcies, mergers, and acquisitions.

The problem is, no hiring manager likes to see a long list of short-term jobs. If your resume has a string of such jobs, with job titles that get bigger and bigger, you look like someone who has no loyalty. On the other hand, if the jobs seem basically the same (or worse, get lower on the totem pole), it makes the reader think that you may simply be unemployable. If you have a legitimate reason for the short-term jobs, make sure that the reason is obvious. For example, mark the contracting/consulting positions clearly.

#9: Don’t put the reader at legal risk

No hiring manager likes to be accused of prejudiced or discriminatory hiring. Not only is it unethical, but it is illegal. So hiring managers who are trying to do the job right will be familiar with the list of questions they can’t ask an applicant. Your part of the equation is to exclude this information from your resume. The hiring manager does not need to know your marital status, ethnicity, nation of origin, age, religion, or sexual orientation. There are a lot of other things the hiring manager does not need to know, either. If you include these irrelevant details on your resume, the hiring manager will feel scared and skittish. Leave these details out, please.

#10: “What a geek!”

In high school, you may have hated being called a geek. But today, you are trying to find work as a programmer. “Geek” is “gold” to hiring managers. Find a way to show them that you are smart, love programming, and are constantly growing, learning, and exploring new ideas. Talk about your relevant hobbies if you have any, like contributing to open source projects or volunteering to teach local kids programming. Let them know if you like programming or computers enough to deal with them outside of work.

It is a really simple equation for the hiring manager. While two candidates may be equal today, the candidate with passion will be far more advanced tomorrow than the candidate who treats it as “just a job.”

Real-life resume blunders

2007-12-28T10:07:00.000+05:30

How bad of a mistake can you make on your resume? Here are some real
life examples from Dribbleglass.com:

I am very detail-oreinted.
My intensity and focus are at inordinately high levels, and my ability to complete projects on time is unspeakable.
Thank you for your consideration. Hope to hear from you shorty!
Enclosed is a ruff draft of my resume.
It’s best for employers that I not work with people.
Here are my qualifications for you to overlook.
I am a quick leaner, dependable, and motivated.
If this resume doesn’t blow your hat off, then please return it in the enclosed envelope.
My fortune cookie said, “Your next interview will result in a job.” And I like your company in particular.
I saw your ad on the information highway, and I came to a screeching halt.
Insufficient writing skills, thought processes have slowed down some. If I am not one of the best, I will look for another opportunity.
Please disregard the attached resume-it is terribly out of date.
Seek challenges that test my mind and body, since the two are usually inseparable.
Graduated in the top 66% of my class.
Reason for leaving last job: The owner gave new meaning to the word paranoia. I prefer to elaborate privately.
Previous experience: Self-employed-a fiasco.
Exposure to German for two years, but many words are inappropriate for business.
Experience: Watered, groomed, and fed the family dog for years.
I am a rabid typist.
I have a bachelorette degree in computers.
Excellent memory; strong math aptitude; excellent memory; effective management skills; and very good at math.
Strengths: Ability to meet deadlines while maintaining composer.
I worked as a Corporate Lesion.
Reason for leaving last job: Pushed aside so the vice president’s girlfriend could steal my job.
Married, eight children. Prefer frequent travel.
Objective: To have my skills and ethics challenged on a daily basis.
Special skills: Thyping.
My ruthlessness terrorized the competition and can sometimes offend.
I can play well with others.
Personal Goal: To hand-build a classic cottage from the ground up using my father-in-law.
Objective: I want a base salary of $50-$60,000 dollars, not including bonus. And some decent benefits. Like a retirement plan, health insurance, personal or sick days.
Experience: Provided correct answers to customers’ questions.
Education: Graduated from predatory school with honors.
Never been fired, although it could happen anytime now.
I have happily been a “kept man” for the past 10 years.
Have extensive experience in turkey manufactures as well as new product development and implementation.
I am accustomed to speaking in front of all kinds of audiences. I make points as well as I can.
Personal: Five children. Dog: Jasper. Cat: Morris. Gerbil: Binky.
While in military, was instrumental in creation of a treat detection system.
My compensation package at my last job included a base salary of $64,500 with excellent benefits including flextime. I am looking for a position in which I can work a more flexible schedule.
Hire me and you won’t regret it-I am funny, cute, smart and creative… really.
Referees available upon request.
Previous rank: Senior instigator.
I have recently sold my home and I now live in a large RV so I will be able to relocate quickly.
Reason for leaving: They stopped paying me.
Cover letter: Desire the chance to showcase my delightful personality, intelligence and superior judgment, which are so hard to find these days.
Personal achievements: Successfully played “Chop Sticks” on a toy piano with my big toes.
Objective: To obtain a position where I can make a difference, infecting others with my professionalism, enthusiasm and dedication.
Strengths: Impersonal skills.
Special interests: I like any projects that are fun.
Please explain any breaks in your employment career: 15 minute coffee break while working at a home improvement store.
Vocational plans: Sea World.

Write a resume that will land you a programming job

2007-12-28T10:04:00.000+05:30

Put your skills front and center

Reading the in-depth details of how you used mainstream skill XYZ to accomplish typical task ABC is not at the top of my agenda. I want to see your skills up front, so I don’t need to go trolling through your resume to see if you meet my minimum needs.

Skip the summary and maybe even the objective

Those summaries are a waste of my time. It is going to say something like “seasoned IT pro with great communication skills” or “proven veteran with 10 years of programming experience.” How do I know this? Because they all say this. Skip it, please.

The objective is a slightly different story; it is useful only if it informs the interviewer about something that the skills and experience does not. The objective’s relevance to me is largely a function of whether you wish to keep doing what you have been doing. If I see you have been programming — particularly at the data access layer and the business object layer — and there is no objective, I am going to assume that you are looking for more of the same with a different employer or location. If you want to do more of that work and put an objective, you are wasting space. If you are looking for a change of pace — like getting more into the presentation layer or heading towards a management track — it’s important to state that in your resume. Otherwise, we may discover during the interview that you are not interested in what we have to offer.

List your education last

Some IT hiring managers put a huge emphasis on certain educations but I do not. I always want you to list your school and your major, but I will only ask you about your education if there is something unusual or intriguing.

For instance, a candidate with a Computer Science degree from MIT or with a PhD in Organic Chemistry will draw my eye because these degrees show a level of high intelligence. On the flipside, an AA in basket weaving or a lack of a degree will not count against you.

In most cases, I am not even curious about your education until I have already made up my mind. This includes certifications — MCSEs and CCNAs do not impress me that much at this point. They matter to some folks, and they do not hurt you in my opinion, but I will only take that certification into account if all else is equal.

Show me that you are different

Even if my project is a run-of-the-mill Web-based, data driven application (which it is not), I still want to see that you are more than someone with 10 years of experience writing run-of-the-mill Web-based, data driven applications. For example, compare these two items:

BORING!
East Coast Power - Programmer 1999 - 2005

Wrote VB applications to control machinery. The hardware interface was handled in a COM library that was written by another team. Application was robust and reliable.
Wrote Web-based tool to track system faults.
Created Web service to allow partners to consume portions of the database.

WOW!
East Coast Power - Programmer 1999 - 2005

Wrote VB applications to control nuclear reactor. Real-time control and monitoring of systems handling 10,000 unique data inputs per second.
Wrote advanced algorithms in C# to detect imminent system failure, which were used within a Web-based application.
Created Web service in C# to allow partners to access data in a secure, reliable, and responsive manner; typical data set was 1,000,000 rows and concurrency challenges needed to be overcome at the database and application layers.

See the difference? Control machinery does not help me much – you could have been working on the elevator system for all I know. Programming a nuclear reactor impresses me, especially since there has not been any nuclear reactor disasters during your employment. Writing advanced algorithms in C# touches my engineer’s heart; whereas writing a mere Web-based tool is ho hum. And, while writing a Web service is fairly simple, particularly in ASP.Net, it’s not so easy to write one that is “secure, reliable, and responsive” with that size of a data set. It’s also not easy to deal with concurrency issues at two different levels.

I am not saying that it needs to be wordy or full of minute details, but if you are doing work beyond what a summer intern could do, I need to know about it. Every developer has written a Web-based, data driven application. Show me more.

Make sure that your experience highlights your skills

I don’t expect your employment history to include a list of all your skills. But if you are looking for work as a .Net developer, show me that you have done some .Net work. If you do not list that experience, I am going to assume that you have little or no experience with it — even if it is on your skill list. If you have large amounts of experience outside of the workforce, find a way to show that on your resume.

Keep your resume between two to four pages long

I have struggled through seven-page resumes filled with jargon and boring details that made me want to cry. An overly long resume doesn’t necessarily make me rule out a candidate, but why make it hard on me?

On the other hand, a resume that tries to stick to the one page rule is not going to cut it for a technical person unless they are new to the field. In my experience, two to four pages is just right. Also, please use some whitespace, so I do not feel like I am drowning.

Watch your formatting

While technical pros’ resumes do not need to be pretty, formatting can make a huge difference in a resume’s readability. If you cannot put three pages of text in front of me in a readable form, do I really want you touching the UI or writing code that someone else might have to maintain?

I recommend that you stick to a larger font size (e.g., 10 - 12 pt.) in a font that reads well onscreen and in print (e.g., Verdana, Arial, Tahoma, Calibri, Helvetica). If you want a slightly fancier font, use it only for section headers. Also, do not mix Serif and Sans Serif fonts — that is just ugly. Do not use “Comic Sans” anywhere, especially in hot pink or baby blue (and yes, unfortunately, this needs to be stated). Keep your margins and space between paragraphs large enough to provide the reader some “breathing room.”

Employment history

I give applicants some slack on employment history. For instance, five year stints are fairly rare in IT, and I give anyone a lot of leeway if their history includes anything that occurred during the dot com boom/bust.

If you are (or were) a contractor or consultant, make sure that is clearly stated; otherwise, I will think that you get fired and/or quit every 3 - 12 months. If you were not a contractor or a consultant, and it looks like you have a hard time staying at a job, I am going to be very cautious. If I see an increasing progression of job titles, “mercenary” pops into my head. Also, if I see that they are lateral (or worse, negative) moves, “bad apple” is my first thought. Of course, sometimes you get hit with a string of employers that go under or get acquired — it happens to the best of us. If that is the case, find a way to convey that information so I don’t think you are unemployable.

Spelling and grammar

It is critical that the spelling and grammar in your resume is flawless. I have seen applicants misspell the name of their state and the name of their school. If grammar and spelling are not your forte, ask someone to look over your resume for you. While I understand that many IT pros are not native English language speakers (or are English language speakers who paid little attention to those subjects in school), you should still ask someone for help. In fact, knowing when to ask for help is a hallmark of the best developers. If I interview you and realize from your speech that you had the sense and humility to ask someone for help on your resume, I am going to be truly impressed. (For examples of what not to do, check out this list of real-life resume blunders.)

Stay out of EEO (Equal Employment Opportunity) territory

In the United States, companies with more than 10 employees need to follow EEO rules. These rules state that an employer cannot discriminate against or show preference for an employee based on certain group membership items or personal lifestyle issues, such as gender, age, ethnicity, nation of origin, religion, sexual orientation, and so on. So, do me a favor and try to not expose any EEO-related information to me on the resume. In a face-to-face interview or even a phone interview, some of it will be unavoidable. But I will never solicit that information. Not only do I want to keep my employer and myself out of trouble, but I personally feel that EEO is important. I can understand that many names (or even college attended) are strongly correlated with ethnicity, religion, or nation (or at least general geographic region) of origin, and college graduation or attendance dates give some age clues. Minimize this as much as possible. Please do not tell me about your church, your family situation, your home life, your parents, and so on. It is not that I am not interested — I would probably love to learn these things about you if we hire you — but I do not need or want to know them before that you come on board.

Outside interests, hobbies, achievements, and activities

I like to see these, but only if they are relevant. I really do not need to know about how big of a fan you are of the New York Knicks; but if you wrote a piece of software that can do something nifty with the team’s statistics for fun, I would love to know about it. People who contribute to open source projects get a huge gold star in my book, but only if I feel like they would be comfortable working on proprietary software with proprietary tools, and not bringing anything GPL’ed into my codebase. That is a small caveat there. “Contributed to project XYZ in the areas of ABC and DEF” is enough to whet my appetite. Show me some outside learning too — don’t let me think that you get home at 6;00 and shut off your brain. If this work is not interesting enough for you to read about or experiment with on your own time, why would I think that you will be engaged or even interested in the job we would hire you for?

Gracefully show your inner geek

Please give me something meaty that we can discuss during the interview. So, where it is relevant, try to show me how much of a nerd you are.

For instance, try to mention the hovercraft you made from an inner tube and a lawn mower engine. Make note of the iterative, evolutionary game theory system you coded in Lisp that proves that Nash’s equilibrium is dead wrong. Tell me something about your three chess championship victories. I do not want to know that you memorized UHF or that you have a pocket protectors collection that have logos of now defunct minicomputer vendors.

I know most of this falls under the previous section, but it is relevant. I love to work with programmers who love technology and logic and using their brains. People like that are simply better programmers. Why would I want to hire someone who is intellectually lazy for an intellectually challenging job?

Obscure or nonmainstream technologies

I am not hiring Lisp, Prolog, Erlang, APL, Scheme, Clipper, PowerBuilder, Delphi, Pascal, Perl, Ruby, Python (forgive me for including those four in this list), Fortran, Ada, Algol, PL/1, OCaml, F#, Spec#, Smalltalk, Logo, StarLogo, Haskell, ML, D, Cobra, B, or even COBOL (which is fairly mainstream) developers. If you show these on your resume, I will want to interview you just for the sake of slipping in a few questions about these items. I am serious. As part of my secret geekiness, I am really into obscure and almost obscure languages and technologies. I know that a lot of those items take better-than-industry-average intellect and experience to do; they also provide a set of experiences that gives their practitioners a great angle on problems. While you will never directly use those skills in my shop, you will be using those ways of thinking, and it will give us something to talk about on your first day.

(Aside: A coworker was shocked to learn that I played Half Life. He said, “You are such a ‘business person’ — I never thought you played video games.” I guess I’m camouflaging my secret geekiness too well!)

Good luck

I’ve given away crown jewels here. In my perspective, these tips will help any programmer write a perfect resume and get them an interview.

What do you think gets applicants an interview? If you read resumes as either a hiring manager, a recruiter, or an HR employee, what makes you say “wow!” or “ugh!” when you see it on paper?

Routing Algorithm

2007-10-05T12:16:00.000+05:30

Routing Metrics

Routing tables contain information used by switching software to select the best route.

Routing algorithms have used many different metrics to determine the best route. Sophisticated routing algorithms can base route selection on multiple metrics, combining them in a single (hybrid) metric. All the following metrics have been used:

•Path length

•Reliability

•Delay

•Bandwidth

•Load

•Communication cost

Path length is the most common routing metric. Some routing protocols allow network administrators to assign arbitrary costs to each network link. In this case, path length is the sum of the costs associated with each link traversed. Other routing protocols define hop count, a metric that specifies the number of passes through internet working products, such as routers, that a packet must take en route from a source to a destination.

Reliability, in the context of routing algorithms, refers to the dependability (usually described in terms of the bit-error rate) of each network link. Some network links might go down more often than others. After a network fails, certain network links might be repaired more easily or more quickly than other links. Any reliability factors can be taken into account in the assignment of the reliability ratings, which are arbitrary numeric values usually assigned to network links by network administrators.

Routing delay refers to the length of time required to move a packet from source to destination through the internetwork. Delay depends on many factors, including the bandwidth of intermediate network links, the port queues at each router along the way, network congestion on all intermediate network links, and the physical distance to be traveled. Because delay is a conglomeration of several important variables, it is a common and useful metric.

Bandwidth refers to the available traffic capacity of a link. All other things being equal, a 10-Mbps Ethernet link would be preferable to a 64-kbps leased line. Although bandwidth is a rating of the maximum attainable throughput on a link, routes through links with greater bandwidth do not necessarily provide better routes than routes through slower links. For example, if a faster link is busier, the actual time required to send a packet to the destination could be greater.

Load refers to the degree to which a network resource, such as a router, is busy. Load can be calculated in a variety of ways, including CPU utilization and packets processed per second. Monitoring these parameters on a continual basis can be resource-intensive itself.

Communication cost is another important metric, especially because some companies may not care about performance as much as they care about operating expenditures. Although line delay may be longer, they will send packets over their own lines rather than through the public lines that cost money for usage time.

Polymorphism

2007-09-07T14:35:00.000+05:30

Polymorphism means that the same thing can exist in two forms. This is an important characteristic of true object oriented design - which means that one could develop good OO design with data abstraction and inheritance, but the real power of object oriented design seems to surface when polymorphism is used.

In programming languages, polymorphism means that some code or operations or objects behave differently in different contexts.
For example, the + (plus) operator in C++:
4 + 5 <-- integer addition 3.14 + 2.0 <-- floating point addition s1 + "bar" <-- string concatenation! In C++, that type of polymorphism is called overloading.

Polymorphism

Literal meaning - many forms
OOP meaning
- Same method (message) but different behavior
- Object determines which method gets executed
Function or Method Overloading
- Similar message but different behavior
Abstract interfaces to class hierarchies
- Define core data and behavior capabilities of a class family
- All classes in the family support core capabilities
- All objects in family respond to core methods (messages)

A classic example is how area is calculated on different shapes. We define an abstact base class shape and derive two classes - rectangle and circle from it. An area() method defined in the base class will have to be implemented differently in rectangle and circle, since it has to be calculated differently.

This is an example of polymorphic behavior, and in C++, this is implemented using virtual member functions. The area() member function is defined virtual in the base class, which signals to the compiler that this member function has to be invoked from the correct derived class at run time. This is indeed a run time decision, and which derived class member function is to be invoked depends on which derived class pointer has been assigned to the base class pointer. This also brings in the concept of late binding (run time binding), since the above association to the area member function can only be done at run time. The compiler will have to insert extra code to do the late binding, which adds in a little runtime overhead.

Types of Polymorphism:
C++ provides three different types of polymorphism.
Virtual functions
Function name overloading
Operator overloading

In addition to the above three types of polymorphism, there exist other kinds of polymorphism:
run-time
compile-time
ad-hoc polymorphism
parametric polymorphism

Other types of polymorphism defined:
run-time:
The run-time polymorphism is implemented with inheritance and virtual functions.
compile-time:
The compile-time polymorphism is implemented with templates.
ad-hoc polymorphism:
If the range of actual types that can be used is finite and the combinations must be individually specified prior to use, this is called ad-hoc polymorphism.
parametric polymorphism:
If all code is written without mention of any specific type and thus can be used transparently with any number of new types it is called parametric polymorphism.

In general, there are two main categories of Polymorphism namely
Ad Hoc Polymorphism
Pure Polymorphism

Overloading concepts fall under the category of Ad Hoc Polymorphism and Virtual methods. Templates or parametric classes fall under the category of Pure Polymorphism.

Persistence

2007-09-07T14:14:00.000+05:30

One of the most critical tasks that applications have to perform is to save and restore data. Whether it be a word processing application that saves documents to disk, a utility that remembers its configuration for next time, or a game that sets aside world domination for the night, the ability to store data and later retrieve it is a vital one. Without it, software would be little more effective that the typewriter - users would have to re-type the data to make further modifications once the application exits.

Therefore, an object that has the ability to store and remember values is often said to have persistence. For Example, the ability of your car radio to remember your list of favorite stations is often referred to as persistence.

It also can be defined as the property of an object by which its existence transcends time(i.e., the object continues to exist after its creator ceases to exists) and/or space (i.e., the object's locations moves from the address space in which it was created).

Hierarchy

2007-09-07T13:52:00.000+05:30

In computer science's object-oriented programming, the mapped relationships of sub- and superclasses is known as a hierarchy. This can be visualized as an upside-down tree (or perhaps a pyramid), the top of which is known as the root.

The issue is more complicated with languages that support multiple inheritance, where hierarchy can be any directed acyclic graph.

Aggregation or Composition relationships in object-oriented design also form a hierarchy, composition hierarchy.

In object-oriented programming, a class is a template that defines the state and behavior common to objects of a certain kind. A class can be defined in terms of other classes. For example, a truck and a racing car are both examples of a car. Another example is a letter and a digit being both a single character that can be drawn on the screen.

In the latter example, the following terminology is used:

The letter class is a subclass of the character class; (alternative names: child class and derived class)

The character class is immediate superclass (or parent class) of the letter class;

The letter class extends the character class.

The third formulation expresses that a subclass inherits state (instance variables) and behavior (methods) from its superclass(es). Letters and digits share the state (name, font, size, position) and behavior (draw, resize, ...) defined for single characters.

The purpose of a subclass is to extend existing state and behavior: a letter has a case (upper and lower case, say stored in the instance variable letterCase) and methods for changing the case (toUpperCase, toLowerCase) in addition to the state that it already has as a character.

However, a digit does not have a case, so the methods toUpperCase, toLowerCase do not belong on the common level of the Character class. There are methods that are special to the digit class. For instance, a digit may be constructed from an integer value between 0 and 9, and conversely, the integer value of a digit may be the result of say the intValue method.

In graphical terms, the above character example may look as follows:

The classes form a class hierarchy, or inheritance tree, which can be as deep as needed. For example, the letter class can have on its turn the subclasses vowel and consonant.

When a message is sent to an object, it is passed up the inheritance tree starting from the class of the receiving object until a definition is found for the method. This process is called upcasting. For instance, the method toString() is defined in the Object class. So every class automatically has this method.

In graphical terms, the inheritance tree and the message handling may look as follows:

A hierarchy is useful if there are several classes which are fundamentally similar to each other. In C++, a "base class" is a synonym for superclass and"derived class" is a synonym for subclass.

Messaging

2007-09-07T13:36:00.000+05:30

"The process by which an object sends data to another object or asks the other object to invoke a method." Also known to some programming languages as interfacing.

The object's interface consists of a set of commands, each command performing a specific action. An object asks another object to perform an action by sending it a message. The requesting (sending) object is referred to as sender and the receiving object is referred to as receiver.

Control is given to the receiving object until it completes the command; control then returns to the sending object.

For example, a School object asks the Student object for its name by sending it a message asking for its name. The receiving Student object returns the name back to the sending object.

A message can also contain information the sending objects needs to pass to the reveiving object, called the argument in the message. A receiving object always returns a value back to the sending object. This returned value may or may not be useful to the sending object.

For example, the School object now wants to change the student's name. It does this by sending the Student object a message to set its name to a new name. The new address is passed as an argument in the message. In this case, the School object does not care about the return value from the message.

It is very common that a message will cause other messages to be sent, either to itself or to other objects, in order to complete its task. This is called sequential operation. Control will not return to the original sending object untill all other messages have been completed.

For example, in the following diagram, Object A sends a message to Object B. For Object B to process that message it sends a message to Object C.Likewise, Object C sends a mesage to Object D. Object D returns to Object C who then returns to Object B who returns to Object A. Control does not return to Object A until all the other messages have completed.

How do receiving objects interpret messages from the senders? How are the messages processed?
Each message has code that associated with it. When an object receives a message, code is excercuted. In other words, these messages determine an object's behavior and the code determines how the object carries out each message. The code that is associated with each message is called a method. The message name is also called the method name due to its close association with the method.
When an object receives a message, it determines what method is being requested and passes control to the method. An object has as many methods as it it takes to perform its designed actions.
Refer to the following diagram, name, name:, address and name:address are method names for the Student object. When the Student object receive the name message, the name message passes control to the name method defined in Student.

Fundamental Concepts - OOP

2007-09-07T13:24:00.000+05:30

Object-oriented programming (OOP) is a programming paradigm that uses "objects" and their interactions to design applications and computer programs. It is based on several techniques, including inheritance, modularity, polymorphism, and encapsulation.

Class
A class defines the abstract characteristics of a thing (object), including the thing's characteristics (its attributes, fields or properties) and the thing's behaviors (the things it can do or methods or features). For example, the class Dog would consist of traits shared by all dogs, such as breed and fur color (characteristics), and the ability to bark (behavior). Classes provide modularity and structure in an object-oriented computer program. A class should typically be recognizable to a non-programmer familiar with the problem domain, meaning that the characteristics of the class should make sense in context. Also, the code for a class should be relatively self-contained. Collectively, the properties and methods defined by a class are called members.

Object
A particular instance of a class. The class of Dog defines all possible dogs by listing the characteristics and behaviors they can have; the object Lassie is one particular dog, with particular versions of the characteristics. A Dog has fur; Lassie has brown-and-white fur. In programmer jargon, the object Lassie is an instance of the Dog class. The set of values of the attributes of a particular object is called its state.The object consists of state and the behaviour that's defined in the object's class.

Method
An object's abilities. Lassie, being a Dog, has the ability to bark. So bark() is one of Lassie's methods. She may have other methods as well, for example sit() or eat(). Within the program, using a method should only affect one particular object; all Dogs can bark, but you need one particular dog to do the barking.

Message passing
"The process by which an object sends data to another object or asks the other object to invoke a method." Also known to some programming languages as interfacing

Inheritance
"Subclasses" are more specialized versions of a class, which inherit attributes and behaviors from their parent classes, and can introduce their own.
For example, the class Dog might have sub-classes called Collie, Chihuahua, and GoldenRetriever. In this case, Lassie would be an instance of the Collie subclass. Suppose the Dog class defines a method called bark() and a property called furColor. Each of its sub-classes (Collie, Chihuahua, and GoldenRetriever) will inherit these members, meaning that the programmer only needs to write the code for them once.
Each subclass can alter its inherited traits. For example, the Collie class might specify that the default furColor for a collie is brown-and-white. The Chihuahua subclass might specify that the bark() method produces a high-pitched by default. Subclasses can also add new members. The Chihuahua subclass could add a method called tremble(). So an individual chihuahua instance would use a high-pitched bark() from the Chihuahua subclass, which in turn inherited the usual bark() from Dog. The chihuahua object would also have the tremble() method, but Lassie would not, because she is a Collie, not a Chihuahua. In fact, inheritance is an "is-a" relationship: Lassie is a Collie. A Collie is a Dog. Thus, Lassie inherits the members of both Collies and Dogs.
Multiple inheritance is inheritance from more than one ancestor class, neither of these ancestors being an ancestor of the other. For example, independent classes could define Dogs and Cats, and a Chimera object could be created from these two which inherits all the (multiple) behavior of cats and dogs. This is not always supported, as it can be hard both to implement and to use well.

Encapsulation
Encapsulation conceals the functional details of a class from objects that send messages to it.
For example, the Dog class has a bark() method. The code for the bark() method defines exactly how a bark happens (e.g., by inhale() and then exhale(), at a particular pitch and volume). Timmy, Lassie's friend, however, does not need to know exactly how she barks. Encapsulation is achieved by specifying which classes may use the members of an object. The result is that each object exposes to any class a certain interface — those members accessible to that class. The reason for encapsulation is to prevent clients of an interface from depending on those parts of the implementation that are likely to change in future, thereby allowing those changes to be made more easily, that is, without changes to clients. For example, an interface can ensure that puppies can only be added to an object of the class Dog by code in that class. Members are often specified as public, protected or private, determining whether they are available to all classes, sub-classes or only the defining class. Some languages go further: Java uses the default access modifier to restrict access also to classes in the same package, C# and VB.NET reserve some members to classes in the same assembly using keywords internal (C#) or Friend (VB.NET), and Eiffel and C++ allows one to specify which classes may access any member.

Abstraction
Abstraction is simplifying complex reality by modeling classes appropriate to the problem, and working at the most appropriate level of inheritance for a given aspect of the problem.
For example, Lassie the Dog may be treated as a Dog much of the time, a Collie when necessary to access Collie-specific attributes or behaviors, and as an Animal (perhaps the parent class of Dog) when counting Timmy's pets.Abstraction is also achieved through Composition. For example, a class Car would be made up of an Engine, Gearbox, Steering objects, and many more components. To build the Car class, one does not need to know how the different components work internally, but only how to interface with them, i.e., send messages to them, receive messages from them, and perhaps make the different objects composing the class interact with each other.

Polymorphism
Polymorphism allows you to treat derived class members just like their parent class's members. More precisely, Polymorphism in object-oriented programming is the ability of objects belonging to different data types to respond to method calls of methods of the same name, each one according to an appropriate type-specific behavior. One method, or an operator such as +, -, or *, can be abstractly applied in many different situations. If a Dog is commanded to speak(), this may elicit a Bark. However, if a Pig is commanded to speak(), this may elicit an Oink. They both inherit speak() from Animal, but their derived class methods override the methods of the parent class; this is Overriding Polymorphism. Overloading Polymorphism is the use of one method signature, or one operator such as "+", to perform several different functions depending on the implementation. The "+" operator, for example, may be used to perform integer addition, float addition, list concatenation, or string concatenation. Any two subclasses of Number, such as Integer and Double, are expected to add together properly in an OOP language. The language must therefore overload the concatenation operator, "+", to work this way. This helps improve code readability. How this is implemented varies from language to language, but most OOP languages support at least some level of overloading polymorphism. Many OOP languages also support Parametric Polymorphism, where code is written without mention of any specific type and thus can be used transparently with any number of new types. Pointers are an example of a simple polymorphic routine that can be used with many different types of objects.

Not all of the above concepts are to be found in all object-oriented programming languages, and so object-oriented programming that uses classes is called sometimes class-based programming. In particular, prototype-based programming does not typically use classes. As a result, a significantly different yet analogous terminology is used to define the concepts of object and instance, although there are no objects in these languages.

Differences Between C and Java

2007-09-04T14:54:00.001+05:30

If you are a C or C++ programmer, you should have found much of the syntax of Java--particularly at the level of operators and statements--to be familiar. Because Java and C are so similar in some ways, it is important for C and C++ programmers to understand where the similarities end. There are a number of important differences between C and Java, which are summarized in the following list:

No preprocessor

Java does not include a preprocessor and does not define any analogs of the #define, #include, and #ifdef directives. Constant definitions are replaced with staticfinal fields in Java. (See the java.lang.Math.PI field for an example.) Macro definitions are not available in Java, but advanced compiler technology and inlining has made them less useful. Java does not require an #include directive because Java has no header files. Java class files contain both the class API and the class implementation, and the compiler reads API information from class files as necessary. Java lacks any form of conditional compilation, but its cross-platform portability means that this feature is very rarely needed.

No global variables

Java defines a very clean namespace. Packages contain classes, classes contain fields and methods, and methods contain local variables. But there are no global variables in Java, and, thus, there is no possibility of namespace collisions among those variables.

Well-defined primitive type sizes

All the primitive types in Java have well-defined sizes. In C, the size of short, int, and long types is platform-dependent, which hampers portability.

No pointers

Java classes and arrays are reference types, and references to objects and arrays are akin to pointers in C. Unlike C pointers, however, references in Java are entirely opaque. There is no way to convert a reference to a primitive type, and a reference cannot be incremented or decremented. There is no address-of operator like &, dereference operator like * or −>, or sizeof operator. Pointers are a notorious source of bugs. Eliminating them simplifies the language and makes Java programs more robust and secure.

Garbage collection

The Java Virtual Machine performs garbage collection so that Java programmers do not have to explicitly manage the memory used by all objects and arrays. This feature eliminates another entire category of common bugs and all but eliminates memory leaks from Java programs.

No goto statement

Java doesn't support a goto statement. Use of goto except in certain well-defined circumstances is regarded as poor programming practice. Java adds exception handling and labeled break and continue statements to the flow-control statements offered by C. These are a good substitute for goto.

Variable declarations anywhere

C requires local variable declarations to be made at the beginning of a method or block, while Java allows them anywhere in a method or block. Many programmers prefer to keep all their variable declarations grouped together at the top of a method, however.

Forward references

The Java compiler is smarter than the C compiler, in that it allows methods to be invoked before they are defined. This eliminates the need to declare functions in a header file before defining them in a program file, as is done in C.

Method overloading

Java programs can define multiple methods with the same name, as long as the methods have different parameter lists.

No struct and union types

Java doesn't support C struct and union types. A Java class can be thought of as an enhanced struct, however.

No enumerated types

Java doesn't support the enum keyword used in C to define types that consist of fixed sets of named values. This is surprising for a strongly typed language like Java, but there are ways to simulate this feature with object constants.

No bitfields

Java doesn't support the (infrequently used) ability of C to specify the number of individual bits occupied by fields of a struct.

No typedef

Java doesn't support the typedef keyword used in C to define aliases for type names. Java's lack of pointers makes its type-naming scheme simpler and more consistent than C's, however, so many of the common uses of typedef are not really necessary in Java.

No method pointers

C allows you to store the address of a function in a variable and pass this function pointer to other functions. You cannot do this with Java methods, but you can often achieve similar results by passing an object that implements a particular interface. Also, a Java method can be represented and invoked through a java.lang.reflect.Method object.

No variable-length argument lists

Java doesn't allow you to define methods such as C's printf() that take a variable number of arguments. Method overloading allows you to simulate C varargs functions for simple cases, but there's no general replacement for this feature.

Differences Between Java and C/C++

2007-09-04T14:46:00.000+05:30

The Preprocessor
Pointers
Structures and Unions
Functions
Multiple Inheritance
Strings
The goto Statement
Operator Overloading
Automatic Coercions
Variable Arguments
Command-Line Arguments

It is no secret that the Java language is highly derived from the C and C++ languages. Because C++ is currently considered the language of choice for professional software developers, it's important to understand what aspects of C++ Java inherits. Of possibly even more importance are what aspects of C++ Java doesn't support. Because Java is an entirely new language, it was possible for the language architects to pick and choose which features from C++ to implement in Java and how.

The focus of this appendix is to point out the differences between Java and C++. If you are a C++ programmer, you will be able to appreciate the differences between Java and C++. Even if you don't have any C++ experience, you can gain some insight into the Java language by understanding what C++ discrepancies it clears up in its implementation. Because C++ backwardly supports C, many of the differences pointed out in this appendix refer to C++, but inherently apply to C as well.

The Preprocessor

All C/C++ compilers implement a stage of compilation known as the preprocessor. The C++ preprocessor basically performs an intelligent search and replace on identifiers that have been declared using the #define or #typedef directives. Although most advocates of C++ discourage the use of the preprocessor, which was inherited from C, it is still widely used by most C++ programmers. Most of the processor definitions in C++ are stored in header files, which complement the actual source code files.

The problem with the preprocessor approach is that it provides an easy way for programmers to inadvertently add unnecessary complexity to a program. What happens is that many programmers using the #define and #typedef directives end up inventing their own sublanguage within the confines of a particular project. This results in other programmers having to go through the header files and sort out all the #define and #typedef information to understand a program, which makes code maintenance and reuse almost impossible. An additional problem with the preprocessor approach is that it is weak when it comes to type checking and validation.

Java does not have a preprocessor. It provides similar functionality (#define, #typedef, and so on) to that provided by the C++ preprocessor, but with far more control. Constant data members are used in place of the #define directive, and class definitions are used in lieu of the #typedef directive. The result is that Java source code is much more consistent and easier to read than C++ source code. Additionally, Java programs don't use header files; the Java compiler builds class definitions directly from the source code files, which contain both class definitions and method implementations.

Pointers

Most developers agree that the misuse of pointers causes the majority of bugs in C/C++ programming. Put simply, when you have pointers, you have the ability to trash memory. C++ programmers regularly use complex pointer arithmetic to create and maintain dynamic data structures. In return, C++ programmers spend a lot of time hunting down complex bugs caused by their complex pointer arithmetic.

The Java language does not support pointers. Java provides similar functionality by making heavy use of references. Java passes all arrays and objects by reference. This approach prevents common errors due to pointer mismanagement. It also makes programming easier in a lot of ways simply because the correct usage of pointers is easily misunderstood by all but the most seasoned programmers.

You may be thinking that the lack of pointers in Java will keep you from being able to implement many data structures, such as dynamic arrays. The reality is that any pointer task can be carried out just as easily and more reliably with objects and arrays of objects. You then benefit from the security provided by the Java runtime system; it performs boundary checking on all array indexing operations.

Structures and Unions

There are three types of complex data types in C++: classes, structures, and unions. Java only implements one of these data types: classes. Java forces programmers to use classes when the functionality of structures and unions is desired. Although this sounds like more work for the programmer, it actually ends up being more consistent, because classes can imitate structures and unions with ease. The Java designers really wanted to keep the language simple, so it only made sense to eliminate aspects of the language that overlapped.

Functions

In C, code is organized into functions, which are global subroutines accessible to a program. C++ added classes and in doing so provided class methods, which are functions that are connected to classes. C++ class methods are very similar to Java class methods. However, because C++ still supports C, there is nothing discouraging C++ programmers from using functions. This results in a mixture of function and method use that makes for confusing programs.

Java has no functions. Being a purer object-oriented language than C++, Java forces programmers to bundle all routines into class methods. There is no limitation imposed by forcing programmers to use methods instead of functions. As a matter of fact, implementing routines as methods encourages programmers to organize code better. Keep in mind that strictly speaking there is nothing wrong with the procedural approach of using functions; it just doesn't mix well with the object-oriented paradigm that defines the core of Java.

Multiple Inheritance

Multiple inheritance is a feature of C++ that allows you to derive a class from multiple parent classes. Although multiple inheritance is indeed powerful, it is complicated to use correctly and causes many problems otherwise. It is also very complicated to implement from the compiler perspective.

Java takes the high road and provides no direct support for multiple inheritance. You can implement functionality similar to multiple inheritance by using interfaces in Java. Java interfaces provide object method descriptions but contain no implementations.

Strings

C and C++ have no built-in support for text strings. The standard technique adopted among C and C++ programmers is that of using null-terminated arrays of characters to represent strings.

In Java, strings are implemented as first class objects (String and StringBuffer), meaning that they are at the core of the Java language. Java's implementation of strings as objects provides several advantages:

The manner in which you create strings and access the elements of strings is consistent across all strings on all systems
Because the Java string classes are defined as part of the Java language and not part of some extraneous extension, Java strings function predictably every time
The Java string classes perform extensive runtime checking, which helps eliminate troublesome runtime errors

The goto Statement

The dreaded goto statement is pretty much a relic these days even in C and C++, but it is technically a legal part of the languages. The goto statement has historically been cited as the cause for messy, impossible to understand, and sometimes even impossible to predict code known as "spaghetti code." The primary usage of the goto statement has merely been as a convenience to substitute not thinking through an alternative, more structured branching technique.

For all these reasons and more, Java does not provide a goto statement. The Java language specifies goto as a keyword, but its usage is not supported. I suppose the Java designers wanted to eliminate the possibility of even using goto as an identifier! Not including goto in the Java language simplifies the language and helps eliminate the option of writing messy code.

Operator Overloading

Operator overloading, which is considered a prominent feature in C++, is not supported in Java. Although roughly the same functionality can be implemented by classes in Java, the convenience of operator overloading is still missing. However, in defense of Java, operator overloading can sometimes get very tricky. No doubt the Java developers decided not to support operator overloading to keep the Java language as simple as possible.

Automatic Coercions

Automatic coercion refers to the implicit casting of data types that sometimes occurs in C and C++. For example, in C++ you can assign a float value to an int variable, which can result in a loss of information. Java does not support C++ style automatic coercions. In Java, if a coercion will result in a loss of data, you must always explicitly cast the data element to the new type.

Variable Arguments

C and C++ let you declare functions, such as printf, that take a variable number of arguments. Although this is a convenient feature, it is impossible for the compiler to thoroughly type check the arguments, which means problems can arise at runtime without you knowing. Again Java takes the high road and doesn't support variable arguments at all.

Command-Line Arguments

The command-line arguments passed from the system into a Java program differ in a couple of ways from the command-line arguments passed into a C++ program. First, the number of parameters passed differs between the two languages. In C and C++, the system passes two arguments to a program: argc and argv. argc specifies the number of arguments stored in argv. argv is a pointer to an array of characters containing the actual arguments. In Java, the system passes a single value to a program: args. args is an array of Strings that contains the command-line arguments. In C and C++, the command-line arguments passed into a program include the name used to invoke the program. This name always appears as the first argument and is rarely ever used. In Java, you already know the name of the program because it is the same name as the class, so there is no need to pass this information as a command-line argument. Therefore, the Java runtime system only passes the arguments following the name that invoked the program.

Abstraction

2007-09-04T14:32:00.000+05:30

"An abstraction denotes the essential characteristics of an
object that distinguish it from all other kinds of object and thus
provide crisply defined conceptual boundaries, relative to the
perspective of the viewer."

-- [Booch, 1991]



"[A] simplified description, or specification, of a system that
emphasizes some of the system's details or properties while
suppressing others. A good abstraction is one that emphasizes
details that are significant to the reader or user and suppress
details that are, at least for the moment, immaterial or
diversionary."

-- [Shaw, 1984]


Abstraction, as a process, denotes the extracting of the essential
details aboutan item, or a group of items,while ignoring the
inessential details.

Abstraction, as an entity,
denotes a model, a view, or some other focused representation for
an actual item. Abstraction is most often used as a complexity
mastering technique.


Abstraction refers to the act of representing essential features
without including the background details or explanations.
Classes use the concept of abstraction and are defined as a
list of abstract attributes.

Example:

An electrician and an interior decorator will look at the same building each in two different ways. The decorator will probably view the building primarily as a series of rooms. However, the electrician will view it as a series of walls and floors. Walls are in both their views, but serve a different purpose, have a different priority, and relate in different ways.

Thus, the "abstraction" used by the decorator may be rooms which are composed/comprised of walls and floors/ceilings. But the electrician's view may have the walls be the primary abstraction, with room information incidental, perhaps only to locate the proper wall when walking around.

Further, in the electrician's view, walls are a complex 3D structure with their own little world inside, while the interior decorator may view them mostly as 2D flat panels. Both have walls in their mental abstractions, but view and relate them differently.

Object Oriented Typing

2007-09-04T14:26:00.000+05:30

The concept of type is more or less important in a language, depending on whether the language is strongly or weakly (or not at all) typed.

In strongly typed languages, the compiler prevents you from mixing different kinds of data together. This is limiting, but can be very helpful when you want to avoid putting a string, say, into the floating point value for the altitude of an airplane’s automatic pilot.

In OO languuages, type is a synonym for class, at least as a first cut. In fact, class and type are quite distinct. A more nuanced understanding of type is one of the things that distinguishes a shallow from a deep understanding of OO design and programming.

Type defines the properties and behaviors shared by all objects of the same type (class).

OO languages can run the range of un-typed, weakly typed, or strongly typed.

The advantage of strongly typed languages is that the compiler can detect when an object is being sent a message to which it does not respond. This can prevent run-time errors. The other advantages of strong typing are:

earlier detection of errors speeds development
better optimized code from compiler
no run-time penalty for determining type

The disadvantages of strong typing are:

loss of some flexibility
more difficult to define collections of heterogenous objects

C++ maintains strong class typing. An object may only be sent a message containing a method that is defined in the object’s class, or in any of the classes that this object inherits from. The compiler checks that you obey this.
Objective C support strong typing, but it also allows for weak typing. A special type, id, can be used for object handles. An id can be a handle to any class of object, thus it has no typing information, and the compiler can’t check if you are sending proper messages. This is done instead at run-time.

Program Execution

2007-09-03T13:12:00.000+05:30

The topology of a structure program is inherently different than the topology of an OO program. Modules are nested into a calling tree, as shown below:

By contrast, the topology of an OO program is inherently less ordered. Objects cluster together by those which communicate most frequently. Inter-cluster messages exist, but are less common than intra-cluster messages. Notice how much like a computer network this topology looks.

Object Model

2007-09-03T13:09:00.000+05:30

The object model has many facets. Here are the ones you’ll eventually have to understand to be mature OO developers. Note that these aren’t “OO” concepts. There is however a way of thinking about and understanding them in an OO context.

Abstraction, Encapsulation, Identity, Modularity, Hierarchy, Typing, Concurrency, Persistence
This is initially a scary, rather monstrous task. We’ll take them iteratively, in keeping with our OO development methodology.

Simple C++ Quiz

2007-09-01T20:36:00.000+05:30

Computer memory is called RAM because:
•
[A] It provides rapid access to data
•
[B] It is mounted on the motherboard
•
[C] It is measured in megabytes
•
[D] Its bytes can be addressed in random order (correct answer)
•
[E] Its chips are mounted in a rectangular array

What is the debugger used for?
•
[A] Removing comments from the source code
•
[B] Running and tracing programs in a controlled way (correct answer)
•
[C] Running diagnostics of hardware components
•
[D] Removing syntax errors from C++ programs
•
[E] Removing dust from the computer screen

Which program helps programmers create and modify source code?
•
[A] Editor (correct answer)
•
[B] Make
•
[C] Compiler
•
[D] Linker
•
[E] None of the above

Which program converts source code into object modules?
•
[A] Editor
•
[B] Make
•
[C] Compiler (correct answer)
•
[D] Linker
•
[E] None of the above

Which program converts object modules into an executable program?
•
[A] Editor
•
[B] Make
•
[C] Compiler
•
[D] Linker (correct answer)
•
[E] None of the above

Data files read by a program are read when that program is:
•
[A] Compiled
•
[B] Linked
•
[C] Loaded into RAM
•
[D] Executed (correct answer)
•
[E] Run for the first time

The complexity of a program is often measured by:
•
[A] The number of lines in the source file (correct answer)
•
[B] The time it took to write it
•
[C] The time it takes to run
•
[D] The number of data files it reads
•
[E] None of the above

How many reserved words are there in C++?
•
[A] 5-10
•
[B] 15-20
•
[C] 25-50 (correct answer)
•
[D] Over 100
•
[E] All words that start with a #

True or False: CPU instructions are stored in a special area of computer memory reserved for all programs.
•
[A] True
•
[B] False (correct answer)

You are hired to write a gradebook program. What is the first step in developing this program?
•
[A] Create the exact program specifications (correct answer)
•
[B] Create the necessary algorithms
•
[C] Create a "stubs" program to check for global execution flow
•
[D] Gather all the necessary grades and other input files
•
[E] Write the main body of the program with function calls for all the major modules

Consider the following statement: (Blank) is the concept of thinking about programming features and using programming features without concern, or knowledge about the implementation of such features.
•
[A] information hiding (correct answer)
•
[B] top-down design and step-wise refinement
•
[C] object oriented programming
•
[D] data abstraction
•
[E] encapsulation

A team of programmers works together on a large project. Each individual team member is assigned to create, write, and test a large function. Which of the following is required information for each programmer to complete his/her assigned task?
I: Complete program specifications, including any input/output requiremens
II: Preconditions and postconditions of the assigned function
III: Parameter list of the assigned function that interfaces with the rest of the program
•
[A] I only
•
[B] II only
•
[C] III only
•
[D] II and III only (correct answer)
•
[E] I, II, and III

True or False: The char data type is used for variables that hold character strings.
•
[A] True
•
[B] False (correct answer)

True or False: The typedef statement is used to define the size of variables of a particular built-in type.
•
[A] True
•
[B] False (correct answer)

True or False: The same name can be used for an integer and a double variable in the same function.
•
[A] True
•
[B] False (correct answer)

True or False: Each variable must be declared on a separate line.
•
[A] True
•
[B] False (correct answer)

All variables must always be declared at the top of the function's body.
•
[A] True
•
[B] False (correct answer)

True or False: It is considered a good practice for a beginning programmer to use only global variables.
•
[A] True
•
[B] False (correct answer)

True or False: It is acceptable to use the same name for local variables in different functions.
•
[A] True (correct answer)
•
[B] False

Quiz: C++ File I/O

2007-09-01T20:26:00.000+05:30

1. Which of the following classes handlers file input?
A. ofstream
B. ifstream
C. instream
D. inputfile

2. Which of the following is not a valid ofstream argument?
A. ios::app
B. ios::trunc
C. ios::noreplace
D. ios::create

3. What does ios::ate mean as an argument to ofstream?
A. Open file, but do not create.
B. Open file, create.
C. Open file for read access only.
D. Open file, set the position to the end.

4. How would you output to an open file named a_file?
A. a_file.out("Output");
B. a_file="Output";
C. a_file<<"Output";
D. a_file.printf("Output");

5. What header file contains C++ file I/O instructions?
A. iostream.h
B. fstream.h
C. infstream.h
D. outstream.h

C++ Quiz

2007-09-01T20:05:00.000+05:30

Question 1
Can you name the special functions a C++ compiler can create implicitly?

Question 2
What are the two ways to achieve automatic type conversion from type X to type Y?

Question 3
Which of one of these represents an assignment operation?
1. C c1 = c2;
2. c3 = c4;
3. both

Answers

Answer to question 1
The four special functions that may be generated by the compiler are:
1. the default constructor
2. the copy constructor
3. the operator=() function
4. the destructor

Answer to question 2
X can define the member function operator Y()
Y can define the constructor Y(const X&)

Answer to question 3
c3 = c4 is an assignment
C c1 = c2 is a copy-construction

Pointers

2007-08-31T13:35:00.000+05:30

Pointers - Definition

Pointers provide an indirect method of accessing variables. The reason why pointers are hard to understand is because they aren't taught in a manner that is understandable. Think for a minute about a typical textbook. It will usually have a table of contents, some chapters, and an index. What if you were looking in the 'C' book for information on printf? You'd look at the index for printf. The index will tell you where information on printf is located within the book. Conceptually, this is how pointers work! Re-read this analogy if you didn't get it the first time. This is important. You must understand that pointers are indirect references.
You may be wondering, what is the point of this ? Why don't I just make all variables without the use of pointers? It's because sometimes you can't. What if you needed an array of ints, but didn't know the size of the array before hand? What if you needed a string, but it grew dynamically as the program ran? What if you need variables that are persistent through function use without declaring them global ? They are all solved through the use of pointers. Pointers are also essential in creating larger custom data structures, such as linked lists.
So now that you understand how pointers work, let's define them a little better.
- A pointer when declared is just a reference. DECLARING A POINTER DOES NOT CREATE ANY SPACE FOR THE POINTER TO POINT TO. The main purpose of pointers is to allocate memory dynamically (Dynamic Memory Allocation).
- A pointer is a reference to an area of memory in the heap. The heap is a dynamically allocated area of memory when the program runs.

void Pointers

void pointers can be assigned to any pointer value. It sometimes necessary to store/copy/move pointers without regard to the type it references.
You cannot dereference a void pointer.
Functions such as malloc, free, and scanf utilize void pointers.

Arrays

2007-08-29T21:48:00.000+05:30

In this section, we will create a small C program that generates 10 random numbers and sorts them. To do that, we will use a new variable arrangement called an array.

An array lets you declare and work with a collection of values of the same type. For example, you might want to create a collection of five integers. One way to do it would be to declare five integers directly:
int a, b, c, d, e;
This is okay, but what if you needed a thousand integers? An easier way is to declare an array of five integers:
int a[5];
The five separate integers inside this array are accessed by an index. All arrays start at index zero and go to n-1 in C. Thus, int a[5]; contains five elements. For example:
int a[5];

a[0] = 12;
a[1] = 9;
a[2] = 14;
a[3] = 5;
a[4] = 1;
One of the nice things about array indexing is that you can use a loop to manipulate the index. For example, the following code initializes all of the values in the array to 0:
int a[5];
int i;

for (i=0; i<5;> The following code initializes the values in the array sequentially and then prints them out:
#include
int main()
{
int a[5];
int i;
for (i=0; i<5; i="0;">

Arrays are used all the time in C. To understand a common usage, start an editor and enter the following code: #include
#define MAX 10
int a[MAX];
int rand_seed=10;
/* from K&R
- returns random number between 0 and 32767.*/
int rand()
{
rand_seed = rand_seed * 1103515245 +12345;
return (unsigned int)(rand_seed / 65536) % 32768;
}

int main()
{
int i,t,x,y;
/* fill array */
for (i=0; i <>
{
a[i]=rand();
printf("%d\n",a[i]);
} /* more stuff will go here in a minute */
return 0;
}

This code contains several new concepts. The #define line declares a constant named MAX and sets it to 10. Constant names are traditionally written in all caps to make them obvious in the code. The line int a[MAX]; shows you how to declare an array of integers in C. Note that because of the position of the array's declaration, it is global to the entire program. The line int rand_seed=10 also declares a global variable, this time named rand_seed, that is initialized to 10 each time the program begins. This value is the starting seed for the random number code that follows.

In a real random number generator, the seed should initialize as a random value, such as the system time. Here, the rand function will produce the same values each time you run the program. The line int rand() is a function declaration. The rand function accepts no parameters and returns an integer value. We will learn more about functions later. The four lines that follow implement the rand function. We will ignore them for now. The main function is normal. Four local integers are declared, and the array is filled with 10 random values using a for loop. Note that the array a contains 10 individual integers. You point to a specific integer in the array using square brackets.

So a[0] refers to the first integer in the array, a[1] refers to the second, and so on. The line starting with /* and ending with */ is called a comment. The compiler completely ignores the line. You can place notes to yourself or other programmers in comments. Now add the following code in place of the more stuff ... comment:

/* bubble sort the array */
for (x=0; x <>
for (y=0; y <>
if (a[y] > a[y+1])
{
t=a[y];
a[y]=a[y+1];
a[y+1]=t;
}
/* print sorted array */
printf("--------------------\n");
for (i=0; i <>
This code sorts the random values and prints them in sorted order. Each time you run it, you will get the same values. If you would like to change the values that are sorted, change the value of rand_seed each time you run the program.

The only easy way to truly understand what this code is doing is to execute it "by hand." That is, assume MAX is 4 to make it a little more manageable, take out a sheet of paper and pretend you are the computer. Draw the array on your paper and put four random, unsorted values into the array. Execute each line of the sorting section of the code and draw out exactly what happens. You will find that, each time through the inner loop, the larger values in the array are pushed toward the bottom of the array and the smaller values bubble up toward the top.

Quiz: The basics of C++

2007-08-29T21:46:00.000+05:30

1. What is the correct value to return to the operating system upon the successful completion of a program?
A. -1
B. 1
C. 0
D. Programs do not return a value.

2. What is the only function all C++ programs must contain?
A. start()
B. system()
C. main()
D. program()

3. What punctuation is used to signal the beginning and end of code blocks?
A. { }
B. -> and <-
C. BEGIN and END
D. ( and )

4. What punctuation ends most lines of C++ code?
A. .
B. ;
C. :
D. '

5. Which of the following is a correct comment?
A. */ Comments */
B. ** Comment **
C. /* Comment */
D. { Comment }

6. Which of the following is not a correct variable type?
A. float
B. real
C. int
D. double

7. Which of the following is the correct operator to compare two variables?
A. :=
B. =
C. equal
D. ==

Memory Leak in C Program

2007-08-28T15:01:00.000+05:30

Why do we need to test weather it is memory leak or not?

How are we going to know that?
Possibilities are:

1) Array will print "Garbage Value"

2) Message by the Compiler!

Because size of heap memory will be reduced and leaked memory can not be assigned to other processes running simultaneously in a multiprogramming environment. Throughput will go down.

Introduction to EJB 3.0

2007-08-28T10:45:00.000+05:30

Introduction to Enterprise JavaBeans 3.0
by Lynn Munsinger

==============================================================

The EJB 3.0 specification makes it easier than ever to develop Enterprise JavaBeans, perhaps encouraging you to consider developing EJBs for the first time. If that is the case, congratulations, you have successfully avoided the many pitfalls of EJB developers before you, and can enjoy the ease of EJB 3.0 development. But before you start development, you might want to know what Enterprise JavaBeans are and what purpose they serve. This article explains the basics of EJBs and how you can utilize them in a J2EE application.
What is an EJB?

An Enterprise JavaBean (EJB) is a reusable, portable J2EE component. EJBs consist of methods that encapsulate business logic. For example, an EJB may have business logic that contains a method to update customer data in a database. A variety of remote and local clients can invoke this method. Additionally, EJBs run inside a container, allowing the developer to focus on the business logic contained in the bean without having to worry about complicated and error-prone issues such as transaction support, security, and remote object access. EJBs are developed as POJOs, or Plain Old Java Objects, and developers can use metadata annotations to specify to the container how these beans are to be managed.
Types of EJBs

EJBs consist of three main types: Session, Entity, and Message-Driven. A Session bean performs a distinct, de-coupled task, such as checking credit history for a customer. An Entity bean is a complex business entity which represents a business object that exists in the database. A Message-Driven bean is used to receive asynchronous JMS messages. Let's examine these types further:
Session Beans

Session beans generally represent actions in the business process such as "process order." Session beans are classified based on the maintenance of the conversation state, either stateful or stateless.

Stateless session beans do not have an internal state. They do not keep track of the information that is passed from one method call to another. Thus, each invocation of a stateless business method is independent of its previous invocation; for example, calculating taxes or shipping charges. When a method to calculate tax charges is invoked with a certain taxable value, the tax value is calculated and returned to the calling method, without the necessity to store the caller's internal state for future invocation. Because they do not maintain state, these beans are simple to manage for the container. When the client requests a stateless bean instance, it may receive an instance from the pool of stateless session bean instances that are maintained by the container. Also, because stateless session beans can be shared, the container can maintain a lesser number of instances to serve a large number of clients. To specify that a Java Bean is to be deployed and managed as a stateless session bean, simply add the annotation @Stateless to the bean.

A stateful session bean maintains a conversational state across method invocations; for example, an online shopping cart of a customer. When the customer starts online shopping, the customer's details are retrieved from the database. The same details are available for the other methods that are invoked when the customer adds or removes items from the cart, places the order, and so on. Yet, stateful session beans are transient because the state does not survive session termination, system crash, or network failure. When a client requests a stateful session bean instance, that client is assigned one stateful instance, and the state of the bean is maintained for that client. To specify to the container that a stateful session bean instance should be removed upon the completion of a certain method, add the annotation @Remove to the method.
Session Bean Example

import javax.ejb.Stateless.*;

/**
* A simple stateless session bean implementing the incrementValue() method of the * CalculateEJB interface.
*/

@Stateless(name="CalculateEJB")
public class CalculateEJBBean
implements CalculateEJB
{
int value = 0;
public String incrementValue()
{
value++;
return "value incremented by 1";
}
}

Entity Beans

An entity bean is an object that manages persistent data, potentially uses several dependent Java objects, and can be uniquely identified by a primary key. Specify that a class is an entity bean by including the @Entity annotation. Entity beans represent persistent data from the database, such as a row in a customer table, or an employee record in an employee table. Entity beans are also sharable across multiple clients. For example, an employee entity bean can be used by various clients to calculate the annual salary of an employee or to update the employee address. Specific fields of the entity bean object can be made persistent. All fields in the entity bean not marked with the @Transient annotation are considered persistent. A key feature of EJB 3.0 is the ability to create Entity beans which contain object/relational mappings using metadata annotations. For example, to specify that an Entity bean's empId field is mapped to the EMPNO attribute of the Employees table, annotate the table name using @Table(name="Employees") and the field using @Column(name="EMPNO"), as shown in the example below. Additionally, a special feature of EJB 3.0 is that you can easily test Entity beans during development, as running Entity beans outside a container is now possible using the Oracle Application Server Entity Test Harness.
Entity Bean Example

import javax.persistence.*;
import java.util.ArrayList;
import java.util.Collection;

@Entity
@Table(name = "EMPLOYEES")
public class Employee implements java.io.Serializable
{
private int empId;
private String eName;
private double sal;

@Id
@Column(name="EMPNO", primaryKey=true)
public int getEmpId()
{
return empId;
}

public void setEmpId(int empId)
{
this.empId = empId;
}

public String getEname()
{
return eName;
}

public void setEname(String eName)
{
this.eName = eName;
}

public double getSal()
{
return sal;
}

public void setSal(double sal)
{
this.sal = sal;
}

public String toString()
{
StringBuffer buf = new StringBuffer();
buf.append("Class:")
.append(this.getClass().getName()).append(" :: ").append(" empId:").append(getEmpId()).append(" ename:").append(getEname()).append("sal:").append(getSal());
return buf.toString();
}
}

Message-Driven Beans

Message-driven beans (MDBs) provide an easier method to implement asynchronous communication than by using straight Java Message Services (JMS). MDBs were created to receive asynchronous JMS messages. The container handles most of the setup processes that are required for JMS queues and topics. It sends all the messages to the interested MDB. An MDB allows J2EE applications to send asynchronous messages that can then be processed by the application. To specify that a bean is an MDB, implement the javax.jms.MessageListener interface and annotate the bean with @MessageDriven.
Message Driven Bean Example

import javax.ejb.MessageDriven;
import javax.ejb.ActivationConfigProperty;
import javax.ejb.Inject;
import javax.jms.*;
import java.util.*;
import javax.ejb.TimedObject;
import javax.ejb.Timer;
import javax.ejb.TimerService;
@MessageDriven(
activationConfig = {
@ActivationConfigProperty(propertyName="connectionFactoryJndiName", propertyValue="jms/TopicConnectionFactory"),
@ActivationConfigProperty(propertyName="destinationName", propertyValue="jms/myTopic"),
@ActivationConfigProperty(propertyName="destinationType", propertyValue="javax.jms.Topic"),
@ActivationConfigProperty(propertyName="messageSelector", propertyValue="RECIPIENT = 'MDB'")
}
)

/**
* A simple Message-Driven Bean that listens to the configured JMS Queue or Topic and gets notified via an * invocation of it's onMessage() method when a message has been posted to the Queue or Topic. The bean
* prints the contents of the message.
*/

public class MessageLogger implements MessageListener, TimedObject
{

@Inject javax.ejb.MessageDrivenContext mc;

public void onMessage(Message message)
{
System.out.println("onMessage() - " + message);
try
{
String subject = message.getStringProperty("subject");
String inmessage = message.getStringProperty("message");
System.out.println("Message received\n\tDate: " + new java.util.Date() + "\n\tSubject: " + subject + "\n\tMessage: " + inmessage + "\n");
System.out.println("Creating Timer a single event timer");
TimerService ts = mc.getTimerService();
Timer timer = ts.createTimer(30000, subject);
System.out.println("Timer created by MDB at: " + new Date(System.currentTimeMillis()) +" with info: "+subject);
}
catch (Throwable ex)
{
ex.printStackTrace();
}
}

public void ejbTimeout(Timer timer)
{
System.out.println("EJB 3.0: Timer with MDB");
System.out.println("ejbTimeout() called at: " + new Date(System.currentTimeMillis()));
return;
}
}

Utilizing EJBs

An EJB client is the application that accesses the bean. It does not necessarily reside on the client tier, but can be a stand-alone application, JSP, servlet, or another EJB. The client accesses the methods of an EJB through the remote or local interfaces of the bean, depending on whether the client resides in the same or a different JVM than the bean. These interfaces define the methods of the bean, while the bean class actually implements the methods. When a client accesses a method of the bean class, the container generates a proxy for the bean, called the remote or local object. The remote or local object receives the request, delegates it to the corresponding bean instance, and returns the results to the client. To invoke a bean's methods, a client finds the bean by using its name defined in the EJB deployment descriptor. In the following example, the client finds the bean named "Statelessejb" using the Context object.
EJB Client Example

import javax.naming.Context;
import javax.naming.InitialContext;

/**
* A simple bean client which calls methods on a stateless session bean.
*/

public class CalculateejbClient
{
public static void main(String [] args)
{
Context context = new InitialContext();
CalculateEJB myejb =
(CalculateEJB)context.lookup("java:comp/env/ejb/CalculateEJB");
myejb.incrementValue();
}
}

Summary

Developing Enterprise JavaBeans is significantly easier with the EJB 3.0 specification. The specification uses metadata annotations to define the type of bean and the methods exposed to the client. Thus, whether you are creating a session bean for executing a specific task or mapping a table to an entity bean for updating data, you can do so using plain Java objects and interfaces, and expose methods for clients by using annotations within the business methods. Now that you have an understanding of the basics of EJBs, refer to OTN's EJB 3.0 Resources Page for more information.

Oracle 9i JDBC Guide

2007-08-28T10:41:00.000+05:30

Oracle9i JDBC Developer's Guide and Reference
Release 2 (9.2) - to get this click on this link or paste this link on the browser address bar.

http://download-west.oracle.com/docs/cd/B10501_01/java.920/a96654/toc.htm

Connecting the Java World to Grid-Enabled Databases

2007-08-28T10:29:00.001+05:30

Grid computing is not necessarily a new concept; however, its adoption within the enterprise has given birth to a new concept called enterprise grid computing, which is being embraced by the entire IT industry. Enterprise grid computing aims to consolidate IT resources - including both infrastructure software and applications - and optimize their usage, cutting costs substantially along the way. Since Java and J2EE are widely used as enterprise software platforms, how do they align with this vision?

This article outlines a set of challenges that JDBC faces as the database connectivity layer within enterprise grid environments and illustrates how the Oracle Database 10g JDBC driver addresses these challenges. First, I'll introduce the concept of enterprise grid computing; then I'll examine how Java and J2EE operate in grid environments and identify their database connectivity requirements; and finally, I'll discuss the features of the Oracle Database 10g JDBC driver that address those requirements.

Enterprise Grid Computing
Commercial software vendors use an assortment of terms, such as utility computing, on-demand computing, and autonomic computing, to describe enterprise grid computing. Regardless of which term is used, products that support enterprise grid computing all have the same set of common functional denominators:

* Resource consolidation
* Resource virtualization
* Policy-based resource management
* Provisioning or allocation

The chief aim of enterprise grid computing, as noted above, is to help enterprises consolidate IT resources and optimize usage, reducing infrastructure and labor costs. This is a slight but important divergence from the original concept of grid computing now classified as academic grid computing, in which massive arrays of computational power are constructed from a network of many small and widespread computers, and used to perform large calculations and operations broken in autonomous chunks that can't be achieved even on today's largest supercomputers. A good example of this is the SETI@home project.

The convergence of recent hardware and software advances has made resource virtualization possible and allowed the enterprise grid to be constructed. On the hardware side, these advances include networked storage devices (like storage grids) and low-cost, modular hardware components (such as blades); on the software side, they include improvements in networking, Web services, databases, application servers, and management frameworks.

Although no specific enterprise grid computing standards have been established, there is a general move toward the concept of service-oriented architectures (SOA), which are based on and make extensive use of existing Web services standards and specifications. SOA makes it possible to construct architectures where client applications can simply register, discover, and use the services deployed over the grid. This move is spearheaded by academic and research proposals such as the Open Grid Service Architecture (Global Grid Forum) and middleware vendors through participation in Web services standards bodies. A new consortium, Enterprise Grid Alliance, has been formed with the goals of developing enterprise grid solutions and accelerating the deployment of grid computing in enterprises.

Figure 1 illustrates a typical enterprise grid platform. While a complete enterprise grid computing discussion is beyond the scope of this article, I hope I've given enough information to encourage you to learn more about it.

Java and J2EE Containers in the Enterprise Grid
Very few enterprises run their business with just stand-alone Java or J2EE servers. Typical business applications employ more complex architectures consisting of load balancers, HTTP listeners, Web caching servers, J2EE containers, directory servers, resource managers and monitors, and management services.

In recognition of this, vendors, such as Oracle with its Oracle Application Server 10g, are actively supplementing their infrastructure with provisioning, monitoring, registering, discovering, and manageability mechanisms. This allows them to be used in the more complex system architectures required by modern SOA-based business applications.

Similarly, the J2EE world, realizing that it needs to broaden its support to interoperate with other applications and environments in a loosely coupled manner, is aligning with enterprise grid computing and SOA concepts. It's doing this by including core Web services standards (such as SOAP, WSDL, UDDI, and JAX-RPC) and numerous other Web services specifications including WS-I, WSIF, security, transaction, reliable messaging, events, peer-discovery, policy, orchestration, choreography, provisioning, and service-level agreement.

In the scientific and research worlds, the Globus Toolkit, from the Globus Alliance, is a reference implementation of the Open Grid Services Infrastructure (OGSI). OGSI lets Java components be exposed as OGSI services. OGSA-DAIS (Data Access and Integration) is another scientific and research proposal aimed at addressing data services requirements in grid environments; leading database vendors are participating in this initiative.

Enterprise grid computing creates an extremely dynamic environment where resources are automatically augmented or diminished based on business priorities captured in allocation policies. The current version of the JDBC specification (and implementations based on it) makes working in such environments impractical and reduces the ability of Java and J2EE applications to achieve all the benefits of enterprise grid computing. To be more explicit, let's look at some of the issues faced when working in an enterprise grid computing environment:

* Most JDBC applications today use connect strings that explicitly specify the hostname or IP address of the target database. This won't work when processing nodes are dynamically added to or retrenched from the cluster of database servers.
* Enterprise grid environments must scale well and serve thousands of concurrent clients. This makes efficient load-balancing and database connection pooling mandatory; traditional connection pooling mechanisms that cache only connections with the same identity are useless.
* With databases and other resources being dynamically managed and allocated for service, connection retention and management is critical. Mechanisms to resize or refresh stale connections or to search for and reclaim abandoned ones are required.
* Database clients, whether they're Java programs or J2EE containers, must be notified about changes in the database server configuration as quickly as possible. Application servers (and J2EE containers) that rely on unpredictable timeout mechanisms will not be able to provide a reliable, guaranteed service.

Java Database Connectivity Within the Enterprise Grid
Virtualizing the Database as a Service
As shown in Figure 1, clusters are pervasive at every level within the enterprise grid: disk and network storage servers, database servers, and application servers. Most database vendors now allow a single database to be concurrently managed by multiple servers or instances.

Although database clusters are easily understood, there are fundamental differences between the architectures supported by the various current implementations; for example, a shared nothing approach and a shared disk approach provide different levels of capabilities. This article focuses on the Oracle Database Real Application Cluster (RAC) model in which any database server instance can address the entire database space, hosted on shared networked storage.

The typical JDBC approach to specifying how to connect to a database is to provide the details for the target database in the form of a tuple containing ::. This is set as the URL attribute of a data source definition or directly in the connect string when establishing the JDBC connection.

String connString="jdbc:oracle:thin:@prodHost:1521:ORCL";

In the Oracle Database RAC model, the physical server hosts and database instances that make up the cluster are represented as a single logical entity known as a service. A client application connects to the logical database service without any real knowledge of the actual host or database server instance that's used in the cluster. By connecting to the service, as illustrated by the Enterprise Grid Model in Figure 2, and not to an actual physical server, clients can be insulated from changes made to the physical elements of the cluster as well as from node failures.

To use a logical database entity in Java applications, JDBC connection strings must be able to accept service-based connect strings instead of physical host details. In the Oracle Database RAC model, services are represented as "/".

String connString="jdbc:oracle:
thin:@/service_name";

The Connection Cache Manager
In the enterprise grid world, where applications are dynamically provisioned to run on different servers and even on instances of Java Virtual Machines (JVMs), it's imperative that the application's connection caches can be managed to permit the most efficient use of available resources. One approach to this is a new component called the Connection Cache Manager, which offers a centralized way to manage one or more connection caches. A single instance of Connection Cache Manager per JVM manages all of the connection caches used by applications running on that JVM.

The Connection Cache Manager plays two major roles: it manages cache and binds a connection to the data source.

Managing and Maintaining Cache
The Connection Cache Manager is responsible for creating the cache, maintaining its state, and terminating it. It's aware of the existence of each connection cache, managed independently. A rich set of APIs is provided to perform the Connection Cache Manager tasks.

The Connection Cache Manager supports the coexistence of more than one cache. Each cache is identified by a unique name and is then tightly bound to a data source. Each cache is either created transparently when getConnection() requests are made on a cache-enabled data source, or is created explicitly in the middle tier via the Connection Cache Manager API. Once a cache is created, it may either be explicitly removed via the Connection Cache Manager, or when the data source is closed.

Caches can be monitored using the Cache Manager APIs, enabling access to information such as the number of connections checked out and the number of connections available in the cache.

Binding a Connection Cache to the Data Source
As illustrated in Figure 3, the Connection Cache Manager makes sure a connection cache is associated with its data source object every time a cache is created, removed, or reinitialized. This ensures an efficient way to access the connection cache and retrieve connections from it every time the getConnection() method is invoked on a data source.

Fast Application Notification (FaN)
As I alluded to earlier, the dynamic nature of an enterprise grid environment results in nondeterministic system changes that may have flow-on effects on applications that are executing.

To allow application clients in an enterprise grid environment to function in the most efficient manner, a mechanism must be provided that performs the following tasks:

* Monitor changes in database configuration and notify clients as fast as possible.
* Balance connection requests across all active instances.
* Fail-over established connections to surviving instances

Oracle Database 10g JDBC offers these capabilities by combining the Connection Cache Manager, Oracle Database RAC, and notification events through a notification service to quickly inform affected components of changes occurring in the grid.

Let's look at how these pieces work together. When a new instance is added to a database cluster, or when an instance is retrenched from a cluster (instance stopped or node dies), Oracle Database RAC generates an event that indicates what happened. The Oracle Notification Service (ONS) detects and distributes this event to components that have registered as interested in such events.

In Oracle Database 10g JDBC, Fast Application Notification is important: the connection caches are alerted when database instances are affected and can take preventive courses of action.

The mechanism is enabled on a cache-enabled data source by setting the data source property FastConnectionFailoverEnabled to true (see Listing 1).

With Fast Application Notification, event detection and notification is nearly instantaneous, occurring in seconds rather than minutes with traditional timeout mechanisms.

Adding Database Instances: Load Balancing
Adding new database instances to an Oracle Database RAC cluster generates UP events. These automatically trigger the balancing of all allocated connections over all active RAC instances without waiting for application connection retries/requests.

Let's consider a basic example in which we have:

* A cluster with two nodes in a database service, one instance per node
* A cache size of 150 total connections, resulting in 75 connections per instance

Adding a new node to the service will trigger an UP event, which is detected and propagated via the FaN service. This will cause the connection cache to automatically rebalance the existing 150 connections in use in the cache over the three instances, resulting in 50 connections being established per database instance. This process involves removing some connections (to existing instances) and creating new ones (to the new instance).

Retrenching Database Instances (or Node Failure): High-Availability
Retrenching database instances from an Oracle Database RAC cluster generates DOWN events, which automatically trigger a detect-and-fix mechanism in the connection caches. This mechanism quickly removes connections belonging to the failed instance, preventing invalid connections from being handed out on connection request.

Continuing with the previous example:

* We now have a three-node database service with 50 connections per instance in the caches, for a total of 150 connections.

If a node in the database service fails or is removed by the resource provisioning system, then a DOWN event is created and propagated via the FaN service. The 50 connections belonging to the failed instance/node will be quickly removed from the cache, ensuring that the cache is clean and consistent. A clean cache guarantees that connection requests will be routed only to surviving instances. Clients with a stale connection must retry connection requests, unless a container intersperses such calls and is able to take corrective action.

The Fast Connection Fail-over mechanism transparently ensures reliable, highly available Java database connections in RAC and grid environments.

In-Flight Transactions
If an application is midtransaction when an instance fails, it will be thrown an appropriate SQL exception and the transaction will be rolled back. It's the responsibility of the application or the container to retry the connection request and reestablish session state.

Simplifying JDBC Connection Caching
As summarized in Table 1, the new Oracle Database10g JDBC Implicit Connection Cache has been designed to overcome existing JDBC Connection Caching limitations as listed in Table 1, by providing:

* Transparent access to the cache
* Support for multiple identities
* The ability to retrieve connections based on user-defined attributes and weights
* The ability to refresh or recycle stale connections from the cache

To take advantage of these capabilities, simply customize your environment by explicitly setting properties on the connection cache properties or connection.

Transparent Access to the Cache
By default, the getConnection() method in the standard OracleData-Source API creates a new database session and a physical database connection, thus incurring performance and scalability penalties. With Implicit Connection Caching, once the DataSource property ConnectionCachingEnabled has been set to true, the getConnection() method will service all connection requests from the connection cache.

ods.setConnectionCachingEnabled(True);
ods.setConnectionCacheName("MyCache"); // optional
ods.setConnectionCacheProperties(cp); // optional
ctx.bind("MyDS", ods);
ods =(OracleDataSource)
// lookup DataSource
ctx.lookup("MyDS");

A JDBC 10g Connection cache can be created either implicitly by the first invocation of the getConnection() method or explicitly by using the Connection Cache Manager API. The Connection Cache Manager is especially useful for developers working with J2EE containers and ERP frameworks since it shields the infrastructure from the complexity of managing connection cache.

// This call would create a "MyCache" cache and a
// connection from "MyDS"data source will be created and returned
conn = ods.getConnection();

// This call would create a "MyCache" cache and a
// connection to "MyDS", authenticated by "Scott" will be created
conn = ods.getConnection("SCOTT","TIGER");

Subsequent getConnection() invocations will either create a new connection (if the cache was not previously initialized) or retrieve an existing connection from the cache. Once the connection is retrieved, you can proceed with statement creation.

// Create a Statement
Statement stmt = conn.createStatement ();
...

// Close the Statement
stmt.close();
stmt = null;

The cache can be populated in one of two ways: by preinitializing it using the Cache Manager APIs or, incrementally, upon the release of connection(s) back to the cache. When returning a connection to the cache, applications can save current connection attributes settings for future use (see attribute-based retrieval, below).

// return this connection to the cache
conn.close();
conn = null;

Caching Multiple Identities
While a database does not impose any specific restrictions on the connection authentication, a traditional cache might impose a limitation on the connections it can manage, requiring that they all use the same username/password combination, for example.

The Implicit Connection Cache can handle any combination of user-authenticated connections. For example, a joe.johnson connection can coexist very well with a sue.miller connection in the same connection cache.

Connection Retrieval Based on User-Defined Attributes
One of the valuable new features in the Implicit Connection Cache is connection striping.

Connection striping, or labeling, consists of applying user-defined attributes to a connection and making their state persist when the connection is returned to the cache. This speeds up future connection retrieval since cached connections don't have to reinitialize a block of state every time. These attributes can later be used to retrieve the same connection from the cache, as follows.

Example 1: Retrieving a connection based on the NLS_LANG attribute:

// get a connection from the cache with NLS_LANG attribute
java.util.Properties connAttr = null;
connAttr.setProperty("NLS_LANG", "ISO-LATIN-1");
conn = ds.getConnection(connAttr);

Example 2: Retrieving a connection based on the isolation-level attribute:

java.util.Properties connAttr = null;
connAttr.setProperty("TRANSACTION_ISOLATION", "SERIALIZABLE");

// retrieve a connection that matches Transaction Isolation
conn = ds.getConnection(connAttr);
...
// this call will preserve attr settings for this connection
conn.close(connAttr);

Example 3: Retrieving a connection based on the connection tag and connection attribute:

java.util.Properties connAttr = null;
connAttr.setProperty("CONNECTION_TAG", "JOE'S_CONNECTION");
// retrieve connection that matches Joe's connection
conn = ds.getConnection(connAttr);

// apply attributes to the connection
conn.close(connAttr);

// This will retrieve Joe's connection
conn = ds.getConnection(connAttr);

Applying Connection Attributes to a Cached Connection
A connection attribute can be applied to a connection in the cache in two ways.

One approach is to call the applyCon-nectionAttributes(java.util.properties connAttr) API on the connection object. This simply sets the supplied attributes on the connection object. It's possible to apply attributes incrementally using this API, letting users apply connection attributes over multiple calls. For example, NLS_LANG may be applied by calling this API from module A. The next call from module B can then apply the TXN_ISOLATION attribute, and so on.

A second approach is to call the close(java.util.properties connAttr) API on the connection object. This API closes the logical connection and then applies the supplied connection attributes on the underlying PooledConnection (physical connection). The attributes set via this close() API override any attributes set using the applyConnectionAttri-butes() API.

The following example shows a call to the close(connectionAttributes) API on the connection object that lets the cache apply the matched connectionAttributes back on the pooled connection before returning it to the cache. This ensures that when a subsequent connection request with the same connection attributes is made, the cache will find a match.

// Sample connection request and close
java.util.properties connAttr = null;
connAttr.setProperty("NLSLANG", "ISO-LATIN-1");
// request connection based on attributes
conn = ds.getConnection(connAttr);

// apply attributes to connection
conn.close(connAttr);

Connection Retrieval Based on Attributes and Weights
Connections may be selectively retrieved from the connection cache based on a combination of ConnectionAttributes and attribute weights.

Weights are assigned to each key in a ConnectionAttribute in a one-time operation that also changes cache properties. The cache property CacheAttributeWeights is one of the java.util.Properties that allows the setting of attribute weights. Each weight is an integer value that defines how expensive the key is in terms of resources.

Once the weights are specified on the cache, connection requests are made on the data source by calling getConnection(connectionAttributes). The connectionAttributes argument refers to keys and their associated values.

The connection retrieval from the cache involves searching for a connection that satisfies a combination of the following:

* A key/value match on a connection from the cache
* The maximum total weight of all the keys of the connection-Attributes that were matched on the connection

Consider the following example in which a cache is configured with CacheAttributeWeights (see Listing 2). (Listings 2-3 can be downloaded from www.sys-con.com/java/sourcec.cfm.)

Once the weights are set, a connection request could be made as in Listing 3.

The getConnection() request tries to retrieve a connection from the MyCache cache. In connection matching and cache retrieval, one of two things can happen:

* An exact match is found. As in the above example, an exact match is a connection that satisfies the same attribute values and all the keys defined by Keys (NLS_LANG, SecurityGroup, and Application).
* An exact match is not found. In this case, the closest match based on the attribute key/value and its associated weights is used (but only if the ClosestConnectionMatch property is set).

Once the connection is returned, the user can invoke the getUnMatchedConnectionAttributes() API on the connection object to return a set of attributes (java.util.Properties) that did not match the criteria. The unmatched attribute list can then be used by the caller (or application) to reinitialize these values before using the connection.

Conclusion
This article highlighted a new set of Java data access requirements that have emerged when executing in an enterprise grid environment while also outlining how Oracle Database 10g JDBC tackles the challenges that these requirements present.

Whether you're using JDBC directly in applications via a run-time container such as an EJB container or through an O/R mapping framework such as Toplink, the latest Oracle JDBC drivers offer reliable and highly available data sources in RAC and grid environments and significantly simplify a range of data source connectivity issues for Java developers.

Oracle has proposed these new features to the JSR 221 (JDBC 4.0 specification) expert group. It hopes to see JDBC Connection Pool management and high-availability support for data sources within enterprise grid environments become part of the JDBC 4.0 standard.

Connecting to a Database with JDBC

2007-08-28T08:43:00.000+05:30

// JDBC|Test – complete code
public class JDBCTest {

public static void main(String args[]){

RunDB runDB = new RunDB();

try{
runDB.loadDriver();
runDB.makeConnection();
runDB.buildStatement();
runDB.executeQuery();
}catch(Exception e){
e.printStackTrace();
}

}
}

//RunDB
import java.sql.*;

public class RunDB {

Connection connection;
Statement statement;

public void loadDriver() throws ClassNotFoundException{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}

public void makeConnection() throws SQLException {
connection=
DriverManager.getConnection("jdbc:odbc:purchaseOrder")
}

public void buildStatement() throws SQLException {
statement = connection.createStatement();
}

public void executeQuery() throws SQLException {

boolean foundResults =
statement.execute("SELECT * FROM Transaction");
if(foundResults){
ResultSet set = statement.getResultSet();
if(set!=null) displayResults(set);
}else {
connection.close();
}
}

void displayResults(ResultSet rs) throws SQLException {
ResultSetMetaData metaData = rs.getMetaData();
int columns=metaData.getColumnCount();
String text="";

while(rs.next()){
for(int i=1;i<=columns;++i) { text+="<"+metaData.getColumnName(i)+">";
text+=rs.getString(i);
text+="";
text+="n";
}
text+="n";
}

System.out.println(text);

}

}