Future of Search

Visual Basic 2005 may be the latest incarnation of the 15 year old programming language, but an ongoing survey of SerachVB.com readers indicates that more developers are still coding in VB6 that in VB.NET. On top of that Visual Basic 9, code named Orcas, is due for release at the end of 2007. Each new release brings productivity enhancements but also questions about performance and migration. 

VB 9 code-named Orcas, is slated for release with the next version of Visual Studio.  Steven Lees, group program manager of VB at Microsoft, indicated at Tech Ed that VB9 will likely appear “sometime late� and that Microsoft will nail down a timetable for Orcas later. 

Perhaps the biggest enhancement VB9 brings to the table is its ability to work with data. This is accomplished with features like object initializes, anonymous types, and full integration with LINQ, integration with LINQ, or the Language Integrated Query. As Mike Gunderloy wrote in “Let’s think about LINQ�: 

“LINQ is designed as a general purpose query facility that will be baked right into the .Net framework. It allows traversal, projection, and filtering operations to be expressed in a declarative syntax in any .NET language, with benefits including compile-time syntax checking, static typing, and IntelliSense.� 

In a Tech Ed session called Visual Basic today and tomorrow�, Lees described LINQ as an extensible system that works with “pretty much anything that can represent itself as a CLR type.� LINQ uses SQL-like syntax, Lees continued, “but there’s no database in sight.� LINQ technology supports five data domains –LINQ to DataSet, LINQ to SQL, LINQ to Entities, LINQ to XML and LINQ to objects. LINQ to SQL, which will bring raw SQL objects into LINQ, was previously referred to as DLINQ. In addition, LINQ to XML, which supports direct XML coding, used to be called XLINQ.  

Entities refers to ADO.NET Entities, which is data mapping tool the ADO.NET group plans to have in preview form by the end of the year, Microsoft corporate vice president of development Soma Somasegar announced.  This is much noise about the features in LINQ, but the reality is that a vast majority of VB developers know very little about it. A quick show of hands during Lees’ session showed that nearly everyone had used VB 6, about   half had used VB 2005 and only a handful had even heard of LINQ. 

VB 6 developers, and the VB 6 applications they built, will have a home in Vista. In a document entitled Support Statement for Visual Basic 6.0 on Windows Vista, Microsoft states “The Visual Basic 6.0 IDE will be supported on Windows Vista as part of the Visual Basic 6.0 Extended Support policy until March 2008?� 

The document also indicates that runtime support that key VB 6 runtime files will ship as part of Vista and will be supported for the lifecycle of the OS, five years of mainstream support and five years of extended support. A list of key runtime files is included with the document. Binaries that will not be shipped with Vista are going to follow their planned support schedule. 

As for VB 6 applications, Microsoft says the goal of the Visual Basic group is that VB 6 apps that work with Windows XP will wok with Vista. According to the document, “A set of applications written on the Visual Basic 6.0 runtime are being tested for compatibility between Windows XP and Windows Vista with a goal that applications work similarly on both operating systems.�

VB 9.0 is the version for “Orcas�, the codename for the version of Visual Studio that will follow Visual Studio 2005 at some as yet unannounced future date (maybe yearly 2008). 

Keeping track of Microsoft’s doings is so important that we tend to seize on any little tidbit of information and try to build an entire story on it, whether there’s really enough these to justify a story or not. Microsoft recently made available for download the complete session abstracts for this year’s Professional Developer’s Conference (PDC), coming up in Los Angeles.

Here's the entire abstract, which is literally all of the information that Microsoft has so far released on VB 9.0:

“Visual Basic 9.0 will offer radical improvements in its ability to work with data in all its forms: as objects, as XML, as relational data. Join the language architects for a detailed     discussion of features such as query comprehensions, object initializes and anonymous types that enable querying data in a more flexible, natural way than ever before. Also, get a glimpse into the future of dynamic programming in VB with coverage of new features intended to radically simplify working with dynamically typed data on the .NET platform.�  

For a decade people have been predicting the demise of Visual Basic, and with VB.NET, nothing has changed. According to some specialists, the future of VB.NET is threatened competitively by its free cousin, C#. Even after all these years, some people still don't understand that VB—and now VB.NET— will continue to be one of the world's most popular programming languages. Sure, some VB programmers will switch to C#, Java, or Delphi, but the very fact that they would consider making the change highlights the fact that these languages have evolved over time to address issues of usability and functionality that Visual Basic invented. Whatever happens to VB, the language, the spirit of VB has conquered the programming world, and will live on. In fact, VB, as a concept, has never been more alive. It is a visible success.

The earliest releases of Visual Basic didn't make a huge splash, but the language was innovative and attracted considerable attention as a new programming paradigm, because it let programmers build forms visually. For the first time, people could drag and drop controls onto a design surface and see how a program would look without going through the lengthy edit-compile-test cycles required by other languages.  

VB further reduced the edit-compile-test cycle by performing an end-run around it. VB classic, like many earlier BASIC implementations, was an interpreted language; you could edit VB code at runtime. The VB IDE could apply most code changes immediately, even while the application was running, letting you step through a block of code in the debugger, find errors, fix them and then retest the code without stopping the program to recompile. Called "edit and continue," this feature gave VB a major productivity boost over older edit-compile-test languages.  

Programmers loved being able to drag and drop controls, but they weren't completely satisfied with the built-in controls. Fortunately, Microsoft made the architecture for building those controls available to the programming community. Soon, enterprising developers created hundreds of "VBX" controls (and later, ActiveX controls), spawning an entire industry and taking the idea of reusable code to new levels.  

VB was also the first popular general-purpose language to offer truly integrated database access. Via Microsoft’s Data Access Objects (DAO) technology, working with relational databases in VB became so simple that in many cases developers didn't need to know anything about how the underlying relational databases worked; they could simply drag-and-drop database-aware controls onto forms. Even for more advanced developers, DAO (and its successors such as, RDO, ADO, and now ADO.NET) provided huge productivity increases.  

By version three, VB was stable and fast. It had the best IDE available, and was accessible to millions of part-time programmers. VB rapidly became the world's most popular application programming language, and it has maintained that position despite predictions of its demise and substantial changes to the language itself.  

It has maintained its popularity because VB delivers the six things that corporate developers care most about.

1. A BASIC-like, case-insensitive syntax
2. Visual design capabilities
3. A great IDE with an integrated debugger
4. Edit-and-continue
5. A variety of inexpensive, robust aftermarket controls
6. Simple, integrated database support 

Other languages have offered a subset of these features, but none have succeeded in capturing the huge market that VB enjoyed.  

Other vendors have long been covetous of VB's developer base, and made huge efforts to lure VB developers to other platforms. For example, Borland's Delphi language offered everything that VB did except the BASIC-like syntax and edit-and-continue. In fact, Delphi provided more capabilities than VB. For example, it was much faster. Delphi code executes at speeds essentially identical to that of C++. Delphi also shipped with native data-aware controls for its DBase and Interbase desktop databases. In later versions Delphi even provided ADO wrappers. 

But Delphi used an Object Pascal language base rather than a BASIC core and that single feature change helped prevent its widespread adoption. Despite being faster and offering true object-oriented programming (OOP) capability—in short, all the features of VB.NET in a COM-based package—Delphi was never a serious contender for VB's popularity crown.  

The bigger question is whether VB.NET will replace VB. One problem is that VB.NET doesn't have all VB's features yet. In particular, VB.NET is missing edit-and-continue, a long-promised, not-yet-delivered feature that will be key to getting many VB programmers to migrate to the .NET version.  

Code incompatibility is another factor inhibiting migration. Microsoft hasn't made code migration from VB to VB.NET easy enough. While VB.NET syntax is very similar to classic VB syntax, it's not the same. In any case, it's not just the syntax that's changed; it's the addition of the framework. The VB-to-VB.NET upgrade wizard is not now, and probably never will be sufficiently intelligent to migrate all applications seamlessly.  

Still, most VB programmers don't have large vertical applications to migrate; they either write smaller applications that aren't prohibitively expensive to rewrite or plan to maintain existing applications in VB while creating new applications in .NET. For most of these programmers, the language differences are welcome, making VB.NET the only likely threat to classic VB.  

Interestingly, certain advancements in the Java camp are likely to have an effect on Visual Basic programming. By neglecting to create a cross-platform version of its languages, Microsoft has failed to take full advantage of their popularity. Meanwhile, Sun's Java leads in the cross-platform arena with its run-anywhere capabilities, which turned out to be a true business advantage—in the server space. In turn though, Sun failed to take advantage of Java's popularity by neglecting to provide it with GUI development capabilities equal to those of VB. The upshot is that Java is king over a large portion of the server-side, non-GUI applications market, while VB, C++, and .NET languages rule the desktop.  

But nothing lasts forever. Thanks primarily to IBM's Eclipse project; Java developers can now create desktop Windows applications responsive enough to compete with those written in Microsoft's languages. And Sun has announced a push to give Java developers simplified RAD features with Rave.  

Combating this trend will be the various open and shared-source projects that are busy porting the .NET framework to Linux and UNIX. If those projects bear fruit, .NET developers will eventually have cross-platform capabilities similar to those of Java. These changes will make for some interesting shifts and changes, but none of them threaten Visual Basic outright.  

VB.NET is VB's true successor because no other language currently matches VB's feature set as well as VB.NET. But here's the kicker—once you decide to leave VB classic behind, it doesn't really matter which language you learn. If you make the move to VB.NET, you'll find that it's perfectly possible, if not quite as comfortable, to program in C# or in J#.  

Even if you've decided to make a complete break with Microsoft and switch to Java or Delphi, you'll find that after you learn those languages and frameworks, switching to .NET aren’t terribly difficult. The ideas behind programming in all those languages are, with few exceptions, identical. They're differentiated by syntax and IDEs far more than they're separated by concepts or capabilities.  

Whether apps are accessed strictly within an enterprise or developers need to share Web based docs with outside parties, one content sharing platform is using AJAX technology to enhance search and browse features for its on-demand service. 

The final release of open source AJAX framework 1.0 is now available. The project extends the benefits of JavaScript and XML functionality to component framework Java Server Faces (JSF), which supports UI development for J2EE applications. This is a great application leading to the future AJAX development. 

AJAX -based platform lets users share apps with the world; whether apps are accessed strictly within an enterprise developers need to hare Web -based documents with outside parties, one content sharing platform is using AJAX technology to enhance search and browse features for its on-demand service.

Stephen Walther, Super Expert pointed us to a new Ajax framework released for Microsoft .NET named Lollygag. The Lollygag framework includes a rich set of client-side widgets that you can use to display database data, perform form validation, and create rich animations. 

Accessing database data with the Lollygag framework is easy. You can bind client-side widgets directly to data exposed by a database or you can bind widgets to data exposed by a business object.  

When taking advantage of the Lollygag framework, you specify how a form field is validated only once. The validation is automatically applied on both the server and the client. Unlike other frameworks that only provide validation on the client, the Lollygag framework prevents malicious users from bypassing client-side validation and submitting data directly to the server. 

Lollygag includes an entire animation framework. You can take advantage of animations to create different effects such as fades and wipes.

The full Lollygag framework works on the latest versions of Internet Explorer, Firefox, Safari, and Opera. 

The Lollygag framework compresses all JavaScript sent to the browser automatically. Any custom JavaScript code that you write as a developer is also compressed automatically. The server-side portion of Lollygag is built on the Microsoft .NET 2.0 Framework. You can build server-side business objects using standard .NET languages such as C# and VB.NET; Lollygag client-side widgets can consume data exposed through server-side objects.

AJAX does have the right goal in mind, holds up the promise of much quicker response to user input, which is a prime factor in user satisfaction. AJAX also allows user interactivity that traditional Web applications do not provide, such as drag and drop and right click functionality.

Wireless mobile communications in the near future will make it possible for one to communicate with any mobile device anywhere in the world. There is a bright future for mobile positioning as the key technology for enabling LBS applications, which themselves will become increasingly important as a key enabler of value added services.

Mobile positioning technology is also crucial for wireless emergency services. 

Beans of Blue Vector say the new generation of products has "blurred the line" about what RFID middleware is. New software standards plus development efforts in the IT industry may blur the lines as to where middleware is needed. The next installment will examine these developments, and the final article presents views on RFID middleware's future.

Middleware has emerged as an important architectural component in modern distributed systems. The role of middleware is to offer a high-level, platform-independent programming model to users (e.g. object-oriented or component-based) and to mask out problems of distribution. Examples of key middleware platforms include:

• Distributed Computing Environment (DCE)
• Common Object Request Broker Architecture (CORBA)
• Distributed Component Object Model (DCOM)
• Microsoft .NET
• Java RMI
• JINI
• Enterprise Java Beans (EJB)
• Web Services

Traditionally, such platforms have been deployed (with considerable success) in application domains such as banking and finance as a means of tackling problems of heterogeneity, and also supporting the integration of legacy systems. 

More recently, middleware technologies have been applied in a wider range of areas including safety critical systems, embedded systems, and real-time systems. In addition, middleware is required to respond to emerging technical challenges as offered for example by:

• Multimedia
• Mobile computing
• Grid Computing
• Peer-to-Peer computing 

It is now becoming apparent that established middleware technologies (such as the ones listed) are not able to respond to such diversity or to such technical challenges. The main reason for this is the black-box philosophy of existing platforms. In particular, existing middleware platforms offer a fixed service to their users, and it is not possible to view or alter the implementation of this service. Inevitably, the architecture of this platform then represents a compromise design featuring, for example, general-purpose protocols and associated management strategies. It is then not possible to form platforms to meet the needs of more specific target domains. 

Middleware designers are aware of this problem and have responded with a number of initiatives. Focusing on CORBA for example, the OMG have introduced a series of platform specifications including real-time CORBA and Minimal CORBA. These are however specific solutions to specific domains and are not a general solution to this problem. Modern middleware platforms also typically offer more flexibility through mechanisms such as interceptors and configurable protocol stacks. These are important developments but, in our opinion, they do not offer a complete solution to the problem.  

Rather, we believe that next generation middleware platforms should have the following properties:

• They should be configurable to meet the needs of a given application domain (e.g. to provide a minimal configuration for embedded systems)
• They should be dynamically reconfigurable to enable the platforms to respond to changes in their environment (e.g. to respond to dramatic fluctuations in network quality of service as experienced in mobile computing)
• They should support the evolution of the design of the platform as requirements change over time (e.g. to respond to the need to support continuous media interactions).

However, new touch and optical technologies are appearing in products that could radically change how we communicate with PCs--promising not only better ergonomics but also new applications. Many notebook owners have learned to use little touchpad’s in place of mice, but a company called Finger Works is using large touchpad’s in place of keyboards as well.

 

Instead of traditional keys, Finger Works' touchpad’s have silk-screened diagrams representing keyboards: You simply touch the area marked "Space", "Enter", or "8", for example. The company claims this light touch approach decreases stress on your fingers.

Another vision for the future: an infrared transmitter to bounce a beam off an object and onto a small charge-coupled device, like those found in digital cameras and camcorders. But this CCD has a chip that can measure precisely when the infrared beam hits each pixel. By comparing the infrared beam's time of flight to different parts of the CCD, the chip can form 3-D image maps.

 

Automated data entry services will offer a highly efficient method of converting paper to digital form. Using automated character recognition and comprehensive data verification, reduces data entry costs, shortens cycle time, manages peak processing, and provides virtually unlimited processing capacity.

The future offers these benefits without the capital investment in systems and personnel traditionally required. High-speed data capture systems will process thousands of forms hourly, without errors and rework. It will be possible to handle structured forms such as claim forms, enrollment forms, and surveys, and unstructured forms such as invoices, and bills of lading.

The big consumer benefit to RSS is that consumer’s opt-in to content of interest; totally controlling the flow of information they receive. If the quality of the content in the feed declines, users simply remove the feed from their RSS reader and they will not receive any additional updates from that source. Ultimately, RSS will be a standard, like email addresses and websites are now a "must" for businesses.  

RSS, being a tool that saves Internet surfers time and allows webmasters to re-purpose and re-package existing and new content will, in my opinion, continue to thrive. A business effectively using RSS can bring new site visitors, increase search engine positioning, and generate product interest. The flexibility of RSS as a communication medium and the expansion capabilities of the enclosure tag will allow RSS to flourish as an online marketing tool. Each day businesses are adopting new uses for RSS, and users are becoming accustomed to skimming content that they choose in a single centralized location. 

As businesses adopt RSS and consumers experiment with feeds, the popularity of RSS will grow. Ultimately, consumers are the driving force behind technology. The convenience of RSS and increased popularity will set a precedent for consumer expectations. Businesses using RSS as a communication vehicle are able to create keyword-rich, themed content, establishing trust, reputation, and ongoing communication with current and prospective customers.  

The big consumer benefit to RSS is that consumers opt-in to content of interest, totally controlling the flow of information they receive. If the quality of the content in the feed declines, users simply remove the feed from their RSS reader and they will not receive any additional updates from that source. The RSS reader acts as an aggregator, allowing users to view and scan multiple content streams in a timely fashion.  

Consumer expectation will drive businesses that are slow to adopt. Ultimately, RSS will be a standard, like email addresses and websites are now a "must" for businesses. RSS feeds will join their ranks.  

Unlike blogs, businesses can easily justify RSS feeds, as they will be increasing customer and corporate communication. RSS will create new revenue channels. RSS has the potential to help companies develop strong relationships with consumers and create brand loyalty. RSS Feeds will draw existing customers and prospective clients, translating to a new or renewed income stream. Businesses using RSS feeds as a communication medium to notify interested customers of specials, discounts, product announcements, technical support tips, news and industry studies will ultimately sustain RSS as a viable and valued communication medium 

RSS feeds will join their ranks. Businesses using RSS feeds as a communication medium to notify interested customers of specials, discounts, product announcements, technical support tips, news and industry studies will ultimately sustain RSS as a viable and valued communication medium. 

Since Ruby is human-oriented it shouldn't change that much, but the scale of the data being processed will change, so scalability is the key.

There was a follow-up comment from someone running Ruby on embedded systems and is concerned about bloat of the core libraries. Matz replied that additions to core will be minimal; that the standard distort will certainly grow but the core language should be easily separable. So for example, the internationalization framework is in the core, but the specific routines (huge) are outside. Request was made for changes to the build procedure to allow trimming down the build to leave out non-mandatory components. Good point was made about difficulties in migrating to newer versions due to needing to do custom builds. 

RSS is no longer a science experiment; it's becoming an important part of the infrastructure, which means that a lot of programmers are going to get the assignment of generating and parsing it. Ruby attracts people that love programming. Someone called out that it's like motorcycle-with-training wheels.

XML is a markup language for documents containing structured information.

Structured information contains both content (words, pictures, etc.) and some indication of what role that content plays (for example, content in a section heading has a different meaning from content in a footnote, which means something different than content in a figure caption or content in a database table, etc.). Almost all documents have some structure. 

A markup language is a mechanism to identify structures in a document. The XML specification defines a standard way to add markup to documents. 

Thus, XML is still a complex data type but not a data model. XML has been designed for maximum expressive power, maximum teach ability, and maximum ease of implementation. The language is not backward-compatible with existing HTML documents.  

XML derives from a philosophy that data belongs to its creators and that content providers are best served by a data format that does not bind them to particular script languages, authoring tools, and delivery engines but provides a standardized, vendor-independent, level playing field upon which different authoring and delivery tools may freely compete. 

This is its main development direction. The first step in this long journey is SQL/XML hybridization. Starting with SQL Server 2000, Microsoft began to provide support for XML data. This support has been significantly extended for SQL Server, allowing for XML data columns, XML variables, and XML indexes.  

This new software species did emerge and did popularize the notion of persistence -- that is, the capability of storing and retrieving programming-language objects without arduous translation to and from relational tables.  

According to Microsoft, the forthcoming Yukon edition of SQL Server will be capable of persisting .Net objects. The first step in the long journey of SQL/XML hybridization was to publish relational data as XML. 

Imagine a purchase order flowing through a business process some time in the future. It's an XML document, created with a tool such as InfoPath, carrying a mixture of core data and contextual metadata. The core data, including the item number and department code, will wind up in the columns of a relational table. The contextual metadata, which might include a threaded discussion made from comments injected by the requester, the reviewer, and the approver, will remain in document form.  

"This human context is never stored in the RDBMS today," says Kingsley Idehen, CEO of Burlington, Mass.-based OpenLink. Yet it's the key to understanding how the data got there and what it means.  

Once written, the purchase order is injected into a workflow orchestrated on top of a Web services network. A security service may enforce authorization policy by updating a SOAP header; a choreography service may search for sets of documents that have SOAP headers that contain the same correlation ID. These active intermediaries will need some kind of database technology to manage the XML that lives transiently in their queues, but it probably won't be a job for Oracle or DB2.  

Here a specialized XML database, such as Software AG's Tamino or Sleepycat Software's Berkeley DB XML may be better suited to the task. They're fast and, as Mike Champion, senior R&D advisor at Software AG in Darmstadt, Germany notes they're built to work well with dynamic XML documents even when those documents lack the schemas the RDBMS SQL/XML mappers rely on.  

During the workflow and after it has been completed, the document will be accessible to interested parties via a certain URL. That URL might resolve to a projection of the document -- from a hybrid SQL/XML RDBMS, to an intranet Web server or a WebDAV repository such as Oracle's. Alternatively, the URL might resolve to the underlying instance of the document stored natively in the RDBMS. Either way, the state of the business process -- both core data and contextual metadata -- will be visible at all times to anyone who's interested in looking at it and is authorized to do so. What's more, both flavors of data carried in the document will be accessible to queries that reach across the enterprise, joining SQL and XML sources to create consolidated views.  

A major shift in the style of enterprise data management is under way, and there are huge architectural issues yet to be resolved. Oracle, not surprisingly, wants you to store everything in a centralized hybrid DBMS. IBM says it would rather enable you to federate data across a range of sources. Each strategy has merit, and most enterprises will wind up pursuing both -- in different ways, for various reasons. 

While storing XML data in the database is a terrific feature, the ability to format the XML data as relational data is essential for a large majority of data processing needs. This is where OPENXML enters the equation. OPENXML is a SQL Server function, which accepts a stream of XML data and provides an in0memry row set view of the XML data. 

XML specifies neither semantics nor a tag set. In fact XML is really a meta-language for describing markup languages. In other words, XML provides a facility to define tags and the structural relationships between them. Since there's no predefined tag set, there can't be any preconceived semantics. All of the semantics of an XML document will either be defined by the applications that process them or by style sheets. 

Since XML is a key part of the Office 2007 story, the MS Office team will have a big presence at the Microsoft booth demoting the just-released product and discussing the OpenXML format.  People from the Data Programmability / XML team will also be in the booth to demonstrate some upcoming technology, including the XML Schema designer that Stan's team is developing, the LINQ to XSD technology that Ralf's team just previewed, and we can show you the underlying LINQ to XML API that will be released in the next version of Visual Studio in action.   Please stop by, let us show you our stuff, and by all means let us know if you share our enthusiasm and want to help take XML technology to the next level. 

When working with XML-based applications, developers often finds themselves facing the requirement to generate XML-encoded data structures on the fly, There are functions in PHP’s DOM API, showing how to programmatically generate a complete well-formed XML document from scratch and save it. This is a very spectacular development direction.

The Java Server Pages (JSP) technology provides a simplified, fast way to create Web pages that display dynamically generated content. JSP technology was designed to make it easier and faster to build Web-based applications that work with a wide variety of Web servers, application servers, browsers and development tools.

Developers will use JSP pages to create portable Web applications that can run with different Web and application servers for different markets, using whatever authoring tools fit their market and their needs.  

By working with a consortium of industry leaders, Sun has ensured that the JSP specification is open and portable. You should be able to author JSP pages anywhere and deploy them anywhere, using any client and server platforms. Over time, tool vendors and others will extend the functionality of the platform by providing customized tag libraries for specialized functions.

Java creator James Gosling points out that there are 150 million Java-enabled mobile phones. Although other promising markets exist for the technology, "the one that continues to grow like a weed is cell phones," he says. 

Java is the programming language originally designed by Sun Microsystems for use in the distributed environment of the Internet. It was designed to have the “look and feel� of the C++ language and uses the object oriented programming model. Java is supposed to work across all servers that run the Java Virtual Machine, enabling programmers to create “write once, run anywhere� applications. It can also be used to build small application modules, or “applets� for use as part of Web pages.  

Despite rumors of its demise, Java is alive and well on the Windows desktop, according to Microsoft and Sun Microsystems. Representatives with both companies confirmed that the two companies have extended security patch support for Microsoft's version of the Java Virtual Machine (MSJVM) until December 31, 2007.

Another important challenge in this era in which we will be surrounded by billions of increasingly intelligent devices, all communicating with one another, is the obvious need to simplify and quicken the process of application development, deployment and maintenance. In this regard, Java appears postured to play an increasingly significant role.  

Although Java seems to failed to hit the target for which it was first developed (whish was to serve as an embedded operating system within smart devices), Java ended up providing a convenient means to enable moving applications around among computing devices, propelled to this position by the emergence made in a dramatically and spectacular way, of the Web. 

Today Java is showing promise in the role of providing a device independent application platform, running on top of the embedded operating system. In this case, rather than serving as the operating system itself, Java provides the benefit of masking the aspect of the underlying device and providing an array of services beyond those offered by the embedded operating systems.   

In the context of an exponential proliferation of smart devices, Java is emerging as a handy way to minimize device specific development and to allow developers to focus on the truly unique aspects of their projects; increasingly, Java will provide the means to obtain functionality like Web browsers, GUIs, handwriting and speech recognition, protocol stacks, wireless communications, multimedia support, database management and a wide range of remote services. 

In the new, exciting post PC world of pervasive computing, we will be surrounded by an exponentially growing number and variety of intelligent, interconnected devices. But the challenges associated with developing, maintaining and supporting increasingly sophisticated system architectures and protocols also will grow exponentially.

In the context of an exponential proliferation of smart devices, Java is emerging as a handy way to minimize device-specific development and to allow developers to focus on the truly unique aspects of their projects. Increasingly, Java is providing a means to obtain functionality like GUIs, Web browsers, protocol stacks, handwriting and speech recognition, wireless communications, multimedia support, database management and a wide range of remote services.  

Looked at from this perspective, the emerging popularity of Java technology as a well-supported application and services framework for devices, offers an enticing possibility of ready-to-use components that can be used along with embedded Linux, to speed and simplify device development and to enhance the capabilities of the end product.  

Sun Microsystems announced the 11/13/2006 that it has begun the process of releasing its Java Platform Standard Edition (Java SE) and a build able implementation of its Java Platform Micro Edition (Java ME) as free software under the open-source GNU General Public License.  

Microsoft is an awesome company when is has competition. .Net is a great example of this. .Net kicks Java with a set of spiked golf cleats “where it counts� on just about everything. Microsoft needs a competition from Java to keep the honest. .Net would not have happened if not for Java, most likely. And the pressure from Java keeps Microsoft driving hard for improvements. As we know that Java can show itself to be a superior system, many programmers will consider that they will see Java the best that it can be.   

Java Platform, Standard Edition (also known as Java 2 Platform) lets the user develop and deploy Java applications on desktops and servers, as well as todays demanding Embedded and Read-Time environments. Java SE will include classes that support the development of Java Web Services and provide the foundation for Java Platform, enterprise Edition (Java EE). James Gosling, often called the father of Java technology, announced JavaOne in June 2006. It was not a question of “whether� but a question of “how� Sun would open source Java platform. “We want better conversations with the developer community, a more collaborative relationship.  

We want to have better relationships with many of the Linux distributions, and a lot of the Linux distributions are very sensitive about precisely which license one uses. We want to have relationships with the open-source community, which leads to better distribution and makes it easy for people to collaborate with us to evolve the platform, to use it in even more interesting ways and in more interesting areas.� said James Gosling. The source code is being open-sourced, but the process of defining the specifications is still the Java Community Process. In addition, there are massive test suites, and Sun will do an immense amount of testing. They expect that people who care about reliability and compatibility with the specifications will use the new version soon. 

From a financial point of view, the Java platform has been free to all of these enterprises and such since day one. And so from that point of view, this really isn’t going to have an effect on Sun’s financial situation. Java is able to evolve faster, although they are currently evolving pretty darned fast. Sun is always interested in people using Java technology in different ways and in different kinds of environments. Certainly, being pen source makes it much possible. Java platform will be available for a very long time.

Delphi.NET preview pack consists of the Delphi for .NET CIL compiler, VCL for .NET and produces safe code. Designed to provide the first experience with Delphi for .NET next year! Conclusion is simple: "Delphi is going .NET, though the timescale may disappoint the most diehard .NET fans. Even if you don't ever intend to do any .NET programming yourself, the changes to Delphi that will take place as Borland retools Delphi for the .NET framework will improve your life� said Zarco Gajic, Delphi senior developer.  

“We plan to continue supporting more and more .NET technologies in Delphi - such as Compact Framework, .NET Whidbey, and Yukon, all the way to Longhorn, WinFX, and beyond. So whether you're a long time Delphi Win32 developer or a soon to be .NET developer or both - if you haven't yet upgraded to v7 or v8, I highly recommend the upgrade to Delphi 8 (which includes D7 for Win32 in the box) it's a great value for both Win32 and .NET developers.� said Michael Swindell, from Borland Software Corporation.

At the German EKON9 conference, was presented a very detailed Delphi roadmap. This doesn’t cover only the future .net 2.0 support (Highlander), but includes the plan for a native 64-bit compiler and multiple versions of the VCL for compact framework and Avalon.  

The Roadmap

• Dexter (end 2005) will have ECO 3 (with ECO Basic in all Delphi editions), specific support for 64bit .net, a full-blown version of Together for Delphi, focus on performance and quality.
• Highlander (2006) will support net 2.0 and provide a VCL for .NET 2.0, VCL for Compact Framework, support for 64bit .NET 2.0
• Delphi for Vista (2007) will include a VCL for Avalon and Indigo support
• Delphi/C++ for win64 (circa 2007): the name says it all

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.

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.

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.

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.

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