Microsoft’s .NET offers an alternative to Java and J2EE. Microsoft’s Visual studio .NET development environment incorporates over 20 different languages including RPG, COBOL and Microsoft’s own C# for business programming. With all languages compiling to a common language runtime, .NET enables developers to create XML Web services and integrate mobile devices and servers.

Functional programming languages, while being merely rare in academic circles, are nearly unheard of within actual production environment. The appropriateness of particular languages to particular tasks is an actual and future problem. I often saw an attitude of, “well, if this is the language that I know, why shouldn’t I use it?” The correct is to use the right tools for the job whenever possible.

Very frequently, non-technical matters play a large role in defining “the right tool”. Some examples of these:

-          Who will be maintaining it?

-          How available is support for this language, and how expensive is it?

-          Are there available libraries in this language to help with this task, or will the team write its own from scratch?

-          How often will maintenance be required?

-          At what intervals will maintenance need to be performed?

-          How available are programmers who know this particular language?

Then it is fairly easy to see why Java and .Net are doing very well in the marketplace, despite their glaringly obvious technical problem and limitations. The main advantage is that they have gigantic libraries (the .Net Framework and J2EE lone, not to mention what their communities and third party developers publish cover more ground than any other language out there, except for Perl and C++) which slash the about of time the programmer spends on “plumbing”.

Using a much better language often cuts development time so much, that it offsets the time that is needed to be spent writing libraries and plumbing. When it takes 5 to 20 times as many lines of code to accomplish something, which is a huge hit in time to develop. Sometimes, writing a library from scratch in a great language, custom suited to the project’s needs, is often quicker than attempting to write “glue code” in a poor language for a “one size fits all” library.

Unfortunately, these more efficient, more suited languages, tend to lack in the business requirements department. Good C++ coders are not easy to find, costly on individual level. Never mind the fact that one great C++ coder can do the same work as ten standard Java programmers. There are more sophisticated languages, like Ruby, Python, Lisp, Prolog, Scheme, ML, but it is very difficult to find books for these languages at the average bookstore. Reading someone else’s code in a lot of functional languages is like someone who speaks English trying to read French.

This is why people like the .Net concept. Everybody really like the way it hides the complexity of the OS’s API behind a consistent, well documented layer. People like too the idea that it is possible to write individual portions of code in the most appropriate language and the various pieces interoperate like magic. A spectacular idea is that any OS with the .Net runtime should be able to run the code with no changes, except for the parts that are platform specific.

Microsoft is sort of headed in that direction. They have IronPython out. They hired the programmer who did a Ruby implementation for .Net, so everybody can imagine that we will see Ruby for .Net soon. They give away free tools (the Express editions of Visual Studio), which are still better than 90% of the tools that are available, let alone for free.

Su is now attempting to do this with Java. But they are so far behind, and Sun alienated the FOSS community almost as bad as Microsoft has, while Microsoft is now working to build a relationship with FOSS (getting Python, Ruby, etc. onto .Net, helping Active State, the “Shared Source” program, and so on).

VB.Net or C# seems to be leaders in the programmers’ choices.  Indeed, with the tools for Visual Studio to work with office documents (meaning VBA macros) anyone can shift away from using VBA within the document to generate reports to using .Net code outside the document, and it will be faster and easier. At the very least, using VB.Net would be better than VBA. Anyone who has ever worked in VBA can attest to this. The customers want and demand Excel spreadsheets as output; for the Web development work, many are stuck with ASP.Net. The customers’ large majority is simultaneously married to offline access (for sales reports on the road) and the Microsoft Office platform.

.NET Framework 3.0 was released in late 2006. .NET 3.0 is technically the .NET 2.0 runtime plus some new .NET 2.0 compatible assemblies formerly known as WinFX (which is the name of the new managed API for Windows Vista).

The many new 2.0 features like pre-compilation, partial classes, master pages, Web Parts, personalization, and so forth are a productivity boost when building applications.

In addition to the already familiar e .NET platform, it is useful to spent time learning Visual Studio 2005. Even though this release has been out for a while, its adoption and usage coincides with use of the .NET Framework 2.0. In addition to the framework versions, Microsoft has also introduced new product versions that are closely tied to the .NET Framework. Certification is a great way to become familiar with the latest release.

Microsoft is a public company that needs to make money, so we can expect more product releases to be updated next year. Examples of recent updates include SharePoint Server 2007 and the 2007 Office System, which can both be used to build more powerful .NET-based solutions.

You can use a Visual Studio 2005 add-on to build applications targeting the 2007 Office System. The Web Parts feature first introduced in SharePoint is now a standard part of the ASP.NET 2.0 platform. Another much-anticipated product release in 2006 was Internet Explorer 7, which adds many new features targeting both users and developers. You can leverage these products to deliver solutions with the expectation of more updates and new versions down the road.

Microsoft saved its biggest product release for the end of the year by making Windows Vista available to corporate customers at the end of November. It was finalized not long after the .NET Framework 3.0 was released, which is the version of .NET you should use when developing applications targeting the Windows Vista operating system.

By default, Windows Vista includes the .NET Framework 3.0. In addition, version 3.0 is available as a plug-in to Visual Studio 2005, allowing developers to write applications that use Vista’s new user interface, security features, and communications system. Windows Vista covers the desktop environment with the Windows Server Longhorn providing an update to Windows Server 2003.

What to expect in 2007? While 2006 has offered plenty of news about product releases and new technologies, 2007 will be no different. AJAX is one area where development continues with a release of the ASP.NET AJAX (code named Atlas) tools expected in 2007. It is designed to speed up development of Web applications that run in a browser or on a server.

In addition, Windows Vista is slated to be released to the general public on January 30, 2007, but it is still unknown how quickly businesses and consumers will adopt the operating system. At this time, I haven’t seen any .NET Framework 4.0 versions, so hopefully developers will be given time to further digest both 2.0 and 3.0. Likewise, the adoption of the latest frameworks will continue as customers continue to build new applications and move to the new platforms.

The world of application development is fast moving and forever changing as product updates and new versions seem to appear on a constant basis. Microsoft is a prime example as it continues to update its operating systems and products as well as its .NET platform.

This has been a long time in coming. Here are the expectations of the developers and the t companies (industry) point of view. When a developer starts to develop software, what he requires or needs is:

Suitable language’s knowledge in which he can program the business logic

1. Database knowledge to store his data
2. Tools to connect the business logic to the database in distributed environment
3. How to pack the application
4. If providing the transparency on client side then needs to develop the web solution
5. Want some sort of components to reuse his hard work or efficient efforts of others
6. Want to validate the client most of the times through scripts or server side logic
7. Want to permit a community to reuse your component to promote your business or criteria
8. Want to provide a neat User Interface
9. Want to save the efforts to put on another web page that you have made once

And many more … (Can not cover or discuss all aspects because these all things actually vary from person to person’s preferences)

But the top 10 points mentioned would be present in the list of every serious developer. So the solutions for these problems in the terms of technology we had before the advent of .NET are:

• Suitable Language’s knowledge for business logic: C, C++, and JAVA etc.
  Databases: ORACLE, SQL Server etc.
• Tools to connect business logic to Database components in Distributed environment: CORBA, RMI, DCOM
• Packing of application for distribution: setup files (Environment dependent), binary files and finally registering the components
• Developing online solution through (Displaying): HTML, DHTML, CSS, and XML
• Want the reusability concept: Java Beans, COM.
• Client validation: Java Script, JScript, Applets etc and Server Side Logic: Perl, ASP, PHP etc.
• Component Distribution: Physically copy and register the component or access through full dependency on server
• Neat User Interface: VB, VC++, GTK+
• Reusable web component: not any popular software used frequently in industry.

For example we were using: C++, SQL Server, DCOM, HTML, COM, JScript, ASP, Server and Client registration utilities, VC++, GTK+ (on Linux) and XML for development requirements. So the problem we faced is that it took a long time for us to understand all technologies and almost every time we suspected the saturation or survival of the technology. We are not saying that every developer needs to know all these technologies at once but definitely if you are going to design something new and creative then you must have a very good idea of at least one option for every point we discussed and those are really the persons our industry is moving with.

But with .NET, Microsoft integrated almost everything in one package with the dependencies of the technologies with a clear distinction of the technology boundaries. Means you have almost everything but not whispering into each other.

So if you start to learn .NET, what all you actually need to learn is: Major technologies: C# (VB.NET is also a good option), ASP.NET, XML.

C# can be used for scripting for client validation, to create business logic, for server side programming, for Windows Applications, for Console Applications, for component designing and can use XML as data, as metadata (self describing data) and connecting tool between database and business logic again you need C# implementation of ADO.NET and moreover to put the things online you need ASP.NET on server side and to make reusable web components, you have the concept of Web Services like Windows Services developed in VC++ but with no physical boundaries.

Just one language and we can use it almost everywhere. No more confusion… and yes! No more registering process of components to waste the central memory of the system as we had with COM/DCOM and no more administration permissions (out of some special cases) on system. So from programmers or developers point of view this is a high level of achievement.

Now if we think in terms of companies (well! Here I’m talking about the small companies, working on the basis of projects). For example one company recruited four VC++ developers because the project they had was going to develop in VC++, but in next 6 months they got a project on VB.

They’ll ask their developers to learn VB and start to work, yes this is not the way to fire them and hire VB developers! So this is the major problem. But in the case of .NET, you don’t need to learn a new .NET language because you can inherit the components of one language in to another .NET language because of excellent interoperability. So with .NET there are no more places to convert your VB programmers to Managed C++ programmers or C# programmers to JScript.NET programmers.

The analysis used here assumes that the development of ASP may be similar to that of the IT industry. Surprisingly, as the material shows, this assumption works well as it turns out that most up-to-date ASP developments truly resemble the events in the history of IT, although they are occurring at a faster pace.

The future demand for ASP also seemed huge, perhaps bigger than the entire IT industry, as it potentially hinted at a total substitution of ASP for incumbent IT along with the massive expansion of services in the future.

ASP.NET is probably one of the most exciting things about .NET from a developer’s perspective. ASP has been totally redone from the ground up.

Many developers made the jump from regular ASP to .NET immediately, drawn in by the all too familiar Microsoft hype and the promises of cross-platform compatibility, rapid and robust development, and the ability to develop web applications in the familiar, comfortable and slightly lazy VB environment.

The move to a .NET development environment was expensive and a far bigger change than many expected. The uptake was, and still is much slower than Microsoft ever expected. It is surely no accident then that the .NET suffix has been removed from the recent Visual Studio 2005. There is no such thing as VB.NET anymore, it is VB2005. It is also a surprise, (although not altogether unexpected), that Microsoft is now giving away a lightweight version of VB2005 for free! Change the name and give it away – a cunning recruitment drive or a company in panic?

In truth, it is possible to find VB2005 for traditional Windows application development a fantastic tool. A sensible object-orientated programming architecture combined with the marvelous ADO.NET database access, alongside powerful features such as Web Services, throw in some of the best layout tools ever seen in an environment of this nature, gently stir in the ability to code in C#, J#, or VB and you cannot deny that VB2005 is an order of magnitude greater than VB6, and is definitely a cake worth eating.

In this accolade, however, it is not possible to include ASP.NET. VB and ASP have now been bundled together in the same VB package and the distinction between the two is supposed to be invisible; VB2005 Windows Forms and VB2005 Web Forms – a slight difference in name, yet a huge difference to the developer. VB Windows Forms (or VB.NET, or VB2005, or VB) will improve your life. VB Web Forms (or ASP.NET, or ASP2005) will make you frown.

In fact, consider the following statement:

“ASP.NET for small to medium sized websites is a huge overhead in so many ways, and so for the foreseeable future I will be sticking with regular ASP for anything but the most complex of websites.”

1. Regular ASP has the most lightweight development environment ever used – Notepad. Yes, that’s all you need!

Installation time? – It’s already installed
Start up time? – It’s running in an instant
Configuration? – Not needed
Availability? – Any PC ever

2. Regular ASP hosting is still cheaper and more prevalent than ASP.NET hosting, and even the ASP.NET hosting is slow at moving to new versions. There are UNIX versions of the ASP compiler too so you don’t even need a Windows hosting company.

3. The workshop is aimed towards those responsible for building and creating their college’s Internet website and/or intranet systems and those who already maintain a college intranet or website. The events deal with practical methods of incorporating database driven information into your current networked HTML information interface using a server that is able to serve Classic Active Server Pages (ASP).

4. The event will cover the use of ASP scripts that search, add, amend and delete information using an Access Database. Scripts will be copied and explained to avoid large amounts of time typing code. The web examples used during the event can be adapted and used in a college and include a searchable telephone directory and searchable courses prospectus using alternative keywords for searching, a titles pages and a detail of course page. Hand coding scripts gives greater flexibility and uses many of the features of ASP that are not available when using Dreamweaver wizards.

5. The scripts may be adapted for reading from, writing to, amending and deleting information in a database, and password protection of web pages. It is not necessary to have any pre-knowledge of ASP or Visual Basic Script to attend the event.

How best to upgrade to Windows Vista? For ASP.NET application developers who move to the Windows Vista operating system, IIS 7.0 represents a significant advance over earlier IIS versions because of increased security and the application possibilities offered by IIS 7.0 Integrated mode. Most developers who move to Windows Vista will be upgrading from Microsoft XP operating system, to Windows Vista and will upgrade their ASP.NET applications in the process or else will install, on Windows Vista, ASP.NET applications that were developed on other Windows operating systems. There are some important post-installation and post-upgrade configuration steps that must be performed for applications to work on the new operating system and also describes changes between Classic mode and IIS 7.0 Integrated mode that affect ASP.NET applications, and how to work around these known problems.

It is easier now to see how to built-in functions of the 2.0 release reduces the amount of code we’ll need to write. There are and will be developed unique a resourceful ways to handle various problems we’re facing daily during the development of any website. It will be easier too to see how to implement new features including themes, membership, personalization, localization, master pages, web parts, and caching. The mastery of many of the new server controls including GridView, DetailsView, MultiView, Wizard, Menu, SiteMap and Login can be also done in a professional manner.

They say that a picture is worth a thousand words, and nowhere is this more evident than in the use of car charts. Thankfully, ASP.NET provides the means for doing just that within the existing .NET framework, via the SYSTEM.DRAWING namespace. With bar charts, it is possible to visualize past sales history, forecast stock prices, and display survey results pictorially, among literally thousands of other applications. Bar charts become even more valuable when they can be generated dynamically. The future development will make this feature more user friendly, of course.

C# is a modern and innovative programming language, one which carefully incorporates features found in the most common industry and research languages. In keeping with the design philosophy of C#, Microsoft has introduced several potential new features to the C# language that increase developer productivity with language constructs.

Microsoft plans to build on an already elegant and expressive syntax by incorporating a variety of features across a broad spectrum of research and industry languages. Included among these language features are generics, iterations, anonymous methods, and partial types. It is on the pillars of a unified type system, component-based development, developer headroom, and pragmatic language constructs that future innovation in C# will be based.

The future developments will provide native support for SQL and XML right in the C# language, providing a far more natural integration of database programming concepts with modern languages. C Omega introduces some radical changes to the C# language. Most notably are the changes to the type system to provide more alignment between XML schema and classes. Anyone who understands what XSD is really trying to achieve will understand that trying to tie together schema and classes is impossible because the two are dramatically different, and are in fact trying to achieve different goals. Classes are just lists of fields, properties and methods. XSD on the other hand, describes documents of data: hierarchical streams of elements, sub-elements, attributes where you can define in quite some detail what constitutes a valid representation of that document. In essence, classes and documents are completely different beasts.

C Omega introduces several radically new concepts that allow interacting with complex data structures as if they were first class citizens of the languages. Based on what we know about the language, here are some of these features: streams, apply-to-all-expressions, choice types, nullable types, anonymous structures, query operators (SQL and XPath in C#), transactions, and XML literals integration.

This represents some great progress on the front of integrating solutions to real enterprise problems right into the language semantic of C#. It holds the potential to revolutionize database programming. Taking this one step further, just imagine if you could work with the new System. Data.SqlServer namespace, right in the SQL Server process, working directly with the data just like you would in stored procedures, and returning this using remoting.

Combining the power of C Omega, .Net and SQL Server’s database engine, this could be the answer I was looking for and a huge leap forward for enterprise development. Could it mean the end of stored procedures? Either way, let’s hope these features make it into C# soon.

Microsoft recognized some of the features that made VB popular, and included them in VB.NET. C# though, was never designed as a “VB killer.” Instead, C# is more likely to attract developers from C++ and Java. C# provides a C-like syntax similar to both C++ and to Java. Right off the bat, it’s missing the first of the six features—a BASIC-like syntax. While syntax is unimportant to some developers, it’s all-important to others.

In addition, VB, and now VB.NET, aren’t case-sensitive languages. For example, “Email” and “EMail” are the same variable. In C, C++, Java, JScript, and other C-like languages, changing capitalization is an error; EMail and Email are not the same variables.

C# does have visual design and simple, integrated database support, and will eventually have a large palette of aftermarket controls to choose from—but it’s the same palette that VB.NET developers will have.

C#’s IDE support leaves a lot to be desired. Even though C# shares an IDE with VB.NET, the IDE responds to each language differently. For example, Intellisense in VB.NET is considerably better than in C#, where it’s—you guessed it—case sensitive. Why anyone would implement case sensitivity in a search feature intended to help people find information they may not know and shouldn’t have to memorize is beyond me. Worse, it’s inconsistently case-sensitive.

There’s no denying that C# syntax is more concise. If you hate typing and don’t use Intellisense’s code completion capabilities, or you’re already working with a C-syntax language, C# is the language for you. But that doesn’t mean that C# will eventually replace VB.NET.

C++ will be around for a long time. It’ll be used forever by embedded systems programmers and programmers who write traditional kinds of apps. Bjarne Stroustrup, who currently works as a professor at Texas A&M University and is creator of the C++ programming language, said: “C++ is bigger than ever.”There are more than 3 million C++ programmers. Everywhere I look there has been an uprising–more and more projects are using C++. A lot of teaching was going to Java, but more are teaching C++ again. There has been a backlash.”

Dennis Ritchie developed C at Bell Laboratories in 1972. Many of its principles and ideas were taken from the earlier language B and B’s earlier ancestors BCPL and CPL. CPL (Combined Programming Language) was developed with the purpose of creating a language that was capable of both high levels, machine independent programming and would still allow the programmer to control the behavior of individual bits of information. The one major drawback of CPL was that it was too large for use in many applications. In 1967, BCPL (Basic CPL) was created as a scaled down version of CPL while still retaining its basic features. In 1970, Ken Thompson, while working at Bell Labs, took this process further by developing the B language. B was a scaled down version of BCPL written specifically for use in systems programming.

Finally in 1972, a co-worker of Ken Thompson, Dennis Ritchie, returned some of the generality found in BCPL to the B language in the process of developing the language we now know as C.

C’s power and flexibility soon became apparent. Because of this, the UNIX operating system, which was originally written in assembly language, was almost immediately re-written in C (only the assembly language code needed to “bootstrap” the C code was kept). During the rest of the 1970′s, C spread throughout many colleges and universities because of its close ties to UNIX and the availability of C compilers. Soon, many different organizations began using their own versions of C causing compatibility problems. In response to this in 1983, the American National Standards Institute (ANSI) formed a committee to establish a standard definition of C, which became known as ANSI Standard C. Today C is in widespread use with a rich standard library of functions.

Stroustrup states that the purpose of C++ is to make writing good programs easier and more pleasant for the individual programmer.  When he designed C++, he added OOP (Object Oriented Programming) features to C without significantly changing the C component.  Thus C++ is a “relative” (called a superset) of C, meaning that any valid C program is also a valid C++ program.

There are several versions of the C++ language, of which Visual C++ is only one.  Other dialects include Borland C++, Turbo C++, and Code Warrior (Mac).  All of these software packages enable you to create computer programs with C++, but they all implement the C++ language in a slightly different manner.  In an attempt to maintain portability of both the C and C++ languages, the American National Standards Institute (ANSI) developed a standard of consistency for C and C++ programming.  While we will be working primarily with this ANSI standard, we will also be examining the idiosyncrasies of Microsoft Visual C++ 6.0.

He then went on talking about new projects using primarily Java, stating that the language was still very slow, regarding performance, but that it would soon change, suggesting that C/C++ were near an “end”.

It made it clear that the C++ Team still believes in C++ Builder, and also that they should do another version of C++ Builder. The question is how and when; this question needs to be answered soon, because it’s also clear to everyone that if Borland waits too long, the moment would be lost and C++ Builder would be dead forever.

One of the possibilities the C++ Team wants to investigate is to embed C++ Builder as a C++ “personality” in a future version of the Borland Developer Studio (BDS, Galileo) IDE. The BDS IDE is also used for C# Builder (BDS 1.0), Delphi 8 for .NET (BDS 2.0) and Diamondback (which includes Delphi for Win32, Delphi for .NET and C#; BDS 3.0). Diamondback is the first version of this IDE that is capable of multiple personalities. The idea is to investigate if it’s possible to extend a future version of Delphi (BDS 4.0, for example) with a C++ personality. The end result would be a C++ development tool for Win32 next to Delphi for Win32, Delphi for .NET, and C#, all in one IDE. That would be awesome, of course.

To illustrate that they were not just telling us something to keep us quiet, JT started a special version of BDS with, indeed, the C++ (VCL) personality inside. He built the famous edit box, list box, button demo, writing one line of C++ code, and then running the application. He was even able to demonstrate a working debugger, so this was more than just a quick hack. The best thing, as I heard later from people on the Delphi Team, was that the C++ Team itself did all this.

This is a good thing, since a future release of Delphi that could also incorporate a C++ (Builder) personality should not force the Delphi Team to divide their resources much more than already needed. One thing that I also heard was that the management at Borland is certainly willing to support C++ Builder (inside a future release of the Borland BDS IDE), but not at the cost of more resources. The C++ and Delphi Teams can do it, but they won’t get additional staff or money toward the effort.

Of course, this project requires some careful planning and consideration by both teams, so we’ll see if this idea has a chance of success. Either C++ Builder gets a future—one, which might even include extensions like Managed C++, or C++ Builder is placed in limbo forever.

One thing to keep in mind: The C++ Team firmly believes in C++ Builder, but it’s the management at Borland (or multiple levels up in the hierarchy, perhaps) that needs convincing. At the Meet the C++ Team session, Paul Gustavson suggested that C++ Builder developers help the C++ Team by writing an open letter to Borland’s management. Stay tuned to the C++ Builder newsgroup, Paul’s blog, or my C++ Builder Gate for more news about this open letter.

While Borland’s sales force believes in C++ Builder X for the new market, the C++ and Delphi Teams are willing to give C++ Builder a new future and a new hope, one that will shape the C++ Builder Community for years to come. However, I think this is a bit of an exaggeration.    I think what’s happening now is more a diversification of languages, rather than a full replacement. I could be wrong, anyway. Same here too, but this has mainly to do with cloudlessness…  Most professors & research personnel can’t do anything useful in C/C++.  Most have heard of the weak things in C/C++ so that they can preach other languages, such as Java. Java is good, but will never be *the* language for doing all tasks that C/C++ can be used for right now.

“C++ has been a power programming language since it was born,” says Ami Vora, Microsoft’s program manager for the Visual C++ IDE in Whidbey. “Use its power for good and not for evil!”

Developers who choose C++ for a project are looking for more than Visual Basic’s convenience or C#’s intimate relationship with .NET. Often, these developers are looking for performance, the ability to control very specific functions, and raw programmer productivity. Certainly, you can fine-tune an application in C++ better than in other languages.

Yet, C++ doesn’t get quite as much of the buzz as it once did. Some relegate it to the “legacy” category—as if that means something dusty, abandoned in the attic, rather than “we have a whole lot of it, and we know how to use it confidently, so we don’t have to re-invent the wheel.” With Microsoft giving so much attention to other, newer languages, some developers have worried if C++ will be left behind. Not hardly.

In the last iteration of Visual C++, Vora admits, Microsoft misread some issues in regard to the use of managed extensions.” Though managed extensions were a great proof of concept, they didn’t always fulfill the needs of C++ developers,” she says. They’ve learned their lessons: according to Vora, the new version that will ship with Whidbey will have better language design (it’ll look like C++ with .NET functionality) in a clean, pleasant environment. Plus, you can take advantage of both all the C++ code you’ve ever written and the .NET framework.

Let’s get specific, with a brief overview of its improvements. The new C++ will let developers take full advantage of the CLR, including garbage collection, finalizes, reference and value types, and mapping C++ and .NET fundamental types to one another. Templates and generics are both supported, and you’ll have a choice of compile- or runtime binding. C++ will support deterministic cleanup, so you know exactly when something is destroyed. You’ll also be able to use the STL.NET library for secure library functions.

You’ll also see better interoperability, the company promises. In Whidbey, C++ will support everything the CLR supports. With a compiler switch turned on, you’ll get errors if your library will not work with that of another language.

Optimization is a topic close to many C++ programmers’ hearts. One new feature to look for is profile guided optimization. If you have sufficient user data and an understanding of how the program will be used, you can show the system, “This is how my application will be run,” making clear which actions are most likely. (For example, most transactions do go through without error, so that’s where you want the compiler to do most of its optimization for both speed and value.) Your application is probed to collect data with a histogram of values and “hot-cold path” information. The new C++ will do (or do more) switch expansion, in lining decisions, and virtual call speculation. MSIL will also be optimized “so the back end will run even faster,” explains Vora.

Naturally, C++ will cuddle up much closer with .NET. By recompiling /clr, says Vora, a developer can take advantage of all the functionality built into .NET. “That means he cans just use the multitude of classes/functions provided (which can do a lot of his job for him) rather than writing all that code himself. This can be, as you can imagine, a major time-saver,” she says.

What’s this mean in regard to standards? Microsoft is working with ECMA to create a standard for the language C++/CLI. When TG5 has completed this specification, it will be submitted to the Ecma General Assembly. Herb Sutter, convener of the ISO C++ committee, is on the Microsoft team; his participation (and established reputation among C++ developers) bodes well for the community.

What about legacy APIs and frameworks, such as MFC and Win API? “We don’t anticipate not supporting things like that in the foreseeable future,” says Vora. “We still have a team actively working on libraries such as MFC. However, most of MS’s brain sweat is going into making MFC interop better with .NET and letting you host MFC in a .NET application.”

Plenty of C++ programmers expect their compiler to do the heavy lifting, and they don’t expect to have to know what happens under the hood. (You can easily own a sports car because you want to go fast without any desire to tinker with the engine.) As a result, the user experience—the development environment and its tools—can often feel like the most important element. Whidbey is promising plenty of IDE improvements for C++ programmers. Among them are better IntelliSense (it understands templates and namespaces, for instance), Unicode support, and XML comment support (which C# already has). Browsing capabilities include live references, call graphs, inheritance browsing, and class view filtering.

A lot of attention has been invested in improving how C++ works with large development teams, according to Vora. There are custom build rules, better IntelliSense performance on large projects, and project property sheets. The goal of all this, says Vora, is to enable developers to make the best use of their time.

Microsoft’s goal is to have a ‘competitively compliant’ compiler – meaning it won’t be 100% compliant. There are a couple of features of the ANSI/ISO standard (for instance the ‘export’ keyword as applied to template classes) that won’t be implemented because they are considered by Microsoft to be obscure and, at this stage, theoretical. Microsoft is however working to ensure that Visual C++ will compile the most popular libraries such as Boost, Blitz, Loki and a fully compliant version of STL. The emphasis is on a level of compliance that allows popular libraries to be compiled, not 100% compliance.

Nick Hodapp, Microsoft’s C++ Product Manager also added that while high compliance is definitely a very important goal Microsoft would not sacrifice code-generation quality or robustness at the cost of extreme compliance. However in recent lab tests they are still beating several popular compilers on conformance tests.

For the pending release of Visual C++ .NET (VC7) Microsoft focused on enabling interop features.  VC7 has the best interop scenarios of all the managed languages and includes the ability to have both managed and unmanaged code in the same image.  They also focused on enabling optimization technology on the generated MSIL – the result is that VC7 is the only compiler to generate optimized MSIL.  In future releases Microsoft will focus on ANSI/ISO conformance (enabling many more features for both managed/unmanaged code), as well as features that will give Visual C++ feature parity with C# – WinForms, for example.  Visual C++ will be positioned as the power-systems language for .NET.

Template support and generic programming are a must and Microsoft is very keen to implement code DOM support, both for ASP.NET and WinForms. With these added features we see Visual C++ as being the power programmers’ language of choice for the .NET framework – to compliment it is current role as the language of choice in unmanaged development. Even without the template support that is currently being pursued we see Visual C++ as the only language suitable for those who need more than C# or VB.NET can offer.

Microsoft’s approach to adding new features is whether those features are

Being used in code that other compilers can build, or

Whether those features are compelling enough that it becomes apparent that their customers want them.

Microsoft will not simply implement features because they are specified in the standard.  They will implement them when people want them because they are beneficial.

The message is that Visual C++ is definitely alive and kicking and has a very bright future in the .NET world. Microsoft’s aim is to have the compiler at a point where it’s the benchmark against which all other compilers are compared – in terms of simplicity, fun factor and conformance. It should be easy to use, versatile, enjoyable, and it should be what developers think of whenever they think C++.

Continuing improvements in C++ compliance along with future support for ASP.NET and WinForms will ensure that Visual C++ be the power language for .NET and for native development.

As to the question of whether developers will move to C# instead of managed C++ Stanley thinks there will be more of a move from VB to C# than C++ to C#. C++ is the better, more versatile and the only optimized compiler available in .NET.

Jonathan Caves, developer on the Visual C++ Compiler Team, speaks about plans

His team has for the next release of Visual C++.

“After the last release of Visual C++ we took a long, hard look at the compiler source base and decided we needed to take the time to seriously invest in reworking our existing code base – some parts of which are over 20 years old. We have plans to really improve the development process for both our existing native C++ customers as well as our newer C++/CLI customers. Unfortunately these changes are going to take time to implement and we definitely can’t do anything in the next release (called Orcas), which has a short development cycle.

So instead of working on the next release of Visual C++ most of the compiler development team will be full steam ahead working on the future generation compiler – we are not yet sure exactly what form this compiler will take but we do know that it will really improve and re-energize the C++ development process.

This does bring up the question of what C++ compiler enhancements will be in Orcas.  Notice I said “most of the compiler development team” as we are not putting the whole team on the future generation compiler – instead we have left one developer, yours truly, to work on the current source base. We know that C++ is still one of the most widely used programming languages and that we can’t just let the current Visual C++ compiler stagnate so I’ll be working on keeping it ticking.  This is mostly going to involve bug fixing (and I hope that most of the bugs I fix will be ones reported by our customers) though I also think that I may find time for a few small features!

One thing we did after Whidbey, as part of analyzing our source base, was to categorize the remaining bugs in the database. This analysis showed some areas of the C++ language in which the compiler support was less than what we would have wished it to be.  We made an effort to address these areas and in some cases we think we can get this work into the next release of the compiler.  One example is the interaction between friend functions and templates.  In many other cases, however, the work became so big (like rewriting the code that handles the parsing of qualified-names) that we decided to just move it to the ‘future’ compiler. Going forward I know of other ‘problem’ areas in the compiler that I am pretty certain can be addressed without needing major reconstructive surgery.

But these small features aside, most of the work on the compiler for the next release is going to bug-fixing and I know from interacting with many of you over the last few years that you’ll be quite happy about this.  I’m sure you’ll welcome a compiler that doesn’t introduce a lot of new features and instead focuses on improving the quality of what we have.  So if you have a serious bug you feel we need to address you should definitely open an issue on the Product Feedback site but please be aware that I am only one person and so, unfortunately, I won’t be able to fix each and every bug.  I can assure you though that as a team we will focus on the bugs we believe have the greatest impact – like compiler crashes (especially without any error message), bad code generation, blocking issues, etc.”

Peter Michael Osera, program manager on the Visual C++ compiler front end, said that their work to update MFC to use elements of the new Vista UI, Aero. They recently finished their efforts to integrate the new Vista- style   file dialogs into MFC. The customers do not need to do anything special to take advantage of this feature. As the top priority was making the transition to Vista as seamless as possible, the MFC code that uses CFileDialog must be only recompiled under Orcas.

Underneath the covers, the new file dialogs are exposed through a new set of COM interfaces collectively known as the common item dialog.  As this is a large departure from the old common file dialog APIs, much of the work consisted of wedging as much of the new common item dialog functionality through the CFileDialog (MFC) API as possible.  The end result is that you can use the same interface as before to control both the old and new dialogs.

Of course, because of the redesign of the underlying file dialog objects, some old functionality of the CFileDialog class is not supported when using Vista dialogs.  In particular, since the new Vista dialogs no longer support hwnd template customization, your CFileDialog object will throw CNotSupportedException if SetTemplate is called on it.

Instead of using templates, it is we recommended, along with the windows team, to use the IFileDialogCustomize COM interface to add controls to your dialog objects.  In the spirit of MFC, we’ve exposed getters for the entire common item dialog COM interfaces so you can get at the remaining functionality that is not exposed through CFileDialog.  In general, if you customize your CFileDialog object extensively, please make sure to review the updated MSDN documentation when it is available to make sure that the methods, events, and flags you use are supported with the new dialogs.

The Visual C++ team is excited to announce the release of Visual Studio 2005 SP1!!!  The Service pack launched on Friday December 15, 2006 and is available for download. This SP addresses issues that were found through a combination of customers and partner feedback, as well as internal testing.

There are over 400 Visual C++ bugs that have been fixed with issues ranging in severity from minor syntax highlighting problems to customer reported crashes across various scenarios. In some areas, more than 50% of the bugs addressed were reported by customers through the MSDN Product Feedback Center and Microsoft Connect. Overall, Service Pack 1 offers customers improvements in responsiveness, stability and performance for Visual Studio 2005.

Service Pack 1 also provides over 70 improvements for common development scenarios including:

• New processor support (e.g., Core Duo) for code generation and profiling
• Performance and scale improvements in Team Foundation Server
• Team Foundation Server integration with Excel 2007 and Project 2007
• Tool support for occasionally connected devices and SQL Server Compact Edition
• Additional support for project file based Web applications
• Windows Embedded 6.0 platform and tools support

For developers using Visual Studio 2005 on Windows Vista, Microsoft is in current development on an update to Service Pack 1 called the ‘Visual Studio 2005 SP1 Vista Refresh Beta’. This update builds on the improvements made in SP1 and delivers a first class experience for developers wanting to take advantages of the new features in Windows Vista. The Visual Studio 2005 SP1 Update for Windows Vista is expected to ship after the consumer availability of Windows Vista in Q1 of 2007 and is now available in beta.

Zeev Suraski, one of the founders of PHP, said that the simplicity of this scripting language means it will be more popular than Java for building Web-based applications. About 22 million Web sites employ it, and usage is steadily increasing. The fact that PHP is an open source programming language makes a great case against its competitors. It has a cheap, fast, reliable and widely supported environment to run in; therefore it is mainly used in standard Web deployment, not only large enterprises.

The future of dynamic XML document construction with the PHP DOM is here. When working with XML-based applications, developers often find themselves facing the requirement to generate XML-encoded data structures on the fly. It will be possible, soon, to programmatically generate a complete well-formed XML document from scratch and save-it to disk

Java and PHP are drawing nearer to one another, though. Oracle, which also sells Java server software and whose database software can be used as a foundation for either Java or PHP, is among those working on an addition to Java to help the two software projects work together. Specifically, Java Specification Request 223 will “help build that bridge between the Java community and the PHP community”, said Ken Jacobs, vice-president of product strategy at Oracle.

There are main new language features. The most basic and important change in PHP 5 is to use handles (or id’s) for objects instead of implementing them as native data types. When copied, only the handle (the id number) itself is actually being copied; the objects these handles represent are not being copied.

This seemingly minor change in the semantics of the language is the major driving force behind the majority of the new PHP 5 features. It allows the addition of new language features and new PHP extensions, such as the great Simple XML that takes full advantage of the new semantics.

Without going into too much detail (or this article would become a book), the following is a list of new language features in PHP 5.

New object cloning semantics as mentioned, the scripting engine never automatically clones objects in PHP 5, whether they are assigned, passed by-value, or returned by-value from a function. If cloning is required, then the developer may explicitly clone an object by using the new clone keyword (for example, clone $obj .

The developer may also implement a method named __clone() in his class, which will be called on the new resulting object, after the clone operation has copied all of the original object’s properties. Implementing this callback is not required but can be useful if the developer wishes each object to have its own copy of a certain resource, thereby creating a new version of that resource for the cloned object (otherwise, both objects would be using the same resource).

Public /private /protected access modifiers: PHP 5 supports the PPP (Private /Public/ Protected) access modifiers commonly found in other object-oriented languages, such as C++ and Java. These access modifiers may be used on both properties and methods, and impose access restrictions. Other extensions that take advantage of this ability include the Simple XML, SOAP, and Perl extensions.

PHP5 is going down the road of Java and copying its object model and other ideas.
That’s no bad thing but most PHP developers surveyed don’t want that. Adoption of PHP4 was much faster than PHP5 is, possibly because there was such a huge difference between versions 3 and 4. If PHP5 features were really “must haves” then people would be crying out for them.

C++ will be around for a long time. It’ll be used forever by embedded systems programmers and programmers who write traditional kinds of apps. But for those of us who write Web apps, C++ will become an anachronism.

Yukihiro Matsumoto (“Matz”), the creator of Ruby, is a professional programmer who worked for the Japanese open source company, netlab.jp. Matz is also known as one of the open source evangelists in Japan. He’s released several open source products, including email, the emacs-based mail user agent, written entirely in emacs lisp. Ruby is his first piece of software that has become known outside of Japan.

In the near future, the adoption of Ruby on Rails will grow more than that of other technologies with 22 percent and 24 percent of respondents expecting to use these platforms in the next 12 months.

It’s been almost eight months since the last major release of Rails introduced RJS, respond to, eager loading, and much more. It is about time latest batch of big ideas was introduced, polished in the interim. Since this is a major new release. Josh Susser, its creator, said that it represents only a step to the future developments. There are already new features that may not appear to have the immediate glitz and glamour the likes of RJS; they still represent a big fundamental shift in how a lot of rails applications will be created from this days forth.

REST and Resources, and general HTTP appreciation, is the star of Rails 1.2. The bulk of these features were originally introduced to the general public. In the future, we can start thinking how the application could become more RESTful. The biggest benefit is hidden: a clear approach to controller design that will reduce complexity for the implementer and result in an application that behaves as a much better citizen on the general web.

The help the transition, there is a scaffold generator that will create a stub CRUD interface, just like the original scaffolder, but in a RESTful manner. This release looks like a fantastic, great release, having spectacular promises for the future.

Ruby will continue to grow and change. The above information is only what we think we know at this point in that process. For the past couple of years, Ruby seems to have been popping up all over the place.

Mac OS is focusing on Carbon for its future development, for a solid, modern operating system, and good news also for the developers who want to preserve their investment in many years of development, as almost all-professional Mac design software is Carbon.

It looks also like Apple should freeware Carbon API’s and stuff it on top of Linux and make it the free User Interface STANDARD for all Unicies (Unixxen)! This will be, finally, a UNIX interface.

Carbon is the set of programming interfaces derived from earlier Mac OS APIs that can run on Mac OS X. Some of these APIs have been modified or extended to take advantage of Mac OS X features such as preemptive multitasking and protected memory.

In addition to being able to run on Mac OS X, Carbon applications built for Mac OS X can also run on Mac OS 8 and 9 when the CarbonLib system extension is installed. (As always, you should test for the existence of specific features before using them.)

Carbon includes about 70 percent of the existing Mac OS APIs, covering about 95 percent of the functions used by applications. Because it includes most of the functions you rely on today, converting to Carbon is a straightforward process. Apple provides tools and documentation to help you determine the changes you will need to make in your source code, as well as the header files and libraries necessary to build a Carbon application.

Mac OS X brings important new features and enhancements that developers have asked for, and Carbon allows you to take advantage of them while preserving your investment in Mac OS source code. As Apple moves the Mac OS forward, Carbon ensures you won’t be left behind.

Carbon applications gain these benefits when running under Mac OS X:

• Greater stability. Protected addresses spaces help prevent errant applications from crashing the system or other applications.
• Improved responsiveness. Each application is guaranteed processing time through preemptive multitasking, resulting in a more responsive user experience.
• Dynamic resource allocation. More efficient use of system resources, including the elimination of fixed size heaps, means your application can allocate memory and other shared resources based on actual needs rather than predetermined values. Each application can access up to 4GB of potential addressable memory.
• Aqua look and feel. Apple’s newest user interface is available only to applications that run natively on Mac OS X.

The Carbon programming interface consists of the following types of APIs:

Classic Mac OS APIs that can run unchanged on Mac OS X. These comprise the majority of the APIs in your current application.

Classic Mac OS APIs that have been modified to work on Mac OS X. For example, to operate properly in a preemptively scheduled environment, a function may now require an additional parameter to specify the context (or process) to which it belongs.

New APIs that can run on both Mac OS X and Mac OS 8 and 9.

For example, Core Foundation and the Carbon Event Manager provide additional benefits for Carbon applications but are not required for porting. New APIs those are available only on Mac OS X.

Currently, the Classic Mac OS APIs makes up the largest proportion of Carbon APIs. However, as Carbon evolves to take advantage of new features in Mac OS X, new Mac OS X-specific APIs will be added that enhance its capabilities.

Carbon does not support a Classic Mac OS function; it is generally for one of the following reasons:

• The function performs actions that are illegal or make no sense in Mac OS X. For example, functions that are 68K-specific, or functions that allocate memory in the system heap (Mac OS X has no concept of a system heap).
• The function directly accesses hardware. The Carbon environment was designed to be fully abstracted from hardware, so such functions are not allowed.
• The function was there for legacy purposes only, and has more modern replacements (for example, File Manager functions that use working directories).

In addition, certain Classic Mac OS programming practices are no longer allowed:

• No 68K code allowed. All Carbon code must be PowerPC-based.
• No trap table access. The trap table and Patch Manager are 68K-specific.
• Limited access to data structure fields. See “Data Structure Access”.
• Carbon lets you create one executable file that can run on both Mac OS X and Mac OS 8 and 9. You accomplish this by linking your application with a single stub library, CarbonLibStub, at build time. At runtime your application links with the appropriate Carbon implementation stored as shared libraries (sometimes referred to as DLLs).

On Mac OS X, your application links dynamically to the Carbon framework, which is a hierarchy of libraries and resources that contains the implementation of Carbon.

On Mac OS 8 and 9, the Carbon implementation is stored as a system extension named CarbonLib. This library contains two types of elements:

• Implementations of all functions specific to Carbon.

Exports of functions currently available in system software. For example, calls to a Menu Manager function available in both Carbon and Mac OS 8 and 9 will merely call through to the implementation in InterfaceLib.

Coldfusion is not dead. I’m not saying this just because I program in CF but because I have programmed in many languages and they all have its advantages and disadvantages. Languages like FORTRAN and Pascal are still being used. Of course not as much as Java, CF or VB and that’s because the technology has changed. Everything is Internet based and older languages are not built for these platforms but they do have their own areas of applications and that’s why they are still being used. Anyway I’m not going to go on with defending CF. I will let CF handle that by itself. Looks like Macromedia had a good quarter.

“Adobe has been very successful in selling into the enterprise. This can only help ColdFusion going forward,” says Dave Mendels, SVP of Adobe’s new Enterprise & Developer Solutions. ‘Scorpio’ is still on course, Mendels confirms, and the ColdFusion product development team is already hard at work devising the best way to harness synergies between CF and Adobe’s LiveCycle products.

The ColdFusion product team is already working on the next great release of ColdFusion codenamed Scorpio, a project that was started before the merger was announced, and one that has continued throughout the transition. In addition, Adobe has been very successful in selling into the enterprise. This can only help ColdFusion going forward.

ColdFusion fits squarely in the new Enterprise and Developer Solutions Business Unit.  Here the team will focus on leveraging the combined LiveCycle, Flex and ColdFusion technologies to provide a rich set of technologies for building and deploying both Web and document-based solutions. The developer market has of course always been a key market for Macromedia and is now also a key market for Adobe.

First, there are capabilities in both ColdFusion and Adobe’s LiveCycle products that could provide mutual benefit to each other.  These include reporting, workflow, document generation, forms design, charting and graphing and more.  The respective product teams are now working together to determine how to best leverage these capabilities in both product lines.

Then there are some obvious areas like PDF document generation.  Given that the PDF document generation was introduced, in its most basic form in the last major release of ColdFusion, it will be natural to extend this capability to leverage the rich set of capabilities offered in PDF.  Things like digital signatures, dynamic forms, workflow and more.  Adobe also offers a forms designer product that could potentially offer ColdFusion a more productive forms design capability.

ColdFusion MX7 has proven to be an incredibly successful product. This success is primarily the result of combining a proven solid architecture with features and technologies that solve real problems. Incidentally, the re-architecture that was ColdFusion MX means that ColdFusion and LiveCycle are built on the same Java foundation – the pieces fit together really nicely.

The ColdFusion product team is cooking up some exciting new capabilities for Scorpio and looks forward to once again providing new, critical advancements in what developers can build and how they build them.

ColdFusion MX7 has proven to be an incredibly successful product. This success is primarily the result of combining a proven solid architecture with features and technologies that solve real problems. Incidentally, the re-architecture that was ColdFusion MX means that ColdFusion and LiveCycle are built on the same Java foundation—the pieces fit together really nicely.  ColdFusion’s Future is Secure.