This is an email I had received back in 2001 through a mail list. Its amazing that the info still holds good in this fast changing IT world.

It is important, you need to know where technology is headed so you can keep up
with changes down the road even if you never have to look for development work
again.

Here are my picks for the 10 most important development technologies today, with
the most important ones first. After you've read my list, be sure to join us in
the talk.editors.devx discussion group to submit your own technology top 10
list.

1. XML
First, and above all else, you should know about XML. I'm not speaking only of
the XML specification itself, but also of a family of related XML-based
languages: the most important of which are XHTML, XSLT, XSL, DTDs, XML Schema
(XSD), XPath, XQuery, and SOAP. For those who have been hiding in the basement
slinging code without looking up from the keyboard for the last five years, XML
is a text file containing HTML-like tags that define a tree structure and
describe the data that they hold.

The nicest thing about XML is that you can store both structured and
unstructured data in it-it can contain and describe "ragged" document data just
as well as it holds and describes "regular" table data.

XHTML is the preferred method for writing HTML these days; because it's well
formed XML, you can manipulate XHTML-formatted documents much more easily than
the older, usually malformed HTML documents.
XSLT and XSL are languages that transform XML documents into something else.
That something might be text documents, PDF files, HTML, comma-delimited files,
or some other XML document.
DTDs and XML Schema describe the type of content that an XML file can contain,
and let you "validate" the contents of XML documents without writing custom code
to enforce the rules for that content.
XPath and XQuery are query languages that let you extract single items or lists
of items from XML documents. XQuery is particularly powerful because it extends
XPath queries and essentially is to XML what SQL is to relational databases.
SOAP is the standard communication protocol between Web services. While you
don't need to know the SOAP standard inside and out, you should become familiar
with the general schema and the way it works so that you can use ...

2. Web Services
Web services are a direct outgrowth of XML's popularity. Because you can use XML
to describe data and objects, because you can use schema to ensure that the
content of an XML document is valid, and because XML is a text-based
specification, XML makes an extremely convenient base format for a
cross-platform communications standard. If you haven't been exposed to Web
services yet, you probably will be soon, and you almost certainly will be within
five years. Web service familiarity is important because it's the simplest way
anyone has yet invented for applications to communicate across disparate
machines, languages, platforms, and locations. Whether you need them or not, Web
services are a major step forward for interoperability.

John Bosak, chair of the XML Working Group, once said that XML "gives Java
something to do." Well, Web services give every language something to do. Web
services let COBOL applications running on mainframes talk to Java applications
running on handheld devices; let Java applets talk to .NET servers; let desktop
applications interact seamlessly with Web servers; and generally provide a
relatively easy way for businesses to expose not only data, but also
functionality-and do it in a language-, platform-, and location-agnostic way.

3. Object-Oriented Programming
Many programmers still regard OOP as an ivory-tower technology, but just think
for a second about which languages have become dominant over the past decade and
you'll begin to understand that it's not. Starting with Smalltalk, OOP spread to
C++ and Pascal (Delphi). It made a serious mainstream leap with Java, and a few
years later to VB.NET and C#, completing its ascendance. While you don't have to
learn OOP to use most of these languages, I suspect that there are a diminishing
number of programming jobs that you can get if you don't know the basic concepts
and how to use them.

4. Java, C++, C#, VB.NET
I've lumped these together not because I'm recommending that you become a guru
in every one of these languages. No. The reason is that one of the most
efficient ways of learning to program is by looking at code-and a huge amount of
the code available to look at is probably not written in your favorite
development language.

Over the past few years, language capabilities have become increasingly similar.
You can write that Windows Service, Web application, or command-line app in
VB.NET these days. Even if you only write in one of these languages, you owe it
to yourself to learn enough about the others to be able to read and understand
the available examples, and to translate code from them into your preferred
language. While the four languages listed here form the basic core of a strong
developer's toolbox, there are others that may prove just as useful, depending
on your particular field, such as FORTRAN, COBOL, APL, ADA, Perl, and Lisp.

5. JavaScript
Despite the similarity in their names, Java and JavaScript are unrelated. Why is
a scripting language so important? Consider that all the major browsers use
JavaScript. If you need to write Web applications, that's enough of a reason
right there. But you can also use JavaScript as a server language for ASP or
ASP.NET or as a functional language for extending XSLT. Javascript is the
preferred language to activate XUL-based interfaces in Mozilla/Netscape, a
derivative, ActionScript, is the programming language for Flash MX applications,
and JavaScript is highly likely to be the scripting language for new devices in
the future, as well as the macro language for major applications.

In contrast, VBScript, although well supported in Microsoft applications, is a
poor relation-and probably a poor choice for future development work. Even
Microsoft tends to write its client-side code examples in JavaScript (or its own
derivative, JScript) these days. When you have a choice of scripting languages,
choose JavaScript

6. Regular Expressions
You search relational databases with SQL, XML with XPath and XQuery, and plain
text with regular expressions. For example, you can do things such as find and
remove all comments from an HTML document via a single command. The simpler
text-searching functions built into the various development languages such as
"IndexOf" or VB classic's "InStr" function or "Like" operator are no match for
regular expressions-and every major development language now provides access to
a regular expressions implementation. Although the expressions themselves are
difficult to write and even more difficult to read (a throwback to earlier days
of computing), they're a powerful and underused tool.

7. Design Patterns
Just as OOP simplifies programming by letting you collect and classify objects,
design patterns classify common object interactions into named patterns. The
more you use OOP, the more useful design patterns become. The most common
patterns have names that are working their way into the common development
argot, so you need to understand them at least well enough to keep up with the
general flow of information.

8. Flash MX (perhaps you could replace this with MS-silver light)
When you need more client-side graphics and programming power than you can get
with HTML and CSS, Flash is the answer. Programming in Flash is much faster and
easier than programming graphics applications with Java applets or .NET code.

In its newest version (MX), Flash is not just a drawing and animation package,
it's also become a highly programmable application environment. and it's capable
of consuming SOAP Web services and calling ColdFusion, Java, or .NET code
running on a remote server. Flash is ubiquitous; its runtime is on most of the
client machines in the world, including handheld devices, set-top boxes, and
even the new Tablet PCs, so using it may actually extend your programs' reach.

9. Linux/Windows
Get familiar with Linux. Install it on an old machine-or a new one. Download the
GUI interfaces and program some applications on it. Install Apache and write a
Web application. The world no longer belongs exclusively to Windows, and that
trend will probably continue. In contrast, if you're a hard-core Linux
developer, drop your antipathy toward Windows and see what you can adopt.
There's a reason why Windows is still king of the desktop-and it's not just that
Microsoft controls the market.

There's no telling when your company may decide to switch from Linux to Windows
(or vice versa), or when you might want to switch to a company that uses a
different platform-or when you might come up with the next killer application
idea-so you should try to gain experience on more than one platform.

10. SQL
Although SQL isn't as new as most of the technologies discussed in this article,
and it's likely to diminish in importance over the next decade, it's still an
essential skill-and one that many developers either don't have or understand
only well enough to use it inefficiently. Don't rely on GUI-based SQL builders
to do the job for you; write your queries by hand until you're comfortable with
the basic SQL syntax. Not only will understanding SQL now help you learn XQuery
later, but you may find ways to immediately simplify or improve your current
development projects.

Cultivate Curiosity
Finally, (and yes, I realize this is No. 11), the most important skill you can
acquire is curiosity. Try things out. That new language or new technology may or
not be important to you in your present or future job; but not everything you
learn needs to be job-focused. Don't be afraid of failing; it's always difficult
to be a beginner at any new technology. Most failures happen because people
expect too much of themselves too fast. Be satisfied with small steps, and don't
let time (or the absence of it) get in your way. Instead, make time to look at,
research, and test new development techniques and tools.