Free Projects for all IT students

History Of Computer

2009-05-03T23:51:00.000-07:00

Introduction
From the dawn of time, human beings have always tried to find new ways to solve problems, be more productive, work with numbers faster, and have better ways of storing information. Possibly early humans used stones to count items, which lead to the abacus, then to the slide-rule, and then later calculators. These machines allowed human beings to do these things faster and better than they could do them in their minds.
Early Computers
The Mechanical Age
Since the early ages of computer history there has been innovations that have led to the advancement of technology. The first computers were mechanical, and sometimes prone to errors. They were calculating machines. Blaise Pascal built a numerical wheel adding machine in 1642 in order to help out his father, who was a tax collector. It was a heavy burden to add numbers by hand, and Pascal had seen it as a chance to relieve that burden.
In 1673 Gothfried Willhelm von Leibniz, a German mathematician, built a calculator device that could add, subtract, multiply, and divide. It provided more functions than Pascal's machine and allowed users of it to solve more problems. Yet both Pascal's and Leibniz's machines were not totally dependable and suffered from flaws.
Mechanical Innovations
Joseph Jacquard, a French weaver, designed a punch card loom in 1805. A chain of punch cards in an certain order, provided instructions for the loom to control it. This allowed patterns in the weave as the machine weaved threads. The pattern could be changed by changing the cards used to different cards. This later lead to storing computer instructions on these cards.
Charles Xavier Thomas, another Frenchman, worked on a new mechanical computer. He called it the four-function machine and it was more reliable than Pascal's or Leibniz's machines. This was in 1820 as technology had progressed, and Thomas learned from Pascal's and Leibniz's works and flaws.
Larger Scale Mechanical Computers and Logic
Charles Babbage and Ada Lovelace made contributions since 1842. The Difference Engine, the machine that became the template for the Analytic Engine, was an automatic logarithm tabulator and printer. It had a memory unit, automatic printout, sequential program control and punch-card input. The punch card idea was borrowed from Jacquard's loom.
Babbage had worked with computers for 20 years with the British government, and the government was threatening to withdraw funds because it had nothing to show for its investments. The project needed someone new to help out, and enter Ada Lovelace, daughter of Lord Byron and Lady Annabella Milbanke. Lovelace corrected some of Babbage's mistakes in the instructions and became the world's first debugger. It was a milestone for women in computer history. Lovelace suggested a binary system of numbers be used, which set the standard of future computers to use.
Sadly the Difference Engine did not function properly. The technology to create proper gears and shafts was not good enough to provide accuracy. Yet it helped pave the way for future computers. Later the IBM Corporation was able to build a working model of the Difference Engine using more modernized parts.
Early Electronic Computers
Early Programming Languages
The first version of a programming language arose from work by Ada Lovelace, the benefactor and business partner of Charles Babbage. Unfortunately her work went mostly ignored since Babbage never built a completed Analytical Engine so there was no public deployment. She is remembered in the programming language still in use on military-grade projects, Ada.
Wiring and Raw Binary
Early work with analog and electromechanical computers did not involve programming languages the way we know them. Since early computers needed to be wired directly for each problem set, the process of setting plugs took the place of having a text-based distillation of an algorithm.
As electromechanical machinery gave way to mercury delay lines and drum memory, it became possible to write directly to addresses in memory and provide instructions without rewiring. This typically meant writing what we would call "machine code". This often gets called "hex" today, as modern 32-bit and 64-bit microprocessor systems read binary data in 8 or 16 hexadecimal chunks per clock cycle.
Writing code at the machine level is difficult: it requires that the programmer know the specific locations for registers in hardware and the instruction set for the processor. Reading machine code is often more difficult than writing it, thus tracking code changes is nearly impossible for a human.
Assembly
The first upgrade to the machine code level of programming was assembly language. This provided a way to write machine code with string manipulators and names for instructions instead of the raw binary versions. It can still be difficult to read and still requires knowing which instructions and register locations exist, but it can be read on paper or screen and assembled into machine code cycle by cycle.
Assembly programming has not gone away. Most device drivers for computer peripherals are written in C code, but some real-time glitches are best resolved by hand optimizing the mid-step assembly output from the C compiler. This is becoming increasingly rare.
FORTRAN
FORTRAN Stands for FORmula TRANslation. This language was invented at IBM in the mid-1950s for the IBM 704 series computer.
BASIC
BASIC stands for Beginners All Purpose Symbolic Instruction Code
In computer programming, BASIC (an acronym for Beginner's All-purpose Symbolic Instruction Code[1]) refers to a family of high-level programming languages. It was originally designed in 1963, by John George Kemeny and Thomas Eugene Kurtz at Dartmouth College, to allow students not in science fields to use computers. At the time all computer use required writing custom software, which was something only scientists and mathematicians tended to do. It became widespread on home microcomputers in the 1980s, and remains popular to this day in a handful of heavily evolved dialects.
COBOL
COBOL, an acronym that stands for COmmon Business Oriented Language, is a high-level programming language developed in the 1960s and still used in business applications. It is used extensively in the financial services industry for large scale mainframe based applications. It uses instructions resembling English statements and imposes an overall framework for a program. The design goal for COBOL was a language that self-documented so that it could be revised and maintained easily.
PL/1
Programming Language 1 is a high-level programming language designed for scientific, engineering, and business applications. It is one of the most feature-rich programming languages and one of the very first in the highly-feature-rich category. It has been used by various academic, commercial and industrial users since it was introduced in the early 1960s, and is still actively used today. It supports recursion and structured programming. The language syntax is English-like and suited for describing complex data formats, with a wide set of functions available to verify and manipulate them.
Early 4GL Systems
• MARK IV - source level specified data extraction from existing files
• NATURAL - a language for extracting data from ADABAS files
• IBM RPG - a "Report generator" language that could also generate other types of applications
Analysis and Design
Early Operating Systems
Mainframe Operating Systems
• IBM BOS
• IBM TOS
• IBM DOS
• IBM MFT
• IBM MVT
• IBM MVS
• IBM VM
• ICL GEORGE
Personal Computer Operating Systems
• QDOS
• CP/M
• MS-DOS
Operating system 'wars'
When the PC was introduced, it needed an operating system. IBM approached a company named Digital Research, which was owned by Gary Kildall. IBM sought the use of Digital Research's CP/M, a popular operating system in earlier systems. (It was, in fact, the first operating system that wasn't hardware-specific.) IBM did not want to pay royalties, however, but sought a one time purchase, which included a rename. Digital Research refused, and IBM withdrew. They then approached Microsoft and Bill Gates, who purchased an existing operating system (Seattle Computer Company's 86-DOS) and renamed it MS-DOS. This name was later used on non-IBM models; Microsoft agreed to IBM's desire to use their own name, and the operating system was sold as PC-DOS on the PC.
86-DOS was modeled after CP/M, and Digital Research filed legal action for patent infringement. IBM settled by offering computer buyers a choice of either; however, CP/M-86 (as the PC version was named) cost almost $200 more than PC-DOS, and it did not sell well.
MS/PC-DOS quickly became the standard for the PC-compatible market. Digital Research would attempt to regain the market, eventually settling on an MS-DOS clone, DR-DOS. DR DOS was sold off the shelf (while MS/PC-DOS was only sold bundled with new computers), and would later gain a large market share with version 5, which had new memory management that broke down an early limitiation of DOS, a maximum usable memory of 640 kB.
By this time, Microsoft was holding the market not only with MS-DOS, but Microsoft Windows, a graphical shell program for DOS. Windows was based on the Macintosh, and Apple filed suit. Complicating the matter was a suit against Apple by Xerox, claiming that Xerox was the rightful owner of the design. Eventually, it was ruled that the design factors in question could not be copyrighted, and Macintosh and Windows continued to coexist.
In 1995, Windows was re-worked to be a self contained operating system, Windows 95. By this time, DR-DOS had been sold twice, becoming Novell DOS 7, then Caldera DR-DOS 7. IBM had also split from Microsoft and was developing PC-DOS 6 separately. The new version of Windows that didn't coexist with DOS was ultimately the focus of an anti-trust lawsuit against Microsoft. Despite this, Microsoft was able to continue developing Windows.
Today, the market is dominated by the IBM PC-compatible computer, the majority of which run Microsoft Windows. Also present is an up-and-coming system, Linux, which is an open source system based on UNIX (an alternate PC-compatible system dating to the late 1970s; it was more complex and used for industrial, rather than home, use). On a separate platform, the Apple Macintosh also exists, running the newest Apple operating system, Mac OS X.
• OS2/ WARP
Early Database Systems
• ADABAS
• DL/1
Early 'Utility' Systems
Sort/Merge
Printer Spooling
• FIDO - for IBM DOS
• JES2 - for IBM MVS
• JES3 - for IBM MVS
Teleprocessing Systems
• BTAM - Basic telecommunications access method
• BATS -
• FASTER -
• TCAM - Telecommunications Access Method
• Qtam -
• CICS - Customer Information Control System
• Intercom -
• Browns Operating System -
• VTAM - Virtual Telecommunications Access Method
Early Application Systems
• "Works Records System " - a multi-user interactive spreadsheet application - produced at ICI Mond Division in Northwich, Cheshire, UK c1974
Early Innovations
The Vacuum Tube
The vacuum tube, also known as a valve because it controls electron flow the way a washer valve controls water direction, was originally developed to amplify radio signals. Its use as a logic gate, which practical, required massive power consumption and a steady supply of replacements.
Tubes were not meant to be turned on and off rapidly, thus they would burn out regularly on computers but can last decades on stereo and musical instrument amplifiers.
Vaccum tubes need a lot of electricity and also produce a lot of heat so they need plenty of ventilation or air conditioning.
The Transistor
Shockley, Bardeen and Brattain's invention of the junction transistor resolved the vacuum tube limitations and in the process started the shrinking of computers.
The transistor is a solid-state logic gate switch: it does not need to heat a filament nor make a change in physical contacts to cause a change in electron flow. Its centerpiece is a semiconductor, a solid material that can be a conductor or resistor depending on the adulteration of the substrate.
The original substrate for transistors was germanium. The move to silicon, one of the most readily available chemicals on Earth, made transistors cheap to manufacture and eventually made computers ubiquitous.
The Integrated Circuit
There are several types of transistors which combine to make full logic circuits.
The Microchip
Vaccum tubes were replaced by the transistors and a number of 1000 transistor were replaced by 1 microchip. Thus microchip were discovered.
The Early Microcomputer
Altair
The MITS Altair 8800 was designed around a new microprocessor, the Intel 8080, and debuted in 1975. Its announcement on the January 1975 issue of Popular Electronics magazine led the Albuquerque-based manufacturer to a four-month backlog attempting to fill orders.
The Altair is considered the first home computer. Its only input was a series of front-panel switches. However, it had a motherboard with a bus, which allowed other companies to provide keyboards, tape readers and other devices to access the registers.
A group of Harvard students wrote a BASIC interpreter for the MITS. These students -- Steve Ballmer, Paul Allen, and Bill Gates -- left school to focus on code development and not long afterward created MicroSoft.
Apple II
The Apple II was produced by Apple Computer. It used a BASIC-type operating system and was marketed toward home use.
Radio Shack
• TRS-80
Commodore
Commodore Pet
Commodore Vic 20
Commodore 64
The Commodore 64 was a revolution at the time it was released in 1981, expanding on the Vic 20's 8 colors to an amazing 16 colors and increasing the screen resolution to 40 columns and 25 lines. A 3 voice synthesizer topped off the features of this amazing computer.
In its time. the Commodore 64 was one of the most popular home computers in the market with thousands of games and business applications available. (I still have a copy of Microsoft Multiplan for the C64)
Its built-in BASIC and a plethora of magazines (ZZap64, Commodore) with programs for readers to enter, enabled many people to learn BASIC and even Machine Code.
In 1986, the C64C was introduced, its changes (a lighter colored case and a different shape) were mainly cosmetic but still compatible with all previous add-ons and software.
Another version of the C64 was the SX-64. This was a "portable" version of the Commodore 64. I use the term portable very loosely, this thing was heavy. It contained a 5-inch color Cathode Ray Tube (CRT) monitor and a built-in disk drive. The keyboard doubled as the lid of the unit.
Commodore64 was a must for its time.
This computer offered:
• An amazing 64K of RAM
• Built-in BASIC
• Built-in TV adapter
• A cartridge expansion port
• 3-channel audio (via the SID chip)
• 2 x D 9-pin input ports
• Serial port
• Optional external floppy drive (the 1541)
• Optional tape drive (normally supplied with the computer)
Commodore 128
Commodore Plus/4
Amiga
The Amiga microcomputer, compared to other computers of its age, was much more advanced in the areas of graphical processing, display, and manipulation. At the release of the original Amiga computer, the Amiga 1000, it was the only machine capable of displaying 12 bit color, using a format known as HAM-12, or Hold And Modify-12. This made it the only machine, for several years, to have as many as 4096 colors on screen at a time. The machine was replaced by the Amiga 500, a slightly enhanced and stripped down version of the Amiga 1000, with some of the same capabilities, as well as some different expansion ports. After the Amiga 500, the Amiga 2000, 3000, 600, 4000 and 1200 machines were released, each having minor enhancements over the previous. Currently, the Amiga corporation has handed off development of a new model, titled the Amiga One, to a separate company. This new machine would support speeds of up to 800 MHz, as opposed to the Amiga 4000, which had a top speed of 60 MHz, not counting the PPC enhancements which were released near the end of the Amiga 4000 lifecycle, which did not do well, due to lack of support from programming companies.
Atari
IBM
The IBM PC was a personal computer built around the Intel 8088 microprocessor (which was modeled after the Intel 8086). It became standardized, and today, the majority of personal computers are IBM compatible.
Apple Lisa & Macintosh
Apple Computer followed the Apple II with the Apple Lisa, and after that, the Apple Macintosh. These computers were unique due to their graphical user interface (GUI), introducing the concept of icons, windows, pull down menus, and mice. (The GUI concept was actually taken from Xerox, via two of their computers, the Xerox Star and Xerox Alto).

Using the Package and Deployment Wizard with the Setup Toolkit

2008-06-26T09:46:00.001-07:00

Using the Package and Deployment Wizard with the Setup Toolkit

In addition to using the Setup Toolkit project to create your own custom setup project, you can use the Setup Toolkit project in conjunction with the Package and Deployment Wizard. In this case, you use the Setup Toolkit project to customize the screens or other parts of the installation sequence, then use the wizard to create and deploy the package for the application.

For example, you might use the Setup Toolkit and the Package and Deployment Wizard together to add dialog boxes to the installation program, prompting the user to specify whether to install optional features in your application. For example, you may have an online Help file that some users would rather not install. You can add as many installation options as you want.

To add an installation option to your setup program

In the Setup1.vbp project, edit the code for the Form_Load event in the setup1.frm form. To add functionality, you add code after the code block calls the ShowBeginForm function (Sub ShowBeginForm).

The following shows an example of how you would add a dialog box that asks if the user wants to install optional files:

Dim LoadHelp As Integer
LoadHelp = MsgBox ("Do you want to install Help? ", vbYesNo)
If LoadHelp = vbYes Then
   CalcDiskSpace "Help"
EndIf
' Block of code containing cIcons = CountIcons(strINI FILES)
If LoadHelp = vbYes Then
   cIcons = CountIcons("Help")
EndIf
' Block of code containing CopySection strINI_FILES.
If LoadHelp = vbYes Then
   CopySection "Help"
EndIf
' Block of code containing CreateIcons, strINI FILES, strGroupName

Close Setup1.frm, save the form and the Setup Toolkit project, and compile to create the Setup1.exe file.

Run the Package and Deployment Wizard, and select Package from the main screen.

Proceed through the wizard, making the appropriate choices. For the example shown above, you would make sure that all optional files the user could choose to install in your custom dialog box were listed in the Add and Remove screen.

Once you are done with the Package and Deployment Wizard, generate the distribution media.

Make any necessary changes to the Setup.lst file. In the example above, you would add a new section with a section you used in the CopySection section of your code. In this case, your section would look something like this:
```
[Help]
File1=MyApp.HL1,MyApp.HLP,$(AppPath),,,10/12/96,2946967,0.0.0
```

Deploy and test your package.

When the user runs the installation program for the example shown in this procedure, the setup program copies all the BootStrap files to the user's machine and then prompts the user to indicate whether to install the Help files. If the user chooses Yes, the CalcDiskSpace statement determines whether there is sufficient disk space on the user's machine for the Help files. The program then installs all of the files listed with the Setup1 Files section in Setup.lst.

Next, the program tests the LoadHelp flag again. If the user chose to install the Help files, Setup1.exe next executes the CopySection statement for the Help files, and installs the files listed in the [Help] section of Setup.lst.

Your Ad Here

Standard Packages

2008-06-26T09:44:00.001-07:00

Standard Packages

Your Ad Here

A standard package is a package that is designed to be installed by a setup.exe program, rather than through the downloading of a .cab file from a Web site. You create standard packages for Windows-based applications that will be distributed through disks, CD, or a network share.

When you create a standard package, you must carefully consider the distribution method you plan to use prior to creating your package. If you plan to use floppies, you must usually create multiple .cab files that can be placed onto several disks, rather than one large .cab file. An option in the Package and Deployment Wizard lets you specify whether you want one or multiple .cab files and the .cab size to use (1.44 MB, 1.2 MB, etc.). If you select multiple .cab files, the wizard splits your application files into several sets that do not exceed the indicated size.

Important Even if the application you plan to distribute on floppy disks is small enough to fit on a single disk when packaged into one large .cab file, you should still choose the multiple .cab option so that you have access to the floppy disk deployment process later in the wizard. In this case, only one .cab file will be created.

If you're planning to deploy to a network or local share, to CDs, or to a Web site, you can create either one large .cab file or multiple smaller .cab files.

Parts of a Standard Package

There are several files that are always part of your standard packages. These include:

The setup.exe file. Setup.exe acts as a pre-installation executable. Setup.exe is the first thing run on the user's machine in the installation process, and it performs necessary processing that must occur before the main installation takes place.

The setup1.exe file. Setup1.exe acts as the main setup program for your application.

All required support files. Support files are stored in the \Support subdirectory, beneath the directory in which the package was created. In addition to the setup.exe and setup1.exe files, this directory contains the files necessary to customize the .cab files for the application if the users so desire.

The .cab files for your application. Both Internet and Windows-based applications are packaged into .cab files prior to distribution. A .cab file takes the place of what was, in previous versions of Visual Basic, a long list of compressed application files. All of those files are now contained within the .cab. You can have a single .cab for your application, or you can create multiple .cabs for floppy disk delivery.

Note If your application will be run on a bidirectional (BiDi) operating system, you will need to manually include the vbame.dll file in the Setup.lst created by the Package and Deployment Wizard. You can do this by adding the file at the Included Files screen when running the Package and Deployment Wizard, by editing the Setup.lst directly, or by adding an entry for vbame.dll to the vb6dep.ini file so that it will be automatically added to the Setup.lst whenever you run the Package and Deployment Wizard.

Data Access Features

If your application uses one of Visual Basic's data access technologies, such as Data Access Objects (DAO), ActiveX Data Objects (ADO), or Remote Data Objects (RDO), the Package and Deployment Wizard performs two additional steps during the packaging process:

If your application uses ADO, OLEDB, or ODBC components, the wizard automatically adds a file called mdac_typ.exe to the list of files to include in your package. Mdac_type.exe is a self-extracting executable that installs all of the necessary components you need for your data access technology.

The wizard prompts you to choose the appropriate data access option when your application includes DAO features. You choose the appropriate method — ISAM-based, ODBCDirect, ODBC through Jet, etc.

Remote Automation and DCOM Features

If your application utilizes remote code components (formerly called OLE servers), you need to create two packages for the application: a setup program for the client, and one for the server. You can use the Package and Deployment Wizard to package the application, simply by running it twice on the same project group — once on the client project, and once on the server project.

Before you package either the client or the server, you must make sure that you have created the necessary remote support (.vbr) files for the project and placed them in the same directory where the .vbp file for the project is located.

To create support for Remote Automation or DCOM

Open the project group in Visual Basic and select the project that will act as the server.

Select Project Properties from the Project menu. Select the Components tab of the Project Properties dialog box and check the Remote Server Files option.

When you compile the project with this option selected, the .vbr file is created automatically.

Registry Files

If your project references any .reg or .vbl files, you will see an additional screen in the wizard where you can specify how this registry information should be treated. You can choose to simply copy the registry files to the end user's computer, or you can have the system store the information in the registry and automatically register it on the end user's computer.

Missing or Outdated Files

As you move through the wizard, a series of dialogs may appear if any files needed by your application are missing or if any files have missing or outdated dependency information. You can either choose to proceed without the dependency information for the component, locate the missing files, or permanently mark a file as requiring no dependencies.

Internet Packages

2008-06-26T09:38:00.001-07:00

Internet Packages

Your Ad Here

Internet packages are .cab-based setup programs that are designed to be downloaded from a Web site. Internet Explorer uses a process known as Internet Component Download to install your Internet application. The Package and Deployment Wizard automatically includes information needed for this process in the packages it creates.

There are several types of Visual Basic applications or components that can be packaged for Internet deployment, including:

ActiveX controls (.ocx files) that are displayed on a Web page.

ActiveX .exe or .dll files, designed to run on the client or the Web server.

ActiveX documents, that are displayed in place of a Web page.

DHTML applications, client-based applications that link HTML pages to Visual Basic code through the use of Dynamic HTML.

IIS applications, server-based applications that link HTML pages to an object called a webclass. The webclass intercepts server requests from the browser and responds to them with Visual Basic code.

For More Information Extensive information about the Internet Component Download process can be found in "Downloading ActiveX Components" in Building Internet Applications in the Component Tools Guide.

Parts of an Internet Package

There are several files that are always part of your Internet packages. These include:

The primary .cab file for your application. The primary .cab file for Internet packages is used as the setup program for your application. The primary .cab file includes project components, such as the executable or DLL for your application or your .ocx file for controls, an .inf file referencing secondary cabs and containing safety and registry information, and all required dependency files that are not in secondary .cabs.

All required support files. Support files for an Internet application may include HTML files, Active Server Pages (.asp) files, graphics files in a variety of formats, or other files your application must access to run.

Any secondary .cab files for your application. In addition to project files, applications often reference several run-time components, such as the Visual Basic run-time DLL, individual ActiveX controls, and data access objects. If these components are available online in prepackaged .cab files, you can reference those .cab files in your primary .cab, rather than shipping the files yourself.

Secondary .cab files provide an efficient way to ensure that the user has the most current version of components. If a newer version of a component in a secondary .cab file becomes available on the external Web site, users who download your application will receive the updated version automatically.

Note If you cannot or do not want your application setup to require a connection to the Internet, you may place the secondary .cab files on a server within your intranet. An intranet server often provides for faster downloading and allows users to download from a secure network.

How Internet Component Download Works

After you package your Internet application or component for download, you deploy it to a specific location on a Web server, from which users can access it. Usually, your package is referenced as part of an existing Web page — that is, your control or other component is hosted by a Web page.

When a user accesses the Web page that hosts your package, the system downloads your package to the user's computer. The package is verified for safety, unpacked, registered, installed, and then activated. All of this occurs in the background and is controlled by the browser.

The Package and Deployment Wizard plays two parts in the process described above:

It packages your component and its associated files into a compressed (.cab) file that the browser uses to download your component. The Package and Deployment Wizard determines which files your project needs to run, gathers those files, compresses them into a .cab file, and generates the HTML that points to your component.

It deploys your packaged files to the Web server location of your choice. For more information on deploying your Internet component download package, see "Application Deployment with the Wizard" later in this chapter.

Safety Issues

When you prepare Internet applications and components for download, you must package them into a file that can be delivered to the user through a browser. In addition, you must perform a few precautionary steps to ensure users that your application will not harm their computers. These steps can include:

Digitally signing your components so that users can verify the contents of the component and identify you as the software's source.

Setting safety levels to vouch that your components will not damage users' computers or corrupt their data.

Arranging for licensing of any components that require it. When you add an ActiveX control to a Web page, you are distributing it to any users who download the control from the page. Unless you license the control, there is little to prevent an end user from taking your control and using it in their own applications. The license acts as a kind of copyright for your control, preventing unauthorized use.

Safety settings can be made within the Package and Deployment Wizard. When you work with an Internet package, a screen in the wizard asks you to verify safety settings. This screen appears lists only the objects in your project that do not implement a safety interface called IObjectSafety.

Note Signing and licensing must be done outside of the packaging process. You should arrange licensing for any components before you package the component. Digital signing can be done after you package the application — the Package and Deployment Wizard reserves space within the .cab file for information about the digital signature.

For More Information See "Steps to Prepare your Component for Download" in the Building Internet Applications book of the Component Tools Guide for detailed explanations of component safety, licensing, and signing. See "Setting Safety Levels for ActiveX Components" in "Downloading ActiveX Components" in Building Internet Applications in the Component Tools Guide for more information on the IObjectSafety interface.

Dependency Files

2008-06-26T09:38:00.000-07:00

Dependency Files

A dependency (.dep) file contains information about the run-time requirements of an application or component — for example, which files are needed, how they are to be registered, and where on the user's machine they should be installed. You can create .dep files for standard projects in all versions of Visual Basic. If you have the Professional or Enterprise edition of Visual Basic, you can create .dep files for ActiveX controls, ActiveX documents, and other ActiveX components.

The Package and Deployment Wizard uses .dep files when it packages your applications. It scans all available dependency information for the application to build a comprehensive list of information about the run-time files the application needs, then builds installation information from that list. For a standard package, the information from the .dep files is written to a Setup.lst file that is stored outside the packaged .cab file. For an Internet package, the .dep file information is written to an .inf file that is stored within the packaged .cab file.

When you package a component, you have the option of creating a .dep file to accompany it when it is deployed. You would do this if you have created a component you want to distribute with dependency information. It is recommended that you package and deploy your component before you package and deploy your dependency file, so that the packaging portion of the wizard knows the source location of the component that the dependency file references.

Types of Dependency Files

In Visual Basic, dependency information is stored in files generated by the Package and Deployment Wizard or created manually by you. There are two types of files that can contain dependency information:

Component .dep files — a .dep file lists files needed by a particular control or component. The Package and Deployment Wizard uses this file when it creates the setup program. In addition, the wizard can create this type of .dep file for you.

The VB6dep.ini file — a list of dependency files for the entire Visual Basic development environment.

When you run the Package and Deployment Wizard, it looks for dependency information in .dep files and in vb6dep.ini. If dependency information cannot be found for a component in either location, the wizard notifies you of the missing dependency information. You can ignore this omission or correct the problem by creating the appropriate dependency files.

Note If you ignore the omission, your program may not function properly after installation. If, however, you are certain that a dependent file will already be loaded on the user's machine, you may ignore the warning and proceed.

Component Dependency Files

A .dep file lists all the files required by a particular component. When you purchase or use a component from a vendor, you receive a .dep file from them. For example, all of the ActiveX controls shipped with Visual Basic have a companion .dep file. These .dep files list all of the dependent files used by the control, plus version and registry information.

You should generate a .dep file for any component that you create in Visual Basic if that component may be used in another project. The information from the .dep file for each component in a project is combined to form the project's dependency information. If you do not create a .dep file for your component, the dependency information for any projects in which it is used may be incorrect.

The VB6dep.ini File

The VB6dep.ini file provides the Package and Deployment Wizard with an all-purpose list of dependencies and references used by Visual Basic. This list is created when you install Visual Basic and resides in the \Wizards\PDWizard subdirectory of the main Visual Basic directory.

Missing Dependency Information

The Package and Deployment Wizard will inform you if dependency information is missing for a component in your project. There are three ways you can add the necessary dependency information:

Edit the vb6dep.ini file to manually add an entry for a particular component.

Create a .dep file for the component with the Package and Deployment Wizard.

Contact the component's vendor and request a .dep file.

Files You Need to Distribute

2008-06-26T09:35:00.001-07:00

Files You Need to Distribute

The first step in creating a custom setup program is to determine which files to distribute. All Visual Basic applications need a minimum set of files, referred to as bootstrap files, that are needed before your application can be installed. In addition, all Visual Basic applications require application-specific files, such as an executable file (.exe), data files, ActiveX controls, or .dll files.

There are three main categories of files needed to run and distribute your application:

Run-time files

Setup files

Application-specific files

Run-Time Files

Run-time files are files your application must have in order to work correctly after installation. These files are needed by all Visual Basic applications. The following are the run-time files for Visual Basic projects:

Msvbvm60.dll

Stdole2.tlb

Oleaut32.dll

Olepro32.dll

Comcat.dll

Asyncfilt.dll

Ctl3d32.dll

While these files are needed by all Visual Basic applications, they may not be necessary for every type of installation package. For example, when creating an Internet package, the Package and Deployment Wizard assumes that any computer capable of performing an Internet download already has all of these files except for Msvbvm60.dll. Therefore this is the only run-time file that the wizard includes in an Internet package.

Note Run-time files can be further classified by their installation location. See "Where to Install Files on the User's Machine" for more information.

Setup Files for Standard Packages

Setup files are all of the files required to set up your standard application on the user's machine. These include the setup executables (setup.exe and setup1.exe), the setup file list (Setup.lst), and the uninstall program (st6unst.exe).

Visual Basic applications that are designed to be distributed on disk, on CD, or from a network location use the same setup files, regardless of whether you use the Package and Deployment Wizard or the Setup Toolkit to create your setup programs. These files are listed below.

Your Ad Here

File name	Description
setup.exe	Program that the user runs to pre-install the files that are needed for your application to be installed on the user's machine. For example, the setup.exe file installs the setup1.exe file, the Visual Basic run-time DLL, and other files without which the rest of the setup process cannot run.
setup1.exe	The setup program for your Visual Basic application. This executable file is generated by the Setup Toolkit and included in the package by the Package and Deployment Wizard. You can rename this file as long as the new name is reflected in the Setup.lst file.
Setup.lst	Text file that contains installation instructions and lists all the files to be installed on the user's machine.
Vb6stkit.dll	Library containing various functions used in Setup1.exe.
St6unst.exe	Application removal utility.

Note Applications designed to be delivered over the Internet generally do not use any of these files. See "Internet Packages" earlier in this chapter for more information on the files involved in Internet delivery.

Application Dependencies

In order to run your application, end users will need certain files in addition to the common run-time files and special setup files. Many of these files will be obvious to you: the executable file, any data files, and any ActiveX controls that you used. The less obvious files are your project's other dependent files. For example, some of the ActiveX controls used by your project may in turn require other files. One of the tasks of the Package and Deployment Wizard is to determine the complete list of such required files.

Your Ad Here

Application Packaging with the Wizard

2008-06-26T09:35:00.000-07:00

Application Packaging with the Wizard

Application packaging is the act of creating a package that can install your application onto the user's computer. A package consists of the .cab file or files that contain your compressed project files and any other necessary files the user needs to install and run your application. These files may include setup programs, secondary .cab files, or other needed files. The additional files vary based on the type of package you create.

You can create two kinds of packages — standard packages or Internet packages. If you plan to distribute on disk, floppy, or via a network share, you should create a standard package for your application. If you plan to distribute via an intranet or Internet site, you should create an Internet package.

In most cases, you will package your applications using the Package and Deployment Wizard, which is provided with Visual Basic. You can package applications manually, but the wizard provides valuable shortcuts and automates some of the tasks you would have to perform yourself in a manual packaging session.

Note In addition, you can use the Setup Toolkit and the Package and Deployment Wizard together. You can modify the Setup Toolkit project to customize your setup programs and add features that that Package and Deployment Wizard does not provide, then use the wizard to package and deploy the application.

In addition to creating standard and Internet packages, you can also use the packaging portion of the Package and Deployment Wizard to create dependency files. Dependency files list the run-time components that must be distributed with your application's project files.

Important Any time you create a package, you should be sure that the version number for your project has been set on the Make tab of the Project Properties dialog box. This is especially important if you are distributing a new version of an existing application: Without the appropriate change in version numbers, the end user's computer may determine that critical files do not need to be updated.

For More Information For a more detailed explanation of standard packages and their contents, see "Standard Packages" later in this chapter. See "Internet Packages" for more information about Internet packages and their contents. See "Using the Setup Toolkit Project with the Package and Deployment Wizard" later in this chapter for more information on using the two tools together to create customized setup programs. See "Dependency Files" for an explanation of the contents of a dependency file.

Files You Are Allowed to Distribute

You can freely distribute any application or component that you create with Visual Basic. In addition to an executable (.exe) file, your application might require other files, such as DLLs, ActiveX controls (.ocx files), or bitmaps (.bmp files).

You can legally distribute sample application files and any files that were originally copied to the \Icons subdirectory of the \Visual Studio\Common\Graphics directory when you first installed Visual Basic on your system. Microsoft makes no warranty, express or implied, regarding the merchantability or fitness of these applications, nor does Microsoft assume any obligation or liability for their use.

If you have purchased the Professional or Enterprise Edition of Visual Basic, you can also distribute any files originally copied to the \Visual Studio\Common\Graphics and \Program Files\Common Files\ODBC subdirectories .

Note You may also be able to distribute other ActiveX controls, .exe files, and DLLs that you have purchased. Consult the manufacturer's license agreement for each of the files you plan to distribute to determine whether you have the right to distribute the file with your application.

Overall Steps in the Packaging Process

Regardless of the type of package you create or the tool you use to create it, there are certain steps that must be taken.

Note The Package and Deployment Wizard performs many of these steps for you automatically.

Determine the type of package you want to create. You can create a standard package for Windows-based programs that will be distributed on disk, on CD, or over a network; or you can create an Internet package for programs that will be distributed on the Web. You can also choose to create only a dependency file.
Determine the files you need to distribute. The wizard must determine the project files and dependent files for your application before it can create the package. Project files are the files included in the project itself — for example, the .vbp file and its contents. Dependent files are run-time files or components your application requires to run. Dependency information is stored in the vb6dep.ini file, or in various .dep files corresponding to the components in your project.
Determine where to install files on the user's machine. Program and setup files are usually installed into a subdirectory of the Program Files directory, while system and dependent files are usually installed into the \Windows\System or \Winnt\System32 directory. Your setup program must take this into account and determine where to install each file.
Create your package. The wizard creates the package and the setup program (setup1.exe) for it, referencing all necessary files. The end result of this step is one or more .cab files and any necessary setup files.
Deploy your package. The deployment process involves creating your distribution media and copying all necessary files to the location from which users can access it.

Differences Between Visual Studio Enterprise and Professional Edition

2008-06-26T09:34:00.000-07:00

Differences Between Visual Studio Enterprise and Professional Edition

The Microsoft^® Visual Database Tools are available as a component in many of the Microsoft Visual Studio™ applications, including Microsoft^® Visual InterDev™, Visual Basic^®, and Visual C++^®. The Visual Studio suite is available in two editions: Professional and Enterprise.

The Professional version of Visual Studio 6.0 offers developers a great solution for accessing data. The Enterprise version builds on the Professional box by offering the ability to manipulate the structure of the database using the full features of the Visual Database Tools.

What's available in each Visual Studio product edition:

Capability	Professional Edition	Enterprise Edition
Create Queries	X	X
Edit Queries	X	X
Execute Stored Procedures	X	X
Create New Views		X
Create New Tables		X
Edit Table Structures		X
Create New Stored Procedures		X
Edit Stored Procedures		X
Debug Stored Procedures		X
Source Control for Stored Procedures and Triggers		X
Create New Triggers		X
Create New Database Diagrams		X
Edit Database Diagrams		X

Visual Studio 97

2008-06-26T09:33:00.000-07:00

Visual Studio 97

Introduction

Microsoft created Visual Studio™ 97 in response to customer demand. Faced with increasing diversity and complexity in their software development efforts, developers asked for a single development suite of tools so they can:

Use Internet technologies for both public Web sites and private intranets.

Access new enterprise services such as distributed components and transaction services.

Benefit from the industry’s standardization around components based on the Component Object Model (COM).

Integrate Internet technologies with client/server solutions.

Microsoft® Visual Studio 97, Professional Edition, contains five core development tools and a comprehensive information CD:

Microsoft® Visual Basic® 5.0, Professional Edition.

Microsoft Visual C++® 5.0, Professional Edition.

Microsoft Visual J++ ™1.1, Professional Edition.

Microsoft Visual InterDev™.

Microsoft Visual FoxPro™ 5.0, Professional Edition.

Microsoft Developer Network (MSDN) Library Reference CD-ROM.

Microsoft Visual Studio 97, Enterprise Edition, adds additional tools and technologies for creating scalable solutions and support for team development:

Microsoft Visual Basic 5.0, Enterprise Edition.

Microsoft Visual C++ 5.0, Enterprise Edition.

Microsoft Visual J++ 1.1, Professional Edition.

Microsoft Visual InterDev.

Microsoft Visual FoxPro 5.0, Professional Edition.

Microsoft® Visual SourceSafe™ 5.0.

Microsoft® SQL Server™ 6.5, Developer Edition.

Microsoft Transaction Server, Developer Edition.

The three key design goals for Microsoft Visual Studio 97 are:

Provide best-of-breed Microsoft® Visual Tool Suite to support any development scenario.

Support open standards with easy-to-use features.

Provide tools that can take on the biggest development challenges.

Visual Studio 97 is the first version of a suite of tools from Microsoft. It contains three widely used development tools: Visual Basic, Visual C++, and Visual FoxPro. Visual Studio also contains two new products, Visual InterDev and Visual J++, that add important functionality to the suite to address Internet development issues.

While Visual Studio 97 is only a first step toward a fully integrated tool suite, it does provide a comprehensive set of best-of-breed development tools that support open standards and scalable solution development. Taken together, these tools can be used to tackle the widest range of development challenges.

Provide Best-of-Breed Visual Tools to Support Any Development Scenario

The Internet has multiplied the number of architectures and scenarios that developers must handle beyond the already large number associated with Microsoft® Windows®-based, component, client/server, and multi-tier development. Therefore, there are four levels on which Visual Studio 97 must succeed to provide developers with the comprehensive tool set they need:

Provide best-of-breed Visual Tools.

Provide enterprise features for distributed solutions.

Support important development scenarios.

Provide comprehensive development support.

Provide Best-of-Breed Visual Tools

Industry leading development tools

Visual Studio 97 includes the Microsoft award-winning Visual Basic, Visual C++, and Visual J++ language tools, Visual FoxPro, and the new Visual InterDev.

Currently 1.9 million developers-more than 25 percent of all developers worldwide-use the Microsoft Visual Basic programming system. Furthermore, that number does not include the 1.1 million developers using the Visual Basic for Applications language available in Microsoft® Office, Microsoft® Project, and soon, in many third-party applications.

Microsoft Visual C++ also leads its class. Sixty-five percent of all developers writing applications based on Windows with a C/C++ tool use Microsoft Visual C++.

With more than half a million developers building solutions with Visual FoxPro worldwide, Microsoft Visual FoxPro is also a worldwide leader among tools used by developers.

Finally, Microsoft Visual J++ is being used by 25 percent of programmers using Java after being available for only a short time. Using Visual Studio 97, a developer can access development tools that are being used by millions of developers around the world (all numbers, except Visual FoxPro numbers, based on IDC estimates, December 1996; Visual FoxPro numbers based on Microsoft Corporation research).

Visual Basic 5.0

The first tool to make Windows-based programming easy, the Microsoft Visual Basic version 5.0 programming system is now the leading tool for helping developers create and use ActiveX Components, build Active Documents for intranet browsers, build client/server or multi-tier solutions with high-speed data access, and build fast applications based on Windows. Version 5.0 adds a native-code compiler, implicit multi-threading, and integration with Microsoft Transaction Server to bring a new level of scalability to server-based components built with Visual Basic.

Visual Basic 5.0 also provides developers with a new interface for faster programming. The IDE now features multiple document interface (MDI) with docking and linking windows to eliminate unnecessary mouse and keyboard actions, and the code editor offers IntelliSense technology such as QuickTips, DataTips, List Members, and List Constants which eliminate the need to memorize syntax and learn object models. Finally, a complete object model to the Visual Basic IDE can be used by third-party vendors to create sophisticated add-ins to extend Visual Basic with modeling and CASE functionality.

Visual C++ 5.0

The Microsoft Visual C++ version 5.0 development system is the development tool used to build many of the most well known desktop software applications in the world, including Microsoft® Word and Microsoft® Excel. Many applications continue to require the language flexibility of C++ and the performance tuning options of a sophisticated C/C++ language compiler, which makes Visual C++ the ideal tool for the most demanding performance requirements. New features in Visual C++ 5.0 include important compiler updates that reduce the size of an application by as much as 10 percent. Using new language syntax extensions, developers who use Visual C++ can use Active Scripting syntax together with C++ language syntax so that they can reuse pre-built components as easily as do Visual Basic and Visual InterDev developers.

Visual J++ 1.1

The Microsoft Visual J++ development system is the tool for professional developers building applets and applications with Java-it has the fastest compilation of any tool available and the only bytecode debugger. Developers using Visual J++ can pursue two options: they can build pure Java applications and applets that run on any platform with a Java virtual machine (Java VM), or they can use Visual J++ to build components with Java and expose component functionality through standard ActiveX interfaces. Integration using ActiveX technologies with Visual J++ works both ways so developers can use Java as the glue for components written in other languages, or they can expose the functionality of Java applications using the same ActiveX Component interfaces. This can be especially useful for building server-side Java components, and integrating these server-side components with other application elements exposed as ActiveX Server Components.

Visual InterDev

The Microsoft Visual InterDev integrated Web application development system meets the needs of developers who want to build dynamic, database-driven Web applications for corporate intranets and the Internet. The Visual InterDev development environment integrates all the tools developers need to create, publish, and manage Web applications that can be accessed by any Web browser running on any platform. Visual InterDev offers an easy-to-use, rapid development environment for building Active Server Pages, formerly code-named “Denali,” a feature of Microsoft Internet Information Server (IIS) version 3.0.

Additionally, Visual InterDev includes extensive database tools for connecting a Web site to any database using Open Database Connectivity (ODBC). With visual database tools such as an integrated Data View, Query Designer, Database Designer, and a multitude of database wizards and programmable data access components, Visual InterDev makes it easy to create sophisticated database-driven Web applications. Finally, Visual InterDev also offers advanced publishing and site management features, as well as support for team-based projects through interoperability with the Microsoft Front Page® 97 Web authoring tool and integration with Visual SourceSafe 5.0.

Visual FoxPro 5.0

The Microsoft Visual FoxPro version 5.0 database management system continues the leadership tradition of version 3.0. It features powerful ActiveX extensibility with a new ability to create ActiveX Components using the FoxPro database language, better forms loading and query performance, improved connectivity features, and an enhanced development environment. The enhanced development environment shares the functionality of the powerful debugger found in Microsoft Visual C++. Improved support, including the ability to subclass, and the ability to reuse third party ActiveX Controls, extends the power of Visual FoxPro. Developers can build applications with greatly improved connectivity features such as offline views and multi-tier client/server functionality. And through its ability to create ActiveX Server Components, Visual FoxPro applications can now be easily integrated with Web applications.

Shared development environment

Three of the popular tools in Visual Studio 97-Visual J++, Visual C++, and Visual InterDev-share a common development environment. The shared IDE can host projects that contain any of these file formats and many others-including hypertext markup language (HTML), and graphics. The shared IDE offers features to make developers more productive, including:

Integrated debugging. Using the shared development environment, a developer can verify and debug the interfaces between ActiveX Server Components and the code that calls them. Furthermore, the new native code compile feature of Visual Basic 5.0 provides a set of symbols that are recognized by Visual C++. This means a developer can debug a Visual Basic-created control or application using Visual C++.

Macro scripting. The integrated development environment provides scripting of the development environment using the popular Visual Basic Scripting language (VBScript). Developers can now automate and speed development of common tasks.

Command bars and customizable toolbars. The integrated development environment sports the same command bar interface as Microsoft Office 97, with configurable, dockable menu bars, and intuitive icons in the menus that remind a developer of the function of a command and how to access it using a toolbar shortcut.

Integrated browser. Developers can browse Web pages directly inside the IDE, a convenient productivity feature that makes it unnecessary to open a separate Web browser window to view a site under construction. The integrated browser is based on the Microsoft Internet Explorer version 3.0 Web browser and supports all its features. The IDE also offers a Preview in Browser feature, so developers can use other browsers when viewing and testing a Web application.

Provide Best-of-Breed Enterprise Tools

Visual Studio 97, Enterprise Edition, adds products for team development and for building sophisticated multi-tier and transaction processing systems. In addition to the Enterprise versions of Visual Basic and Visual C++, Visual Studio 97 contains three important developer products:

Microsoft Visual SourceSafe 5.0

The Microsoft Visual SourceSafe version 5.0 version control system provides support for managing source code in development teams and for managing Web site content. Fully integrated with Visual Basic, Visual C++, Visual J++, Visual InterDev, and Visual FoxPro, Visual SourceSafe delivers easy-to-use, project-oriented version control.

Microsoft SQL Server 6.5, Developer Edition

Using a develop-and-test license, developers can build and test Microsoft SQL Server version 6.5 database systems using Visual Studio 97 tools. Microsoft SQL Server is a scalable, high-performance database management system designed specifically for distributed client/server computing. Its built-in data replication, powerful management tools, and open system architecture offer a superior platform for delivering cost-effective information-based solutions.

Microsoft Transaction Server, Developer Edition

Using a develop-and-test license, developers can create and test complete Microsoft Transaction Server-based solutions using Visual Studio 97 tools. Microsoft Transaction Server provides the application infrastructure-including transactions, cross-platform integration, and scalability-required to build reliable distributed business systems solutions easily. Using the Transaction Server, developers can focus on business solutions instead of on application infrastructure, thereby lowering the cost and complexity of building and supporting server applications.

Support Important Development Scenarios

The growth of the Internet and the introduction of new server-side and distributed computing technologies have greatly increased the demands on software development. Visual Studio 97 meets these new demands by addressing the full range of development scenarios:

Building multi-tiered solutions. Using Visual Studio 97, developers can make the transition from client/server to multi-tier development with Distributed COM (DCOM) and Microsoft Transaction Server.

Creating Web sites. Using Visual Studio 97, developers can publish Web content, manage data-intensive Web sites, and create dynamic applications for the Web.

Developing with components. Using Visual Studio 97, developers can build, use, and reuse ActiveX Components.

Integrating Internet technologies and client/server solutions. Using Visual Studio 97, developers can add Web interfaces to existing client/server solutions.

Building multi-tier solutions

Using tools such as Visual Basic, Visual FoxPro, Microsoft Access, and Visual C++, application developers have built departmental solutions. These solutions have been built on personal computers (PC) running Windows operating systems, inexpensive server computers, and database management systems (DBMS). As these client/server solutions have become widely used and have grown to represent line-of-business solutions, there is a growing need to scale them for wider use and easier maintenance.

Distributed, or multi-tier, computing in the form of separate user interface, data storage, and business rule components is now attainable for solutions employing inexpensive PC technology. Two essential elements for building multi-tiered solutions using PC technology are Microsoft Transaction Server for managing server transactions and DCOM for easily connecting client and server components. With the inclusion of the Microsoft Transaction Server, Developer Edition, and capability to create COM components using every tool in the Visual Studio 97 suite, Visual Studio 97 supports the core enabling technologies of multi-tier development. Using Visual Studio 97, developers can migrate existing client/server solutions to multi-tiered architectures.

Creating Web sites

The primary use of the World Wide Web has been to publish information and graphics to users. While this has been a very popular use of Web technologies, there is an opportunity to migrate these publishing sites to full applications where users have access to dynamically generated data and rich user interfaces. These applications are then useful as line-of-business Internet and intranet applications. The challenge for Microsoft is not merely to make this possible-it is already possible if developers use a variety of tools and custom scripts-but also to make it easy using the tools in Visual Studio 97.

With Visual Studio 97, developers can easily create dynamic Web applications. Visual Studio 97 developers can:

Manage their Web project using Visual InterDev and build HTML pages that can be viewed on any platform by any browser.

Add server components written in Visual C++, Visual Basic, or any language capable of creating ActiveX Components.

Add client components written with Visual J++ as a Java applet or as a reusable ActiveX Component written in Visual J++, Visual C++, or Visual Basic.

Use JScript or VBScript for client-side and server-side scripting.

Add connections to virtually any database using ODBC.

Using these capabilities, a development organization can create dynamic, data-centric Web applications that can be deployed on the World Wide Web or on a corporate network.

Developing with components

All of the tools in Visual Studio 97 are either creators or consumers of reusable COM-based components, known as ActiveX Components, which can run on client PCs, in Internet browsers, or on PC servers with Microsoft IIS or Microsoft Transaction Server. If run on the server, these components are referred to as ActiveX Server Components although there are no changes required to run ActiveX Components on a server. ActiveX Controls are a special kind of ActiveX Component that can respond to user events such as the click of a button.

ActiveX Components all share the characteristic of being easy to assemble using Visual Studio 97 tools. Also, a large number of components can be purchased from third-party vendors. As a result, developers can easily build or purchase, assemble, and deploy ActiveX Components.

Using Visual Basic, Visual C++, Visual J++, and Visual FoxPro, a developer can build ActiveX Components. Using Visual Basic and Visual C++, a developer can build ActiveX Controls. All Visual Studio 97 tools are consumers of ActiveX Components. In particular Visual InterDev can not only use them with Internet clients and servers, but it can also use a specialized kind of ActiveX Control named Design-time ActiveX Control.

Integrating Internet technologies and client/server solutions

The final scenario is a combination of the previous three. As client/server systems migrate to multi-tier solutions, as Web publishing sites evolve into Web applications, and as ActiveX Components are created that can be used in both scenarios, all three elements often merge in the creation of a single solution. That solution could be a Web-based catalog or a line-of-business inventory management application running on a corporate intranet. Using Visual Studio 97 tools, developers can integrate Internet technologies and client/server solutions by using components to build the business logic that connects Web applications to network data, and using the tools to create rich interfaces for customers and business partners.

Provide Comprehensive Development Support

Visual Studio 97 puts all the right tools into the hands of developers, but their needs do not stop when they purchase the product. Microsoft provides ongoing developer support through paid telephone support, and an award-winning reference library. Microsoft also actively supports third-party channels for software support, training, and information.

MSDN Reference Library

The MSDN Library CD-ROM is included in the Visual Studio 97 box. The MSDN Library is the comprehensive source of technical information about Microsoft tools, platforms, and technologies. The Library CD-ROM contains a database of thousands of articles and code samples published by Microsoft Product Support Specialists to help developers address specific technical challenges. All the product documentation for the tools in Visual Studio 97 is indexed and cross-referenced on the CD-ROM.

MSDN Online

Augmenting the MSDN Library CD-ROM is a dynamic Web site especially for developers. Developers can find the latest news and information online so they can stay up-to-date on techniques for getting the most from their development work using Microsoft tools.

Microsoft product support services

Visual Studio 97, Enterprise Edition, includes four no-charge support calls, and Visual Studio 97, Professional Edition, includes two no-charge support calls. Microsoft Product Support Specialists can answer the broadest range of technical questions about Microsoft development technologies. Developers who need additional assistance can choose from a range of support offerings, from additional support calls to 24-by-7 support contracts.

Additional developer support

Developers who use Visual Studio 97 can access a worldwide network of product support and training resources. This network includes

Hundreds of third-party books on the development tools in Visual Studio 97.

The Microsoft Mastering Series, a set of interactive self-paced tutorials on the development tools in Visual Studio 97.

Microsoft Authorized Technical Education Centers (ATEC) that offer hands-on training around the world.

Microsoft-sponsored and third party-sponsored development conferences.

A worldwide network of development tool user groups.

Visual Studio 97 is backed by one of the largest communities of developer resources.

Support Open Standards with Easy-to-Use Features

Visual Studio 97 is designed to give developers choice and flexibility in their application development by supporting standards that are broadly adopted by customers, whether those standards are driven by organizations such as the World Wide Web Consortium (W3C) or the Open Group, or by vendors like Microsoft, Sun®, and Netscape®. Visual Studio 97 supports open standards in three ways:

ActiveX. Each tool uses the ActiveX Component standard.

Connectivity. Each tool supports access to the broadest range of corporate data.

Web. Visual Studio 97 delivers a complete set of tools for developing dynamic Web applications.

ActiveX Technologies

All of the Visual Studio 97 tools use the ActiveX Component standard, which is one of the most widely implemented and supported software component standards in the industry. In fact, ActiveX Components sustain an industry of several hundred firms that create thousands of controls for resale to developers.

ActiveX Components may be used either in-process or out-of-process and can be created in any language. A sophisticated subset of ActiveX Components, ActiveX Controls, can support events and are a popular building block for developers creating solutions with Visual Basic, Visual FoxPro, Microsoft Office, and other tools. ActiveX Automation is the term for code, or the act of executing code, that is written against the exposed interface, or object model of an ActiveX Component.

The key to understanding ActiveX Components is simple. They all work in the same way. However, attempts to clarify the naming strategy have frequently confused, rather than simplified, the situation. For example, ActiveX Components can be run on a client, an application server, a Web server, or Microsoft Transaction Server. They can be written in Visual J++, Visual FoxPro, Visual Basic, and Visual C++, and they can be automated (programmed against) by all of the Visual Studio 97 tools. Whether called ActiveX Server Components (running on the server) or Java applets with COM interfaces, or ActiveX Controls created in Visual Basic Control Creation Edition, they in fact all belong to the same class of software component.

ActiveX is built on top of the Component Object Model. Distributed COM for Microsoft® Windows®95 and Microsoft® Windows NT® enables software components to be programmed across a network. Software vendors such as SoftwareAG are porting DCOM to other platforms. In addition, DCOM is one of the ActiveX Core Technologies Microsoft has turned over to The Open Group for management as a public standard. The Open Group is chartered to license ActiveX technologies for porting to other platforms.

Creating ActiveX Components

Building ActiveX Components and ActiveX Controls has become important to developers. Visual Studio 97 offers a range of tools for building ActiveX Components.

Visual Basic. Visual Basic is designed to be one of the fastest ways to build ActiveX Controls. Wizards support the development and deployment of ActiveX Controls, including the ActiveX Control Interface Wizard, the Property Page Wizard, and the Setup Wizard. Controls created with Visual Basic can include Authenticode licensing and support for developer-only licensing.

Visual C++. Visual C++ includes COM support at the syntax level with new features that make it easier for C++ developers to work with COM objects, build COM objects, and reuse ActiveX Components. These new features are Class View, the COM Wizard, and the Import Statement.

Visual J++. Developers who use Visual J++ can use components to extend Java code for solutions based on Windows and can create reusable ActiveX Server Components. Visual J++ 1.1 includes a new wizard that eases the creation of ActiveX Server Components.

Visual FoxPro. Using Visual FoxPro, developers can create ActiveX Server Components that display reusable forms, implement business rules, or package a complex routine into a simple component that other programmers can use on the client or the server.

Using ActiveX Components

All of the tools in Visual Studio 97 support ActiveX Automation and can access functionality stored in ActiveX Components built to run on either the client or the server. All Visual Studio 97 tools except Visual J++ can host ActiveX Controls. Visual InterDev supports the hosting of ActiveX Controls in its WYSIWYG HTML editor, so that Internet browsers with support for ActiveX Controls, including Microsoft Internet Explorer and Netscape Navigator with NCompass, can view them.

Using Design-time ActiveX Controls

Visual InterDev introduces a special kind of ActiveX Control, the Design-time ActiveX Control. Developers building Web applications use these controls as helper tools in creating HTML and VBScript or JScript code to run on the Web client or server. Because the interfaces for creating them are public, what they can accomplish is basically unlimited. Examples of Design-time ActiveX Controls that ship with Visual InterDev are controls that create data access logic, handle data retrieval, and format HTML pages.

Creating Active Documents

Unlike an ActiveX Control that is displayed within the page of the document or form that hosts it, an Active Document is a full-scale, conventional document hosted in an Internet browser. Active Documents control part of the user interface, merging application menus with the container menus. Active Documents have two important benefits. First, they lower software ownership costs by eliminating the need for client deployment. Second, with them, a user can maintain a single desktop interface, which, in turn can lead to lowering user training costs and raising user productivity.

Visual Basic. Visual Basic includes an Active Document Migration Wizard that converts existing applications written in Visual Basic into Active Documents that can be viewed using Microsoft Internet Explorer and can be automatically downloaded and updated.

Visual C++. Visual C++ includes an AppWizard that makes it easier for developers to add Active Document support to C++ applications.

Connectivity: Support for Data Access Standards

Powerful database connectivity options and easy-to-use database tools are an integral component of any developer’s attempt to integrate Internet technology with client/server solutions. All database connectivity features in Visual Studio 97 are based on the industry-standard ODBC, and the tools in Visual Studio 97 work with a broad range of databases, including ORACLE®, Microsoft SQL Server, Microsoft® Access, Microsoft Visual FoxPro, Informix®, Sybase®, IBM DB2®, and others.

High-level data access interfaces

Visual Studio includes three data access interfaces developers can use in accessing data. These include:

Data Access Objects 3.5 (DAO) is a COM-based interface to the Microsoft Jet database engine. DAO enables access to other ODBC data sources, and in the current version, it includes a feature named ODBCDirect, which offers access to RDO for direct and very fast access to ODBC data sources.

Remote Data Object 2.0 (RDO) is a COM-based interface to ODBC available with the Professional and Enterprise Editions of Visual Studio 97. RDO 2.0 offers high speed data access to ODBC data sources and is approximately 20 percent faster than RDO 1.0. RDO 2.0 includes new client batch cursors, enhanced asynchronous processing, and features for writing data access applications that are completely event driven. By using these new features in RDO 2.0 to access data, developers can create database code that is up to 2.2 times faster than RDO 1.0.

Active Data Objects (ADO) is a COM-based interface to ODBC and to OLE DB data sources. ADO enables server-based access to relational and non-relational data sources. When using Visual InterDev, ADO is the interface that is scripted in either VBScript or JScript. ADO supports a rich set of properties for setting locking levels, cursor options, query and login time-outs, transaction support, result set scrolling, error handling, and more.

Integrated SQL debugging

Developers using Visual Studio 97, Enterprise Edition, can interactively debug and view Structured Query Language (SQL) stored procedures from within Visual Basic or Visual C++. Using integrated SQL debugging, a developer can implement stored procedures in a SQL database and verify or debug those stored procedures in the context of the application that is calling them. Using the power of distributed computing technology, a developer can step from Visual C++ or Visual Basic source code executing on a client computer to Microsoft SQL Server 6.5 source code executing on a remote server computer.

Microsoft Visual Database Tools

Visual Studio includes new tools for data definition. These tools can be used from within Visual InterDev, Visual Basic, Enterprise Edition, or Visual C++, Enterprise Edition.

The Query Designer. The Query Designer is a sophisticated SQL Query Designer that works with any ODBC data source.

The Database Designer. Using the Database Designer, a developer can create database schemas for databases built using Microsoft SQL Server, version 6.5.

Web Standards Support

Visual Studio 97 supports HTML standards endorsed by the World Wide Web Consortium (W3C), and offers features in all of the tools that make it easy to support Internet protocols. Developers can use Visual J++ and Visual InterDev to create Web applications that run using any browser on any platform.

Run Visual J++ applets anywhere

Developers who use Visual J++ have full access to the entire Java class library. Developers can create a Java applet or application and run it on all platforms and browsers. Visual J++ applets can run on any Java VM, including the Apple® Macintosh® Java VM, the Windows Java VM, and on any operating system that supports a Java virtual machine.

Build Web sites

The Visual InterDev development environment integrates all the tools a developer needs to create, publish, and manage Web applications designed to be accessed by any Web browser running on any platform. A Visual InterDev project consists of a live Web site. When developers open a project, they can work with a live view of a site as it exists on a Web server. The server can be a personal development server running on a developer’s workstation, but more typically, it will be a staging or production Web server running on a network. Visual InterDev is thus a complete Web site management tool that developers can use to easily modify the structure of a Web site and to edit, add, move, rename, and delete files and folders for the site.

Integrate applications with the Internet

Visual Basic has added several controls that make it easier to integrate applications with the Internet.

Using the Internet Transfer Control, developers can build applications that transfer files to and from Internet sites.

Using the WinSock Control developers can create real-time client/server applications over the Internet or any TCP/IP or UDP network.

Using the WebBrowser Control, developers can integrate Web browsing into a Visual Basic application seamlessly.

Using the classes and wizards in Visual C++, developers can build Internet server application programming interface (ISAPI) extensions and filters. Developers can customize their Internet and intranet servers with ISAPI extensions and filters that take specific actions when designated events occur. For example, an ISAPI filter could be used to track logins to a Web site, or an ISAPI extension could be used to add credit card validation to a Web site.

Provide Visual Tools for the Largest Development Challenges

PC-based solutions are achieving performance loads once reserved for mainframe computers. The result is more large scale and mission-critical applications being based on PCs. The tools in Visual Studio 97 meet these new application requirements with support for large-scale development projects in three areas:

Performance.

Team Development.

Building and testing large systems.

Performance

All Visual Studio 97 tools have been optimized for speed and performance so they support development of the largest applications.

Visual Basic 5.0 native code compilation

Using Visual Basic version 5.0, developers can build high-performance applications and components with a new native code compiler-the same compiler used by the Visual C++ version 5.0 product. Resulting language and CPU-intensive benchmarks run up to 20 times faster than applications built with earlier versions of Visual Basic.

Visual Basic 5.0 forms performance

In addition to a native code compiler, Visual Basic 5.0 provides faster application load, form load, and form show capabilities.

Visual C++ 5.0 compiler enhancements

The new optimized compiler in Visual C++ version 5.0 decreases the size of executables by up to 10 percent-a significant improvement over recent gains of three to four percent per release-and adds Intel® MMX and Pentium® Pro support. Because it is smaller, the code executes more quickly on virtual memory operating systems such as the Windows 95 and Windows NT Workstation operating systems.

Visual J++ 1.1 compiler and virtual machine for Windows

The Visual J++ compiler, based on the Microsoft Visual C++ compiler technology, compiles at 10,000 lines/second, many times faster than the compiler included with the Java Development Kit. In addition, the Java virtual machine for Windows is by far the fastest on the market.

Visual FoxPro 5.0 speed enhancements

Visual FoxPro 5.0 is a major release in terms of speed enhancements. Specific areas of enhancement include the speed with which objects are rendered on the screen, control data binding, and the memory footprint for several frequently used controls. The result is from 40 percent to 200 percent faster performance for forms, depending on computer configuration. Data retrieval using the common Where clause is also significantly faster.

Team Development

All products in Visual Studio 97 support the latest edition of the award-winning Microsoft Visual SourceSafe, which manages source code in development teams and Web site content. Once installed, Visual SourceSafe is fully integrated with Visual Basic, Visual C++, Visual J++, Visual InterDev, and Visual FoxPro menus and delivers easy-to-use, project-oriented version control.

Visual InterDev takes this support for team development to a new level with advanced site management and publishing features so a developer can manage the various inputs to a Web project.

Microsoft Visual Basic 5.0 also offers Microsoft Repository, the first version of a new object storage system. In this release of Visual Studio, the repository works only with Visual Basic 5.0.

Building and Testing Large Systems

All of the products in Visual Studio 97 support ActiveX Automation which, when coupled with Distributed COM, enables them to integrate software components located elsewhere on the network or to connect to server processes hosted by Microsoft Transaction Server.

DCOM support in Visual Studio 97

Any out-of-process ActiveX Server Component can be seamlessly distributed over a server network using DCOM. This means that software components requiring computational-intensive processing can be distributed to application servers, including servers running Microsoft IIS or Microsoft Transaction Server to efficiently process requests, resulting in more effective load balancing, higher performing applications, and greater fault tolerance. In addition, because these ActiveX Server Components are the same as ActiveX Components running on a client, they can be easily scripted using any language.

Microsoft SQL Server and integrated SQL debugging

Visual Studio 97, Enterprise Edition, includes a developer edition of Microsoft SQL Server 6.5. Using the developer edition, a developer can immediately begin building databases to test and evaluate production systems. Perhaps most important, developers can interactively debug and view SQL stored procedures from within Visual Basic or Visual C++.

Microsoft Transaction Server

Visual Studio 97, Enterprise Edition, includes a developer edition of Microsoft Transaction Server. Transaction Server combines the flexibility and low-cost of desktop application development with the mission-critical transaction processing features normally found in high-end mainframe systems. It is a component-based transaction processing system for developing, deploying, and managing high performing enterprise, Internet, and intranet server applications.

Microsoft Transaction Server provides the easiest way to run server applications on servers running Windows NT Server because applications are built using ActiveX Components and transactions are automatically built into applications. Developers can use Visual Basic 5.0, Visual C++ 5.0, or Visual J++ 1.1 to create ActiveX Components that are compatible with Microsoft Transaction Server.

Visual InterDev connection pooling

Visual InterDev establishes global database connections for a site that Microsoft IIS automatically pools across users. Pooling, connection caching, and time-out values are all established automatically based on default properties, but they can easily be customized by a developer. Consequently, users of the solution rarely wait for a database connection on the server.

The Application Performance Explorer

Visual Studio 97, Enterprise Edition, includes the Application Performance Explorer (APE). APE is a utility that aids in the design, deployment planning, and performance tuning of distributed client/server applications. Using APE, developers can test-drive different multi-tier scenarios before committing to one. Once an architecture has been chosen, APE gives developers access to reusable Visual Basic source code for their application.

Conclusion

Visual Studio 97 is the first comprehensive suite of tools to address the complete range of development challenges. With Visual Studio 97, developers can:

Use Internet technologies for both public Web sites and private intranets.

Access new enterprise services such as distributed components and transaction services.

Benefit from the industry’s standardization around components based on the Component Object Model.

Integrate Internet technologies with client/server solutions.

Visual Studio 97 provides best-of-breed tools that support open standards and can take on the biggest development challenges.

Each of the best-selling tools in Visual Studio 97 gives developers choice and flexibility in their application development by supporting open standards that are broadly supported. The tools in Visual Studio 97 do this by providing support for component standards through ActiveX, providing world-class data connectivity, and enabling pure Web development. Able to take on the biggest development challenges, Visual Studio 97 offers developers optimized compiler technology that brings excellent performance to the largest applications, supports developers working in teams, and delivers support for building and testing scalable enterprise solutions.

While Visual Studio 97 is only the first step toward a fully integrated development tool suite, it already shows how an integrated tool suite can be greater than the sum of its parts.

The three core development languages in Visual Studio 97-Visual Basic, Visual C++ and Visual J++-all take advantage of one of the best native code compilers available.

Every tool is a consumer and/or producer of ActiveX Controls and ActiveX Server Components. Consequently, developers can integrate multiple components into a single application and choose the best tool to build each component.

Each of the tools supports access to the broadest range of data through common ODBC standards.

With shared technologies like the Visual Database Tools and SQL debugging, and the integrated development environment for Visual C++, Visual InterDev, and Visual J++, developers can master a technology once and use it with all the tools.

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

Microsoft, Visual Basic, Visual C++, Windows, and Windows NT are registered trademarks and Visual FoxPro, Visual SourceSafe, SQL Server, and Front Page are trademarks of Microsoft Corporation.

IBM and DB2 are registered trademarks of International Business Machines Corporation. Sun is a registered trademark of Sun Microsystems, Inc. Intel and Pentium are registered trademarks of Intel Corporation. Netscape is a registered trademark of Netscape Communications Corporation. Sybase is a registered trademark of Sybase, Inc. Informix is a registered trademark of Informix Software, Inc. Apple and Macintosh are registered trademarks of Apple Computer, Inc. ORACLE is a registered trademark of Oracle Corporation.

Other product or company names mentioned herein may be the trademarks of their respective owners.

Introducing Visual Studio 97

2008-06-26T09:31:00.000-07:00

Your Ad Here

Introducing Visual Studio 97: A Well-stocked Toolbox for Building Distributed Apps

Visual Studio 97 to the Rescue

Microsoft® Visual Studio™ 97 goes a long way toward providing you with a well-stocked toolbox to help you complete your development projects. Visual Studio targets developers and teams that create dynamic Web-based applications or other distributed applications. Visual Studio takes all of Microsoft's development tools, adds a rich set of new tools for creating Web content, and ties it all together with comprehensive documentation. Even if you're not creating distributed applications but you use two or more Microsoft developer products, you'll probably find Visual Studio suits you. (If you use only one tool, don't stop reading—each of the tools in Visual Studio is also available separately. And you might find another tool that would make your life easier.)

In this article, I'll give you a quick overview of what Visual Studio is all about. It's a big product, so don't expect every detail of every tool to be covered here. I'm going to focus on the new tools released for the first time in Visual Studio and the new features of tools you've probably seen before. Watch Microsoft Systems Journal and Microsoft Interactive Developer (MIND) for more in-depth articles about individual tools.

Why Visual Studio?

Visual Studio specifically targets developers of distributed, client-server Web applications (see the sidebar, Building Distributed Applications with Components). It provides all the tools you need to create and maintain each tier of the multitier application architecture. Many of the improvements to existing Microsoft developer products are aimed directly at simplifying the creation or use of ActiveX components. A full complement of tools is provided to create HTML-based presentation layers in addition to the more traditional Windows®-based application programming tools. A comprehensive set of data management tools helps with the routine creation and maintenance of the underlying databases.

A second target of Visual Studio is the corporate client-server application. The same basic architecture applies to both types of applications. Corporate applications tend to focus a little more on the database side of things, though, and the Visual Studio Enterprise Edition contains even more tools for creating large-scale database and transaction-processing applications.

What's in the Box?

Visual Studio 97 comes in two editions, Professional Edition and Enterprise Edition. Figure 1 lists the contents of each edition. As you can see, the Enterprise Edition focuses more on database development than the Professional Edition. The first thing you'll notice is that Visual Studio is big, very big. The beta-2 Enterprise Edition I worked with came on five jam-packed CDs.

Figure 1 Visual Studio 97 Contents

Product	Hard Drive Space		Included in
	Min	Max	Professional Edition	Enterprise Edition
Visual Basic 5.0 Professional Edition	30MB	220MB	x
Visual Basic 5.0 Enterprise Edition	35MB	345MB		x
Visual C++ 5.0 Professional Edition	50MB*	274MB	x
Visual C++ 5.0 Enterprise Edition	50MB*	293MB		x
Visual J++ 1.1 Professional Edition	35MB	55MB	x	x
Visual InterDev 1.0	37MB	52MB	x	x
Visual FoxPro 5.0	15MB	190MB	x	x
MSDN Library	10MB	1GB	x	x
SQL Server 6.5 Developer Edition	80MB	95MB		x
Transaction Server 1.0 Developer Edition	11MB	23MB		x
Visual SourceSafe 5.0	8MB	16MB		x
* Typical install

The best decision anyone made for Visual Studio was to put all the documentation on a single CD. The Microsoft Developer Network (MSDN) Library CD provides one-stop shopping for technical information about the Visual Studio tools. In addition to the product documentation, the CD contains a snapshot of the Microsoft KnowledgeBase, a collection of thousands of articles created by Microsoft technical support specialists.

Augmenting the MSDN Library CD will be Visual Studio Online, a Web site devoted to the Visual Studio toolset. Product and documentation updates, new samples, and helpful technical articles will appear here first. Visual Studio tools even have Help menu items that take you directly to their respective home pages.

Installation

Be prepared to set aside a significant amount of time—and disk space—to install Visual Studio. Figure 1 shows you the minimum and maximum hard disk space requirements for each component of Visual Studio. You don't have to install all the components on the same drive, but most apps will need to install files into the Windows system directory. You can reduce the amount of disk space needed by accessing the documentation and sample code from the CD.

The beta-2 version I worked with took a long time to install because the main Visual Studio install program simply triggers each tool's individual install program. In a couple of cases, the installation program requires a reboot to finish installing some files, which means that after you reboot, you need to start up the Visual Studio install program again and work your way through to the screen that lists the individual components you can install (see Figure 2). However, each individual installation program did what it was supposed to.

Once everything is installed, you'll see that your Start menu has a lot of new items. Each individual application makes its own start menu entry, and some common tools appear on multiple menus. (Unfortunately, these tools are also installed in multiple places on your hard drive.) Some applications create their Start menu entries in the user-specific menu and others create their entries in the menu common to all users. I would like to see better coordination between the different application setup programs when creating Start menu entries and installing common tools. I expect this to be much improved in the retail release.

I must admit that after installing the Visual Studio beta 2, I was feeling a little negative toward the product. Installing it took too long and used too much hard drive space. But once I actually starting working with the tools, my whole attitude changed. Believe me, the tools are worth the wait.

Let's take a look at each of the tools that comes with Visual Studio. First, I'll look at the language tools. They primarily provide a development environment for a programming language—Visual Basic, Visual FoxPro™, Visual C++®, and Visual J++™. After I look at the languages, I'll go over the Web content authoring tools that make up Visual InterDev™. Finally, I'll take a brief look at the enterprise tools—Visual SourceSafe™, Microsoft SQL Server™, and Microsoft Transaction Server.

Visual Basic 5.0

Visual Basic is Microsoft's RAD tool for Windows programmers. Visual Basic uses a graphical, forms-based approach to application development. The typical way to write a program in Visual Basic is to create a form, drag and drop components onto the form, set properties for the form and its components, and add application-specific code to handle events. It sounds simple, but you can write some very powerful applications this way.

The great thing about Visual Basic is that it hides most of the gory details of Windows-based programming and lets you focus on your application-specific functionality. Pretty much every service you use in a Visual Basic program is provided by an ActiveX component. Once you've learned how to use one component in Visual Basic, using any other component is simply a matter of learning how its object model—its properties, methods, and events—works.

If you've used Visual Basic before, one of the first things you'll notice is that Visual Basic 5.0 has a new integrated development environment (IDE). Figure 3 shows the IDE just after a new control project has been created. Unfortunately, this IDE is not the same one that other tools in Visual Studio use. The IDEs are becoming more similar, but there are still differences in their capabilities that may catch you by surprise if you move back and forth between them.

The Visual Basic 5.0 IDE now has a traditional Windows MDI look. If you don't like this, you can switch back to SDI mode from the ToolsOptions command. Windows and toolbars can float or be docked to each other or to the edge of the screen. The IDE is very flexible so that you can organize things for maximum productivity. The IDE even lets you open multiple projects simultaneously—critical for debugging projects with user-created controls. If the features provided by the IDE aren't sufficient, you can create add-ins to extend it.

The IDE code editor has some new features that you'll soon wish were in every product you use, including List Properties/Methods, which presents a dropdown list of properties available for that control, and Auto Quick Info, which displays the syntax for statements and functions. Complete Word fills in the rest of the word you are typing once you have entered enough characters for Visual Basic to identify the word you want. Parameter Info (see Figure 4) shows a popup in the Code window that contains information about the parameters of the initial function or statement. Quick Info provides the syntax for a variable, function, statement, method, or procedure selected in the Code window.

In addition to the IDE changes, Visual Basic now provides a native code compiler. Earlier versions of Visual Basic compiled applications into p-code, which required a runtime interpreter that reduced application performance. The native code compiler lets you compile your apps down to Intel-native instructions. You can even optimize for specific processors, including the Pentium and Pentium Pro. Whether you compile your app to native code or p-code, you still need to ship the Visual Basic runtime files, but native code applications will run much faster. (Even though compiling to native code generates machine code, the machine code still needs to make some calls to helper routines that live within the Visual Basic runtime.)

Visual Basic 5.0 Enterprise Edition provides enhanced client/server database development features. Remote Data Objects (RDO) has been improved to include local cursor support, optimized batch updates, and direct access to ODBC data sources without going through the Jet engine. You can now create standalone connection and query objects. A Connection Designer is provided to help create these objects at design time and a Data Form Wizard automatically generates forms used to manage database information. Integrated T-SQL debugging lets you verify stored procedures executing on a Microsoft SQL Server database.

With version 5.0, Visual Basic also expands its capabilities to encompass ActiveX component creation. Visual Basic 4.0 was able to create Automation servers, which are a type of component, but did not support more powerful component features. Visual Basic 5.0 lets you create components that raise events, support data binding, support licensing, have property pages, and are Internet-aware. Visual Basic can create several types of components, including Automation components (that Visual Basic calls ActiveX Code components), ActiveX controls, and ActiveX Documents.

All ActiveX components in Visual Basic are defined by creating class modules. Creating an Automation component isn't much more complicated than defining your object's data and implementing a few procedures. Visual Basic takes care of all the goo to turn a class module into an Automation dual interface. Using the new Implements feature, classes can even support any Automation-compliant interface already defined in a type library. You define events in your class module using the Event keyword, and raise events using the RaiseEvent keyword. Clients use the new WithEvents keyword to indicate that they want to handle events from a particular object, then implement event handlers just as they would for any other event.

Using the Enterprise Edition, you can mark your components for unattended execution, which means they have no user interface. When you do this, the components can be used in multithreaded environments. In-process components (DLLs) marked for unattended execution support the COM apartment threading model. Out-of-process components (EXEs) marked for unattended execution will allocate object instances across multiple threads for better scalability as instances are created.

The Enterprise Edition also provides full support for deploying components remotely. Remote Automation (RA) was originally developed for Visual Basic 4.0 Enterprise Edition and extends OLE Automation so that it works across machine boundaries. It is compatible with and can be replaced by Distributed COM (DCOM). However, there are some situations when RA is more appropriate than DCOM. In particular, you need to use RA if you want to support 16-bit clients, since there is no DCOM support for 16-bit Windows. Fortunately, you don't need to write your applications any differently to use RA or DCOM. In fact, Microsoft supplies configuration utilities that you can use to switch between RA and DCOM: the Remote Automation Manager (AUTMGR32), and the Remote Automation Connection Manager (RACMGR32).

Visual Basic 5.0 makes ActiveX control creation incredibly easy. You can either combine existing controls into a new component or create a component from scratch. Either way, you use a special kind of object, called a UserControl, as the basis for your ActiveX control. Once you've added any constituent controls to the UserControl, you use the ActiveX Control Interface Wizard to specify which properties, methods, and events your composite control will expose to clients. You can create property pages for your control using the PropertyPage Wizard.

The major limitation to the Visual Basic 5.0 control creation features is that the controls you create are single-threaded. In addition, I didn't see any support for windowless controls. But if you can live with these restrictions, Visual Basic now provides a great way to create powerful, lightweight controls. If you'd like to know more, take a look at Guy and Henry Eddon's articles in the February and March 1997 issues of MSJ.

Using another special object called a UserDocument, you can create ActiveX Documents as easily as you design a form. When you create an ActiveX Document in Visual Basic, you add controls to a UserDocument instead of adding them to a Form. In fact, Visual Basic provides a wizard for converting ordinary apps into ActiveX Documents: the ActiveX Document Migration Wizard. This wizard converts the project type to ActiveX Document DLL or EXE and adds a UserDocument to the project. It then copies a form's properties, controls, and the code behind the controls to the UserDocument object, and migrates form event handlers to the UserDocument equivalents.

ActiveX Documents created with Visual Basic are a little different than other ActiveX Documents you may have encountered. Visual Basic ActiveX Documents are roughly equivalent to Visual Basic forms that can only be hosted in ActiveX Document containers—you can't run them as standalone applications. ActiveX Documents are typically activated by accessing a file. When you create an ActiveX Document project in Visual Basic, it generates a file with a .VDP extension. This is a structured storage file containing the CLSID of the ActiveX Document that should be launched, and any persistent properties exposed by the document. However, the emphasis in Visual Basic seems to be related more to making a Visual Basic application run within a document container such as Internet Explorer than on the "persisted" data (contrast this with Word, where the emphasis is clearly on the persistent document).

Once you've created a component, you'll need to distribute it to your clients. Visual Basic provides a Setup Wizard to help you with all the packaging issues associated with distributing applications and components. The wizard has been enhanced in version 5.0 to support distribution via the Internet. It also supports installation of remote server components using either DCOM or RA.

Visual FoxPro 5.0

Visual FoxPro is a relational database system that provides powerful query and reporting capabilities as well as visual design tools for generating forms, queries, and reports (see Figure 5). Originally based on the dBase language, Visual FoxPro has evolved to include a complete object-oriented programming environment. The IDE offers multiuser project and database management support, including visual tools for designing tables, queries, and views. Visual FoxPro is fully integrated with source code control products such as Visual SourceSafe.

Like Visual Basic, Visual FoxPro provides a graphical forms designer. Your forms can contain built-in FoxPro controls or ActiveX controls. Builders and designers help you configure control properties. Using Visual FoxPro class libraries, you can even create new controls, either from scratch or by customizing existing Visual FoxPro classes. Numerous wizards are provided to help you create applications quickly. An Application Wizard generates a skeleton app for you. The Report Wizard generates professional-looking reports. There's even a Web Wizard to generate Web pages to query and display database records.

In addition to accessing data via the Visual FoxPro database engine, you can access any ODBC data source from a Visual FoxPro-based application. This makes Visual FoxPro a useful tool for creating front-ends for distributed applications. You can even develop your app against a Visual FoxPro database, then upsize the database to run on SQL Server or Oracle databases.

Visual FoxPro also provides limited support for creating Automation servers, which can be deployed locally or remotely using RA. (Visual FoxPro provides the same RA management tools as the Enterprise Editions of Visual Basic and Visual C++.) These servers are single-threaded and cannot fire events. However, even with these limitations, you may find Visual FoxPro to be a useful tool for creating middle-tier business objects—particularly those that interact with data management services.

Developer Studio

Developer Studio is the IDE used by the rest of the tools included with Visual Studio—Visual C++, Visual J++, and Visual InterDev—as well as the MSDN Library. Developer Studio consists of a shell that various packages can be plugged into. A package typically corresponds to a language such as Visual C++, or a tool such as Visual InterDev or NuMega's BoundsChecker. The shell provides standard functionality that all packages can use. With this plug-in approach, new packages are automatically integrated into Developer Studio as soon as they are installed on your system.

If you've used Developer Studio in the past, Developer Studio 97 will look familiar. Appearances can be deceiving, though. Developer Studio has some interesting new features.

Developer Studio uses project workspaces to help you organize your work. Workspaces include projects and your preferences for how project information appears on the screen. Projects organize the files required to create specific targets. One workspace can contain multiple projects (independent or interdependent) and projects can be nested. You can also create projects using different Developer Studio packages. For example, a single workspace might contain pages for a Web site created using Visual InterDev, a Visual C++ project to create a custom server-side object, and a Visual J++ project to create a client-side applet (see Figure 6).

Although the project management user interface looks similar to previous versions, there have been several improvements. A single dialog is used to create new workspaces, projects, and files, instead of the separate project and file dialogs used in earlier versions of Developer Studio. When you create a new file, you can select the project or workspace you want to add it to. Developer Studio is now an ActiveX Document host, which means you can view any ActiveX Document, such as a Word document or Microsoft Excel worksheet, within the IDE. You can also add ActiveX Documents to your projects. This is handy for keeping track of specifications, project plans, and so on. All this additional flexibility requires new project and workspace file formats—project files now have the extension DSP rather than MAK or BLD, and project workspace files now have the extension DSW rather than MDP.

Sharing project workspace files is a problem that has plagued development teams using Developer Studio since its inception. Microsoft has finally managed to eliminate all machine-specific information from the workspace files so that everyone on your team can use the same workspace without needing exactly the same directory configuration. Machine-specific information is now stored in a workspace options file (OPT). You share the workspace and project files among team members, but each team member has his or her own options files.

Developer Studio is also Internet-aware. You can use a new InfoViewer (based on the Internet Explorer WebBrowser control) or your own Web browser to view Web pages within the IDE. When a URL appears in a window, clicking on the URL takes you right to the Web page. The Help menu includes a new item, Microsoft on the Web, that connects you to important developer sites on http://www.microsoft.com/, including Visual Studio Online.

Perhaps the most interesting new feature of the Developer Studio IDE is that it exposes a rich Automation object model that can be manipulated from within Developer Studio by using VBScript macros or DLLs called add-ins. Of course, Automation can also be used to control Developer Studio from other applications too.

VBScript macros are procedures containing VBScript commands. You cannot pass any parameters to VBScript macros. Macros can be created by recording keystrokes which are automatically converted to VBScript, or by writing the VBScript code yourself.

One of the things I like to put in every source file I create is a comment block with Visual SourceSafe keywords. Visual SourceSafe takes care of updating the file name, last revision date, and so on. Manually adding this block in every file is a pain though, so I wrote a VBScript macro to handle this task. It figures out what type of file is active and inserts a standard comment block above the current selection. The macro, InsertVSSHeader, is shown in Figure 7, MYMACROS.DSM. After assigning the macro to an available keystroke, adding a header is a piece of cake.

'------------------------------------------------------------------------------'FILE DESCRIPTION: MYMACROS.DSM
'------------------------------------------------------------------------------
'This is a modification of the FileType function in the sample macros'Return value:  0 Unknown file type'               1 C related file, this includes .c, .cpp, .cxx, .h, .hpp, .hxx'               2 Java related file, this includes .jav, .java'               3 ODL style, .odl, .idl'               4 Resource file, .rc, .rc2'               5 StyleSheet file: .css'               6 HTML style file, this includes .html, And .htm'               7 VBS style, .dsm'               8 Def style, .def'               9 ASP file: .asp, .asa'USE: pass this function the document that you wish to get information forFunction FileType (ByVal doc)    ext = doc.Name    FileType = 0    pos = Instr(ext, ".")    if pos > 0 then        Do While pos <> 1            ext = Mid(ext, pos, Len(ext) - pos + 1)            pos = Instr(ext, ".")        Loop        ext = LCase(ext)    end if    If ext = ".rc" Or ext = ".rc2" Then        FileType = 4   ElseIf ext = ".css" Then      FileType = 5   ElseIf ext = ".asp" Or ext = ".asa" Then      FileType = 9    ElseIf doc.Language = dsCPP Then        FileType = 1    ElseIf doc.Language = dsJava Then        FileType = 2    ElseIf doc.Language = dsIDL Then        FileType = 3    ElseIf doc.Language = dsHTML_IE3 Or doc.Language = dsHTML_IE2 Or _            doc.Language = dsHTML_RFC1866 Then        FileType = 6    ElseIf doc.Language = dsVBSMacro Then        FileType = 7    ElseIf ext = ".def" Then        FileType = 8    Else        FileType = 0    End IfEnd Function
Sub InsertVSSHeader()'DESCRIPTION: This macro adds a comment block with Visual SourceSafe keywords'             at the insertion point.
   Asterisk = Asc("*")   Dash     = Asc("-")
   OpenComment  = ""  'Language specific token to open a comment block   CloseComment = ""  'Language specific token to close a comment block   LineComment  = ""  'Language specific token for each line in a comment block
   'Make sure the active document is a text window   If ActiveDocument.Type = "Text" Then      TypeOfFile = FileType(ActiveDocument)
      'Figure out what comment tokens to use      If TypeOfFile > 0 And TypeOfFile < 5 Then         'C/C++, Java, IDL, and Resource Files         OpenComment  = "/*" + String(63, Asterisk)         CloseComment = String(63, Asterisk) + "*/"         LineComment  = vbTab      ElseIf TypeOfFile = 5 Or TypeOfFile = 6 Then         'HTML and StyleSheet Files         OpenComment  = "<!--" + String(61, Dash)         CloseComment = String(62, Dash) + "-->"         LineComment  = vbTab      ElseIf TypeOfFile = 7 Then         'VBS Files         OpenComment  = "'" + String(64, Dash)         CloseComment = "'" + String(64, Dash)         LineComment  = vbTab + "'"      ElseIf TypeOfFile = 8 Then         'DEF Files         OpenComment  = ";" + String(64, Dash)         CloseComment = ";" + String(64, Dash)         LineComment  = ";" + vbTab      ElseIf typeOfFile = 9 Then         'ASP Files         OpenComment  = "<%" + vbLf + vbTab + "'" + String(59, Dash)         CloseComment = vbTab + "'" + String(59, Dash) + vbLf + "%>"         LineComment  = vbTab + "'"      End If
      If TypeOfFile = 0 Then         'Unrecognized File         MsgBox("Unable to add comment header. Unrecognized file type")      Else         'Position the comment block above the current selection         ActiveDocument.Selection.StartOfLine
         'Add comment block with one assignment statement so it         'can be removed with a single Undo command.         ActiveDocument.Selection = _            OpenComment + vbLf + _            LineComment + "$Logfile:$" + vbLf + _            LineComment + "$Author:$" + vbLf + _            LineComment + "$Modtime:$" + vbLf + _            LineComment + vbLf + _            LineComment + "$Nokeywords$" + vbLf + _            CloseComment + vbLf + vbLf      End If
   End IfEnd Sub

Developer Studio add-ins can be written in Visual C++, Visual Basic, or other languages that can create in-process Automation servers. Add-ins can contain multiple commands to be added to Developer Studio, as well as the code to connect these commands to toolbar buttons and key sequences. A wizard is provided to help you start writing an add-in using Visual C++. Sample add-ins provide standard code you can cut and paste into your own add-ins.

VBScript macros are easier to create than add-ins, but they're not as versatile. Macros can only access the Developer Studio object model. Add-ins, on the other hand, can access all the resources of your system—including other object models. This is a significant difference. For example, if you want to read information from a text file during your processing, you would need to go through major contortions in VBScript, which has no file system commands of its own.

The Developer Studio editors haven't been ignored. Many user-interface improvements make locating and maintaining your resources and source code easier. In particular, syntax coloring is now available for many languages—C++, Java™, VBScript, IDL/ODL, SQL, and several variants of HTML. Take a look at the "What's New in Visual Studio" topic in the online help for the highlights.

You'll also see a more functional WizardBar and Class View. Early versions of these tools were tied to Visual C++. Now any language package can use them (Visual C++ and Visual J++ do). Class View and WizardBar complement each other: Class View lets you see all the classes in all the projects in the current workspace, while WizardBar shows you a single class within the active project. Unlike Class View, WizardBar tracks where you are in the source editor to display context-sensitive class information. For Visual C++, WizardBar extends the functionality of the dialog editor, making it easy to add event handling code for your dialogs. Class View and WizardBar both have a convenient way to add properties and methods to your classes; this has been extended to support editing COM interfaces or dispinterfaces defined in IDL or ODL files. If you're using the ActiveX Template Library (ATL) or MFC, this even creates a stub function in the appropriate H and CPP files.

Developer Studio, like MSDN, uses an online documentation system called InfoViewer, now based on Microsoft Internet Explorer. Documentation is stored in InfoViewer title files, which have the extension .IVT, and are compressed HTML files. Although the implementation of InfoViewer has changed, I did not see any major change in functionality—you can still do full-text searches across titles, define information subsets, create bookmarks, print complete books, access sample code, and so on.

The new InfoViewer is Internet-aware, and topics may contain links to Internet Web sites. The docs can even be incrementally updated over the Internet. If you click on a link to a Web site, an Internet connection will be established. You can also enter a URL into the listbox on the InfoViewer toolbar. InfoViewer Internet navigation uses the Internet Explorer options, and they must be set before an Internet connection can be completed.

Visual C++ 5.0

You'll have to dig to find most of the updates from previous versions of Visual C++. Not that the changes are insubstantial, they're just not as visible as a new IDE.

On the compiler front, there have been updates to better conform with the C++ standard. Visual C++ 5.0 now supports the keywords bool, explicit, false, mutable, true, and typename. This will undoubtedly thrill the C++ gurus, but may cause you C++ programmers grief if you've used these words for your own purposes. Visual C++ 5.0 also ships with an ANSI Standard C++ library that conforms to the working paper produced by the Stockholm meeting of July 1996. There have been some changes to the compiler options you can use as well. If you're upgrading from a previous version of Visual C++, I'd suggest looking at the "What's New" section of the documentation to see if any of these changes will affect your app.

In an intriguing move, Microsoft has added special support for COM to the Visual C++ compiler itself. This support simplifies creating COM clients—for instance, applications or other components that use ActiveX components. Microsoft has added a new preprocessor keyword, #import, which is essentially #include for type libraries. When you import a type library into your C++ code, the preprocessor reads the type library, creates a C++ header file describing the included COM interfaces as C++ classes, and creates a second header file containing the implementation of these classes. You can read more about the compiler support for COM in George Shepherd's article in this issue of MSJ.

If you prefer to work at a slightly higher level of abstraction, Visual C++ includes two class libraries. MFC is an established framework for Windows-based application development and ActiveX control creation. The ActiveX Template Library (ATL) is a relatively new library designed specifically for creating small, fast ActiveX components.

There have been a few updates to MFC since version 4.2b, primarily for Internet and database support. ActiveX Documents written in MFC now support all the features required for hosting in both Internet Explorer and Office Binder. MFC also supports asynchronous URL monikers. On the database front, MFC supports DAO 3.5 and ODBC 3.0. It supports binding simple and complex data controls to any ActiveX data control, including the Remote Data Control shipped with Visual C++ Enterprise Edition.

Previous versions of MFC were able to create Automation components, ActiveX controls, and ActiveX Documents. You won't see any major changes here. Components can support apartment model threading, but cannot be free-threaded. Unlike Visual Basic, MFC does provide support for windowless controls. However, MFC doesn't support dual interfaces directly.

ATL takes a radically different approach from MFC. It focuses on one thing—creating small, fast ActiveX components. (For more information see "Developing and Deploying ActiveX Web Components: A Tools Overview" by Michael T. McKeown and Mary Kirtland, MIND, April 1997.) Early versions of ATL only had built-in support for only the most basic COM functionality. With ATL 2.0, the ability to create ActiveX controls was added. Visual C++ 5.0 ships with ATL 2.1, which offers better integration with the Developer Studio IDE and wizards to create more kinds of objects. (You'll also see significantly smaller components when you compile with Visual C++ 5.0, due to better code-generation optimizations.)

Of all the tools included with Visual Studio, ATL offers the most flexibility in creating components. It supports all COM threading models and lets you build components as DLLs, EXEs, or services. Unlike MFC, ATL supports dual interfaces. And since ATL is a C++ template library, all code gets included in your component—no runtime DLL is required. ATL uses templates and multiple inheritance to implement objects. If you're not comfortable with these C++ features, you may find using ATL rough going. However, the wizards provided are a great help in creating the basic framework for your component and adding object classes to it. Figure 8 shows the ATL Object Wizard.

Visual C++ 5.0 Enterprise Edition provides better SQL support than earlier Visual C++ versions. A Data View pane in the project workspace window simplifies working with ODBC data sources. The text editor color-codes SQL statements to help reduce syntax and spelling errors. Combined with the Data View's ability to generate skeletal triggers and stored procedures, this helps you create SQL scripts and procedures. The integrated SQL debugger helps track down errors in your stored procedures.

In addition to working directly with SQL or using MFC to work with DAO or ODBC, you can use data controls that ship with Visual C++ 5.0 to connect to local or remote databases. These controls also ship with Visual Basic 5.0. (See Figure 9 for a list of the controls that are available.) You can bind the MSDataList, MSDataCombo, Data Bound Grid, Masked Edit, and Calendar controls to the Remote Data control. When you do this, data accessed by the Remote Data Control is displayed in the data-bound control. This helps you write Visual C++-based apps that can view and maintain database records. Remote Data Objects is used to manipulate the data control. When you insert the control into your project, Visual C++ automatically creates the C++ class framework for manipulating the control.

Control Type	Files
Remote Data	MSRDC32.OCXMSRDO32.DLL
Apex Data-Bound Grid	DBGRID32.OCXGRDKRN32.DLL
Microsoft Masked Edit	MSMASK32.OCX
MSDataList	DBLIST32.OCX
MSDataCombo	DBLIST32.OCX
Calendar	MSACAL70.OCX

Visual J++ 1.1

Visual J++ is Microsoft's Java development tool. Like Visual C++, Visual J++ uses Developer Studio as its IDE. Figure 10 shows a debugging session in progress. Note that the debugger disassembly window shows the bytecodes being executed.

Visual J++ has wizards to help you generate the generic parts of your Java applets and applications. The Applet Wizard generates a starting framework that will run as both an applet and an application. You can elect to have the wizard provide multithreading support, animations, mouse event handlers, and more—it will even generate a sample HTML page for testing the operation as an applet.

Java applets use Abstract Windowing Toolkit (AWT) code to specify UI elements such as menus and dialogs. Instead of writing this code by hand, you can use graphical resource editors in the IDE to create your UI elements and store them in a resource template file. You then use the Java Resource Wizard to convert that file into the appropriate Java code.

Microsoft's reference implementation of the Java Virtual Machine (VM) integrates Java and ActiveX. Using Visual J++, you can build components with Java and expose their functionality as COM interfaces. You can also write client applications and higher-level components in Java that glue together existing ActiveX components. The Java Type Library Wizard is used to create Java classes that interface with the ActiveX components described by a type library. (Sounds a lot like Visual C++ #import, doesn't it?) Take a look at the March 1997 Visual Programmer column in MSJ and "Understanding the Java/COM Integration Model," by Guy and Henry Eddon, MIND, April 1997 to learn more about Java/COM integration.

The Web Content Tools—Visual InterDev 1.0

Visual InterDev (formerly Internet Studio) is a complete set of tools for creating dynamic, data-driven, Web applications for the Internet and intranet. With Visual InterDev, you can edit static content files, create, manage, and work with ODBC databases and connect them to your Web application, add client and server-side scripting to HTML pages using VBScript or JScript™, and manage multi-user Web projects.

When you create your Web application with Visual InterDev, you work with a Web, which is the actual set of files out on the Web server, and a project, which is the working directory and files located on your development machine. Visual InterDev includes Web project wizards that create the working directory on the development machine, create project and workspace files, create (if necessary) and configure the Web on a Web server, and create a set of starter files for the Web. Multiple developers can work on the same site and multiple projects can point at the same Web. Visual InterDev lets you decide whether multiuser projects should permit free-for-all changes or should use source control. When source control is enabled, file locking on the Web server is used to prevent multiple users from changing files.

To create HTML, you can use the Developer Studio text editor, the FrontPage WYSIWYG HTML editor, or any other editor you might prefer. To activate your Web page, you add controls and scripting. The editors make it extremely easy to add controls to your pages. If you're not a VBScript or JScript™ guru, Visual InterDev supplies a Script Wizard that provides limited point and click client-side scripting support. Visual InterDev keeps track of the relationships between Web files and can update links when you move a file. A Link View tool lets you see the connections between your Web pages graphically. Figure 11 shows the link view and FrontPage™ editor in action.

Visual InterDev's strength is its support for creating data-driven applications using Microsoft Active Server Pages. (For more information about Active Server Pages, take a look at my article, "Writing a Smart Server Application with Denali," MIND, December 1996.) Data-driven Active Server Pages tend to have a lot of code, much of which is the same no matter what database is accessed or how the data is displayed—the ideal scenario for a wizard. That's exactly what Visual InterDev provides: wizards to generate common code for Active Server Pages. Visual InterDev also provides something called Web Designers that help you create and initialize instances of server-side controls in your Active Server Pages. Using these designers is a little disconcerting if you are editing your pages in text mode because a visual editor is displayed. The Visual InterDev designers don't really make a compelling case for using them—it's faster to type in the little bit of code they generate than it is to use the designer, and the handwritten code is easier to read. For complex server-side objects such as the data command control, a design-time interface would be extremely handy.

Once you've got some content, Visual InterDev lets you test it out in your browser (Internet Explorer by default) from within the IDE using the Preview command. This is important for Active Server Pages, which must be run from the Web server to generate the client-side content; you can't just open up the file and expect to see what Web clients will see. You can also test alternate browsers using the Browse With command—very handy. The text editor's syntax coloring is a helpful addition to actual testing in multiple browsers. You can select different versions of HTML to control syntax coloring, and unrecognized tags show up in a different color.

Visual InterDev includes Visual Data Tools to help manage your application databases. The tools include a graphical Query Designer and Database Designer. If you've used Microsoft Access and Query, these tools will look familiar. Database Designer helps you create, edit, and delete Microsoft SQL Server 6.5 database objects. Query Designer helps you construct SQL statements to query or update databases.

Visual InterDev also includes several tools for creating and managing multimedia content. Image Composer is a sprite-based image editor. To create images in Image Composer, you take existing images (sprites), apply various imaging effects, and put the images together to form a composition. These images can then be saved in standard image formats that Web browsers understand. Music Producer is a program you can use to create music. You specify information such as tempo, key, style, mood, and instruments, and Music Producer generates an original composition for you. This works better for some types of music than others: the compositions Music Producer generated for me tended to be heavy on the rhythm section and light on the melody (think about the electronic organ demonstrations at your local mall and you'll get the idea). But if you need background sounds for your Web site and can't compose your own, Music Producer is the answer.

Finally, Visual InterDev includes a tool for keeping track of media. If you've ever wasted half an hour trying to locate that way-cool bullet that would be absolutely perfect for your new Web page, or ended up with half a dozen applets cluttering the screen while picking out background images and sounds, you'll appreciate Media Manager. Media Manager is so seamlessly integrated into the Windows shell that, if it weren't for the startup screen that automatically loads with Windows, you might never realize it's there. Although you might think Media Manager is just for graphics, audio, and video files, you can actually keep track of many kinds of files with it. All you need to do is create a Media Manager directory (by right-clicking on a directory and selecting "Convert to a Media Manager folder," or by selecting NewMedia Manager folder) and start adding files to it. Figure 12 shows a Media Manager view of some audio files. Media Manager also keeps track of file properties—both those it understands automatically in supported file types and any annotations you add yourself—so that it can provide enhanced file find capabilities.

Visual InterDev is a powerful, full-featured tool for creating and managing Web content, and I've obviously just hit the highlights here. For more details, take a look at the March 1997 MIND.

The Enterprise Tools

Visual Studio 97 Enterprise Edition includes Developer Editions of Microsoft SQL Server 6.5 and Microsoft Transaction Server 1.0. Developer editions are full-fledged copies of the respective products with restricted licenses that prohibit deployment of your applications. This lets you develop and test your applications within your development team, for example, before handing the app over to your IS manager for company-wide deployment. Your team can work on its own private database server, without affecting production applications—and without purchasing a production copy of SQL Server or Transaction Server.

If you're not familiar with Microsoft Transaction Server (formerly codenamed Viper), it provides development tools and runtime services for building high-performance, scalable applications with transactioning.

The Visual Studio Enterprise Edition also includes the latest version of Visual SourceSafe, Microsoft's source code management tool. It is fully integrated with the Visual Studio tools, and with Microsoft Access and Microsoft FrontPage. Visual SourceSafe is a project-oriented version control system for tracking changes to any type of file. As you can see in Figure 13, Visual SourceSafe provides a hierarchical view of your project files. Development team members can share files, modify them independently, and merge changes or revert to earlier versions if necessary. Like most version control systems, you can add comments about the file you are checking in or out, then later review the file's history. A separate administration program lets you control who has access to which files.

Perhaps the most interesting new feature of Visual SourceSafe version 5.0 for Visual Studio users is its Web site management feature. To create a Web site, you collect a set of files and check them into a Visual SourceSafe project. Designating the project as a Web site project using the Administrator program enables several useful features: Check Hyperlinks, which looks for invalid links on your site, Create Site Map, which creates a map of all the Web pages on your site, and Deploy, which moves an entire project onto a designated Web server.

Summing Up

Microsoft's aim in creating Visual Studio 97 is to provide you the tools you need to develop applications that integrate the best of the Internet and the best of client/server computing—applications that can be built once and deployed everywhere.

ActiveX components are central to Microsoft's distributed applications architecture. While there are thousands of ready-to-use components you can purchase, at some point you'll probably want to write your own. Visual Studio 97 provides a multitude of options for creating components. Each tool optimizes for different scenarios and has different constraints (see Figure 14). Instead of forcing you to use a one-size-fits-all tool to create your components, Visual Studio 97 gives you the flexibility to use the tool that best meets the needs of your development project. And since ActiveX is language-neutral, the components will work together regardless of how they were developed.

Figure 14 Visual Studio Tools ActiveX Component Authoring Comparison

Capability	Visual Basic	Visual FoxPro	Visual J++	Visual C++
				ATL	MFC
ActiveX Components
Automation	x	x	x	x	x
Dual Interface	x		x	x
Events	x			x	x
UI Controls	x			x	x
Windowless Controls				x	x
Internet-Aware Controls	x			x	x
ActiveX Documents	x			x	x
Threading Models
Single Threaded	x	x		x	x
Apartment Model	x*			x	x
Free Threaded				x
Both (Apt. + Free)			x	x
Packaging
In-Process	x	x	x	x	x
Executable	x	x	x†	x	x
Service				x
* Only in Enterprise Edition when component marked as unattended (no UI) † Using surrogate application

Building Distributed Applications with Components

A distributed application is nothing more than an app that runs on more than one machine. The most common reason for writing a distributed app is to give multiple clients the ability to create or access data from a common set of stored data. These applications are also known as client-server applications. Figure A shows the architecture of a typical, multitier client-server application. This general architecture can be applied to traditional client-server apps as well as to Web-based apps. (Web apps are client-server applications, after all.) Well-designed multitier architectures partition software into reusable parts, or components, that can be easily adapted to changing business needs.

A front-end or presentation tier provides the user interface, and is typically created using a rapid application development (RAD) tool. The presentation layer accesses business objects that perform actions such as validating user input or calculating output based on business rules. The business objects communicate with data management services that know how to access data servers. By separating presentation, business logic, and data access code into discrete components with well-defined, narrow interfaces, developers can create reusable, maintainable, and scalable code. Any tier can be modified easily to meet changing requirements without affecting the rest of the app.

When it comes time to deploy an application that uses a tiered architecture, components are installed wherever it makes the most sense for the application's needs. For example, two important requirements for most applications are a responsive user interface and minimal network traffic. So, you'll typically see the presentation layer installed on each client's machine and data management services deployed near the data they access. Business objects can be installed on client machines, data servers, or any other machines, depending on the application and the environment it's used in.

What makes this architecture work is an underlying infrastructure that lets components work together without regard to their physical location. Developers write only the components. These components can then be glued together in any way, shape, or form, depending on the business need. Components can be reused in a variety of applications that can be deployed anywhere. The applications can be standalone, single-user applications or complex enterprise solutions. Although components may need to be tuned for specific performance scenarios, the fundamental notion of what it means to write a component remains unchanged.

The Component Object Model

In the Microsoft universe, the infrastructure that enables objects to work together is the Component Object Model (COM), the cornerstone of the ActiveX™ technologies. COM is a widely used technology that provides a binary standard for component interoperability. "Binary standard" means that components can be written in and used from most any language—you aren't tied into a single development language or tool. "Widely used" means that there are literally thousands of components available today that you can purchase for use in your applications. These components range from simple user interface widgets to complex data analysis tools.

COM takes care of all the murky details required to make objects work together, regardless of where these objects are located. Neither the developer of a component nor the developer of the application that uses the component needs to worry about where the component code is located. This gives you an enormous amount of flexibility when it's time to deploy your application.

COM objects communicate with each other and with client applications by using an interface. An interface is essentially a specification for some well-defined behavior. Any object that claims it supports a particular interface agrees to provide the specified behavior. A client that uses the interface doesn't need to worry about the specifics of how a particular object implements the interface; it just knows that the object provides the specified services. Objects can support any number of interfaces.

Objects that support COM are called ActiveX components, or ActiveX controls. The features required of an ActiveX component are simple: support the fundamental COM interface, IUnknown, and know how to register yourself with the operating system.

Admittedly, if this is all a component did, it would be pretty boring, so components add their own unique functionality by implementing additional interfaces. Some interfaces are generic and—either by themselves or in conjunction with other interfaces—provide behaviors that can be implemented by many components. Other interfaces are specific to a single component and are known as custom interfaces.

Components that implement certain generic interfaces are often referred to by special names. For example, components that implement the IDispatch interface are called Automation components. Automation components expose properties, methods, and events to client applications via IDispatch interfaces or a combination of IDispatch and custom interfaces known as a dual interface. Information about interfaces and components can be stored in a type library. Development tools can use this information at design time to determine what features a particular component exposes.

An ActiveX control is an Automation component that provides some user interface and is designed to be used in the context of a data form. There are a number of additional interfaces UI controls use to communicate with control container applications.

Another type of specialized component is called an ActiveX Document. ActiveX Documents support an additional set of interfaces that let them work with ActiveX Document containers to display a viewport into your document's data. Unlike normal components, ActiveX Documents are displayed full-frame within document hosts such as Internet Explorer or Office Binder. When an ActiveX Document is viewed, its menus are merged with the host's menus, giving the user the sense that he or she is working with your application rather than the host. Microsoft Word docs and Microsoft Excel worksheets are examples of ActiveX Documents.

Active Content

To create distributed applications, you purchase or create a bunch of components and glue them together, either into higher-level components or into a front-end application that interacts with the user. Web applications that target the Internet or intranets are created the same way; the only difference is the type of glue you use. Web applications use HTML for their user interfaces, and glue components together using a scripting language such as Visual Basic® for Scripts (VBScript) or JavaScript. The combination of HTML, components, and scripting is often called active content. Just like other distributed applications, Web applications can be distributed over multiple machines. The HTML and possibly some components run on each client machine. Other components and data access services are likely to run only on the server side. The client and server communicate with each other using standard Internet protocols, typically HTTP.

Visual Studio Enterprise Edition Features

2008-06-24T11:13:00.000-07:00

Visual Studio

Enterprise Edition

Features

The Visual Studio Enterprise Edition has it all. With it, you can more quickly build mission-critical enterprise solutions. For more information on enterprise development with Visual Studio, and the editions in which each language tool is available, please use the following links.

Your Ad Here

Topic	Description
Developing for the Enterprise	Introduces Visual Studio's enterprise development guide, with sections on architectural and data access design.
Visual Basic Enterprise Edition Features	Lists new and enhanced Visual Basic enterprise features, with links to more information.
What's Included in the Visual C++ Enterprise Edition?	Lists Visual C++ enterprise features, providing links to more information about each.
Introducing Visual InterDev	Provides an introduction to the main feature areas of Visual InterDev and links to more detailed information.
Visual J++ Start Page	Introduces the Visual J++ documentation.

Features in the Enterprise Editions

The Visual Studio Enterprise Edition includes all of the features available with the Visual Studio development tools. When installing the Visual Studio Enterprise Edition, you can elect to install enterprise features for use with these tools. In addition, Visual Basic and Visual C++ are available in separate enterprise editions.

The following table indicates whether a given feature is available with a given tool. If you acquired a separate enterprise edition of Visual Basic or Visual C++, you can use this table also to identify which of the Visual Studio enterprise features you received with your purchase. (Visual J++ and Visual InterDev are not offered as separate enterprise editions.) In addition, some of these features are available in professional editions with a subset of their enterprise edition functionality.

The following list of features is followed by descriptions and a suggested place to start for more detailed information on the feature.

Feature Name	Visual Basic	Visual C++	Visual FoxPro	Visual InterDev	Visual J++
Application Performance Explorer	VB		VFP		VJ++
COM Transaction Integrator for CICS and IMS	VB	VC++
Data Environment Designer	VB
Data Object Wizard	VB
Database Designer	VB	VC++	VFP	VID	VJ++
Deployment	VB		VFP	VID	VJ++
Internet Information Server 4.0	VB		VFP	VID	VJ++
Microsoft Transaction Server 2.0	VB	VC++	VFP	VID	VJ++
New Database Wizard	VB	VC++			VJ++
OLE DB Provider for AS/400 and VSAM Data	VB	VC++
Posting Acceptor	VB				VJ++
Query Designer	VB	VC++	VFP	VID	VJ++
RDO User Connection Designer	VB
RemoteData Control	VB	VC++
SNA Server 4.0	VB	VC++
SQL Debugging*	VB	VC++	VFP	VID	VJ++
SQL Server 6.5	VB	VC++	VFP	VID	VJ++
Stored Procedure Editor*	VB	VC++	VFP	VID	VJ++
Stored Procedures as Project Items	VB		VFP	VID	VJ++
Table Design	VB	VC++	VFP	VID	VJ++
Trigger Editor*	VB	VC++	VFP	VID	VJ++
View Designer	VB	VC++	VFP	VID	VJ++
Visual Component Manager	VB	VC++		VID	VJ++
Visual Modeler	VB	VC++
Visual SourceSafe	VB	VC++	VFP		VJ++
Visual Studio Analyzer					VJ++
Webclasses	VB

* Feature may differ between development tools.

Enterprise Feature Descriptions

Feature Name	For More Information Online
Application Performance Explorer (APE) — A tool to test the run-time performance and resource load characteristics of distributed application design scenarios you are considering.	Application Performance Explorer Reference (Visual Studio)
COM Transaction Integrator for CICS and IMS — A generic proxy that handles communications between the Windows NT platform and mainframe computers.	COMTI Is a Proxy for the Mainframe (Visual Studio)
Data Environment Designer — An interactive, design-time environment for creating programmatic run-time data access.	Using the Data Environment Designer
Data Object Wizard — A wizard through which you can generate code to create custom data sources and User Controls to display and manipulate data through stored procedures.	Data Object Wizard (Visual Basic)
Database Designer — A tool to graphically represent tables and their relationships, and through which you can create and modify the database objects that your application relies on.	Database Designer (Visual Studio)
Deployment — A Microsoft development environment feature through which you can distribute and debug the components of your Web applications.	Solution Deployment Reference (Visual Studio)
Internet Information Server 4.0 — A complete FTP, Gopher, and World Wide Web information service specifically designed to run on Microsoft Windows NT and within the BackOffice environment.	Internet Information Server
Microsoft Transaction Server 2.0 — A component-based transaction processing system for developing, deploying, and managing high-performance, scalable, and robust enterprise, Internet, and intranet server applications.	Getting Started with Microsoft Transaction Server
OLE DB Provider for AS/400 and VSAM Data — A provider is a COM component with an OLE DB-compliant interface. This provider enables access to the IBM Distributed Data Management (DDM) architecture.	Accessing VSAM and AS/400 Files (Visual Studio)
Posting Acceptor 2.0 — A tool that enables Microsoft Internet Information Server to accept Web content from Web Publishing Wizard and other clients via HTTP Post.	Configuring an IIS Server to Be a Deployment Target (Visual Studio)
Query Designer — A tool for creating SQL commands using a simple, intuitive visual interface.	Query Designer (Visual Studio)
RDO User Connection Designer — A tool using Visual Basic ActiveX designer architecture to provide design-time support for programmatic data access.	The UserConnection Designer (Visual Basic)
RemoteData Control — An ActiveX control that provides access to data stored in a remote ODBC data source through bound controls.	Using the RemoteData Control (Visual Basic)
SNA Server 4.0 — A tool that provides a gateway connection between personal computer local area networks (LANs) or wide area networks (WANs), along with IBM mainframe and AS/400 hosts.	What Is SNA Server? (Visual Studio)
SQL Debugging — Features through which you can debug Microsoft SQL Server stored procedures and triggers in much the same way that you debug other kinds of scripts or programs.	Working with SQL Server Databases (Visual Studio) Debugging SQL (Visual C++) The T-SQL Debugger (Visual Basic)
SQL Server 6.5 — A server that provides tools for enterprise-wide administration, data replication, parallel DBMS performance, and scalability to very large databases.	Introduction (Microsoft SQL Server Programmer's Toolkit)
Stored Procedures as Project Items — With Microsoft® Visual Database Tools™, you can create and manipulate stored procedures within the development environment.	Stored Procedures (Visual Studio) Working with Stored Procedures in Data View (Visual Studio) Creating an Extended Stored Procedure (Visual C++) Stored Procedures in the SQL Editor (Visual Basic)
Table Design — With Microsoft Visual Database Tools, you can create tables, change the table view, adjust table size, duplicate tables, and add columns to tables.	Tables (Visual Studio)
Trigger Editor — With Microsoft Visual Database Tools, you can create, open, copy, and delete triggers in your database.	Working with Triggers in Data View (Visual Studio) Triggers in the SQL Editor (Visual Basic)
View Designer — With Microsoft Visual Database Tools, you can create a view, which is a virtual table generated by a query.	Creating Views with the View Designer (Visual Studio)
Visual Component Manager — A tool with which to organize, find, and insert components into a Visual Studio project, addressing three requirements for storing and organizing components: publishing, finding, and reusing them.	Visual Component Manager Reference (Visual Studio)
Visual Modeler — A tool for designing three-tier distributed applications using class and component diagrams. With Visual Modeler you can visually design models of the classes and components your application needs, then convert these models to Visual Basic or Visual C++ code.	Visual Modeler Reference (Visual Studio)
Visual SourceSafe — A source control tool with which you can manage your projects, regardless of the file type (text files, graphics files, binary files, sound files, or video files) by saving them to a database.	Visual SourceSafe Start Page (Visual SourceSafe)
Visual Studio Analyzer — A tool for evaluating, analyzing, and debugging the structure, performance, and interactions of a distributed application from an application perspective, rather than a component or code perspective.	Visual Studio Analyzer Reference (Visual Studio)
Webclasses — A Visual Basic component that resides on a Web server and responds to input from the browser. When you create an IIS application, you create its webclasses using the Webclass Designer.	An Introduction to Webclasses (Visual Basic)

What's in the Enterprise Edition?

2008-06-24T11:08:00.000-07:00

What's in the

Enterprise Edition?

The Visual Studio Enterprise Edition includes all of the Visual Studio development tools, including Visual Basic, Visual C++, Visual FoxPro, Visual InterDev, and Visual J++. When installing the Visual Studio Enterprise Edition, you can elect to install any or all of these tools, as well as a number of special enterprise features for use with them. It also includes many additional tools and technologies from Microsoft BackOffice and the Microsoft systems group.

In addition, Visual Basic and Visual C++ are available in separate enterprise editions, which contain many of the enterprise and system tools.

The following table describes these enterprise features, and indicates whether a given feature is available with a given tool. If you purchased a separate enterprise edition of Visual Basic or Visual C++, you can use this table to also identify which of the Visual Studio enterprise features you received with your purchase. (Visual J++ and Visual InterDev are not offered as separate enterprise editions.) In addition, some of these features are available in professional editions with a subset of their enterprise edition functionality.

Each feature name and description is accompanied by a suggested place to start for more detailed information on the feature.

Feature	For more information online
Application Performance Explorer (APE) — A tool to test the run-time performance and resource load characteristics of distributed application design scenarios you are considering (VB, VFP, VJ++).	Application Performance Explorer Reference (Visual Studio)
COM Transaction Integrator for CICS and IMS — A generic proxy that handles communications between the Windows NT platform and mainframe computers (VB, VC++).	COMTI Is a Proxy for the Mainframe (Visual Studio)
Data Environment Designer — An interactive, design-time environment for creating programmatic run-time data access (VB).	Using the Data Environment Designer
Data Object Wizard — A wizard through which you can generate code to create custom data sources and User Controls to display and manipulate data through stored procedures (VB).	Data Object Wizard (Visual Basic)
Database Designer — A tool to graphically represent tables and their relationships, and through which you can create and modify the database objects that your application relies on (ALL).	Database Designer ( Visual Studio)
Deployment — A Microsoft development environment feature through which you can distribute and debug the components of your Web applications (VB, VFP, VID, VJ++).	Solution Deployment Reference (Visual Studio)
Internet Information Server 4.0 — A complete FTP, Gopher, and World Wide Web information service specifically designed to run on Microsoft Windows NT and within the BackOffice environment (VB, VFP, VID, VJ++).	Internet Information Server
Microsoft Transaction Server 2.0 — A component-based transaction processing system for developing, deploying, and managing high-performance, scalable, and robust enterprise, Internet, and intranet server applications (ALL).	Getting Started with Microsoft Transaction Server
OLE DB Provider for AS/400 and VSAM Data — A provider is a COM component with an OLE DB-compliant interface. This provider enables access to the IBM Distributed Data Management (DDM) architecture (VB, VC++).	Accessing VSAM and AS/400 Files (Visual Studio)
Posting Acceptor 2.0 — A tool that enables Microsoft Internet Information Server to accept Web content from Web Publishing Wizard and other clients via HTTP Post (VB, VJ++).	Configuring an IIS Server to Be a Deployment Target (Visual Studio)
Query Designer — A tool for creating SQL commands using a simple, intuitive visual interface (ALL).	Query Designer (Visual Studio)
RDO User Connection Designer — A tool using Visual Basic ActiveX designer architecture to provide design-time support for programmatic data access (VB).	The UserConnection Designer (Visual Basic)
RemoteData Control — An ActiveX control that provides access to data stored in a remote ODBC data source through bound controls (VB, VC++).	Using the RemoteData Control (Visual Basic)
SNA Server 4.0 — A tool that provides a gateway connection between personal computer local area networks (LANs) or wide area networks (WANs), along with IBM mainframe and AS/400 hosts (VB, VC++).	What Is SNA Server? (Visual Studio)
SQL Debugging — Features through which you can debug Microsoft SQL Server stored procedures and triggers in much the same way that you debug other kinds of scripts or programs (ALL).	Working with SQL Server Databases (Visual Studio) Debugging SQL (Visual C++) The T-SQL Debugger (Visual Basic)
SQL Server 6.5 — A server that provides tools for enterprise-wide administration, data replication, parallel DBMS performance, and scalability to very large databases (ALL).	Introduction (Microsoft SQL Server Programmer's Toolkit)
Stored Procedures Editor — With Microsoft Visual Database Tools, you can create and manipulate stored procedures within the development environment (ALL).	Stored Procedures (Visual Studio) Working with Stored Procedures in Data View (Visual Studio) Creating an Extended Stored Procedure (Visual C++) Stored Procedures in the SQL Editor (Visual Basic)
Table Design — With Microsoft Visual Database Tools, you can create tables, change the table view, adjust table size, duplicate tables, and add columns to tables (ALL).	Tables (Visual Studio)
Trigger Editor — With Microsoft Visual Database Tools, you can create, open, copy, and delete triggers in your database (ALL).	Working with Triggers in Data View (Visual Studio) Triggers in the SQL Editor (Visual Basic)
View Designer — With Microsoft Visual Database Tools, you can create a view, which is a virtual table generated by a query (ALL).	Creating Views with the View Designer (Visual Studio)
Visual Component Manager — A tool with which to organize, find, and insert components into a Visual Studio project, addressing three requirements for storing and organizing components: publishing, finding, and reusing them (VB, VC++, VID, VJ++).	Visual Component Manager Reference (Visual Studio)
Visual Modeler — A tool for designing three-tier distributed applications using class and component diagrams. With Visual Modeler you can visually design models of the classes and components your application needs, then convert these models to Visual Basic or Visual C++ code (VB, VC++).	Visual Modeler Reference (Visual Studio)
Visual SourceSafe — A source control tool with which you can manage your projects, regardless of the file type (text files, graphics files, binary files, sound files, or video files) by saving them to a database (VB, VC++, VFP, VJ++).	Visual SourceSafe Start Page (Visual SourceSafe)
Visual Studio Analyzer — A tool for evaluating, analyzing, and debugging the structure, performance, and interactions of a distributed application from an application perspective, rather than a component or code perspective (VJ++).	Visual Studio Analyzer Reference (Visual Studio)
Webclasses — A Visual Basic component that resides on a Web server and responds to input from the browser. When you create an IIS application, you create its webclasses using the Webclass Designer (VB).	An Introduction to Webclasses (Visual Basic)

Adding Help to Your Visual Studio Applications

2008-06-24T09:39:00.000-07:00

Adding Help

to Your

Visual Studio

Applications

The development tools in Visual Studio 6.0 allow you to add both the traditional Windows Help (WinHelp) and the new HTML Help to your applications. Adding Help to your applications is the following topics:

Development Tool	HTML Help Topic	Description
Visual Basic	Adding Help to Your Application	Describes how to implement HTML Help in your Visual Basic applications.
Visual C++	Help Topics (HTML Help): Context Sensitive Help for Your Programs	Describes how to implement HTML Help in your VC++ applications.
Visual FoxPro	Creating Graphical Help	Describes how to implement both HTML Help and traditional Windows Help (WinHelp) in your Visual FoxPro applications.

For a general discussion of HTML Help, refer to the following MSDN article: http://www.microsoft.com/msdn/news/htmlhelp.htm.

C++ Programming Concept

2008-06-22T10:31:00.000-07:00

About C++

Contents

Your Ad Here

1 History
1.1 Language standard
1.2 Etymology
2 Philosophy
3 Standard library
4 Hello world program
5 Language features
5.1 Operators and operator overloading
5.2 Templates
5.3 Objects
5.3.1 Encapsulation
5.3.2 Inheritance
5.4 Polymorphism
5.4.1 Static polymorphism
5.4.1.1 Function overloading
5.4.1.2 Default arguments
5.4.1.3 Class and function templates
5.4.2 Dynamic polymorphism
5.4.2.1 Inheritance
5.4.2.2 Virtual member functions
6 Parsing and processing C++ source code
7 Problems and controversies
7.1 Standards compliance
7.2 Criticism
8 Incompatibility with C

C++ ("C Plus Plus", pronounced /ˌsiːˌplʌsˈplʌs/) is a general-purpose programming language. C++ is regarded as a middle-level language, as it comprises a combination of both high-level and low-level language features. It is a statically typed, free-form, multi-paradigm, generally a compiled language where compilation creates machine code for the target machine hardware, supports procedural programming, data abstraction, object-oriented programming, and generic programming.
Bjarne Stroustrup developed C++ in 1979 at Bell Labs as an enhancement to the C programming language and named it "C with Classes". In 1983, it was renamed to C++. Enhancements started with the addition of classes, followed by, among other features, virtual functions, operator overloading, multiple inheritance, templates, and exception handling. The C++ programming language standard was ratified in 1998 as ISO/IEC 14882:1998, the current version of which is the 2003 version, ISO/IEC 14882:2003. A new version of the standard (known informally as C++0x) is being developed.

HISTORY
Many credit the origin of the name "C" as being a follow-on to APL (A Programming Language) and then BCPL, (B Computer Programming Language), or just plain "B" as it was most commonly called. APL was completely different in concept. With B, the original idea was to create machine code that was as closely identical to coding in assembly as possible, along with library functions for input/output, mathematical functions, etc. For the purists who thought it necessary to program in assembly to get full performance, it allowed the opportunity to program at a higher level and achieve better productivity. C is very similar to B, and while is not as efficient as B, it is available for a much greater variety of processors and platforms.

Bjarne Stroustrup, creator of C++
Stroustrup began work on C with Classes in 1979. The idea of creating a new language originated from Stroustrup's experience in programming for his Ph.D. thesis. Stroustrup found that Simula had features that were very helpful for large software development, but the language was too slow for practical use, while BCPL was fast but too low-level to be suitable for large software development. When Stroustrup started working in AT&T Bell Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing. Remembering his Ph.D. experience, Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it is general-purpose, fast, portable and widely used. Besides C and Simula, some other languages that inspired him were ALGOL 68, Ada, CLU and ML. At first, the class, derived class, strong type checking, inlining, and default argument features were added to C via Cfront. The first commercial release occurred in October 1985.
In 1983, the name of the language was changed from C with Classes to C++ (++ being the increment operator in C and C++). New features were added including virtual functions, function name and operator overloading, references, constants, user-controlled free-store memory control, improved type checking, and BCPL style single-line comments with two forward slashes (//). In 1985, the first edition of The C++ Programming Language was released, providing an important reference to the language, since there was not yet an official standard. In 1989, Release 2.0 of C++ was released. New features included multiple inheritance, abstract classes, static member functions, const member functions, and protected members. In 1990, The Annotated C++ Reference Manual was published. This work became the basis for the future standard. Late addition of features included templates, exceptions, namespaces, new casts, and a Boolean type.
As the C++ language evolved, a standard library also evolved with it. The first addition to the C++ standard library was the stream I/O library which provided facilities to replace the traditional C functions such as printf and scanf. Later, among the most significant additions to the standard library, was the Standard Template Library.
Language standard
After years of work, a joint ANSI–ISO committee standardized C++ in 1998 (ISO/IEC 14882:1998). For some years after the official release of the standard, the committee processed defect reports, and published a corrected version of the C++ standard in 2003. In 2005, a technical report, called the "Library Technical Report 1" (often known as TR1 for short) was released. While not an official part of the standard, it gives a number of extensions to the standard library, which are expected to be included in the next version of C++. Support for TR1 is growing in almost all currently maintained C++ compilers.
While the C++ language is royalty-free, the standard document itself is not freely available.
Etymology
According to Stroustrup: "the name signifies the evolutionary nature of the changes from C". During C++'s development period, the language had been referred to as "new C", then "C with Classes". The final name is credited to Rick Mascitti (mid-1983) and was first used in December 1983. When Mascitti was questioned informally in 1992 about the naming, he indicated that it was given in a tongue-in-cheek spirit. It stems from C's "++" operator (which increments the value of a variable after evaluating it) and a common naming convention of using "+" to indicate an enhanced computer program. There is no language called "C plus". ABCL/c+ was the name of an earlier, unrelated programming language.

Philosophy

In The Design and Evolution of C++ (1994), Bjarne Stroustrup describes some rules that he uses for the design of C++:
C++ is designed to be a statically typed, general-purpose language that is as efficient and portable as C
C++ is designed to directly and comprehensively support multiple programming styles (procedural programming, data abstraction, object-oriented programming, and generic programming)
C++ is designed to give the programmer choice, even if this makes it possible for the programmer to choose incorrectly
C++ is designed to be as compatible with C as possible, therefore providing a smooth transition from C
C++ avoids features that are platform specific or not general purpose
C++ does not incur overhead for features that are not used (the "zero-overhead principle")
C++ is designed to function without a sophisticated programming environment
Inside the C++ Object Model (Lippman, 1996) describes how compilers may convert C++ program statements into an in-memory layout. Compiler authors are; however, free to implement the standard in their own manner.
Standard library

The 1998 ANSI/ISO C++ standard consists of two parts: the core language and the C++ standard library; the latter includes most of the Standard Template Library (STL) and a slightly modified version of the C standard library. Many C++ libraries exist which are not part of the standard, and, using linkage specification, libraries can even be written in languages such as C, Fortran, Pascal, or BASIC. Which of these are supported is compiler dependent.
The C++ standard library incorporates the C standard library with some small modifications to make it work better with the C++ language. Another large part of the C++ library is based on the STL. This provides such useful tools as containers (for example vectors and lists), iterators to provide these containers with array-like access and algorithms to perform operations such as searching and sorting. Furthermore (multi)maps (associative arrays) and (multi)sets are provided, all of which export compatible interfaces. Therefore it is possible, using templates, to write generic algorithms that work with any container or on any sequence defined by iterators. As in C, the features of the library are accessed by using the #include directive to include a standard header. C++ provides 69 standard headers, of which 19 are deprecated.
The STL was originally a third-party library from HP and later SGI, before its incorporation into the C++ standard. The standard does not refer to it as "STL", as it is merely a part of the standard library, but many people still use that term to distinguish it from the rest of the library (input/output streams, internationalization, diagnostics, the C library subset, etc.).
Most C++ compilers provide an implementation of the C++ standard library, including the STL. Compiler-independent implementations of the STL, such as STLPort, also exist. Other projects also produce various custom implementations of the C++ standard library and the STL with various design goals.

Your Ad Here

Hello world program

The following is a Hello world program which uses the C++ standard library stream facility to write a message to standard output
#include // provides std::cout

int main()
{
std::cout << "Hello, world!\n";

}

Language features C++ inherits most of C's syntax and the C preprocessor. Operators and operator overloading C++ provides more than 30 operators, covering basic arithmetic, bit manipulation, indirection, comparisons, logical operations and more. Almost all operators can be overloaded for user-defined types, with a few notable exceptions such as member access (. and .*). The rich set of overloadable operators is central to using C++ as a domain specific language. As a simple example, a class that represents a matrix could overload the multiplication (*) and other arithmetic operators, allowing it to be treated by application code similarly to the standard numerical types.: matrix A, B; matrix C = A * B; The overloadable operators are also an essential part of many advanced C++ programming techniques, such as smart pointers. Overloading an operator does not change the precedence of calculations involving the operator, nor does it change the number of operands that the operator uses (any operand may however be ignored). Templates C++ templates enable generic programming. C++ supports function and class templates. C++ templates are implemented by expansion : at compile-time, there is a complete expansion of the function or class template. Template expansion is a very powerful concept that can lead to optimized code, and to policy-based template metaprogramming. However, with this power there is also a cost. The expansion may increase code size, since for each type using the template at compile time, a duplicate of the templatized code is made: one copy for each type. This is in contrast to template type erasure seen in other languages (e.g. Java) where at compile-time the type is erased and a single template body is preserved. Templates are different from macros: while both of these compile-time language features enable conditional compilation, templates are not restricted to lexical substitution. Templates are aware of the semantics and type system of their companion language, as well as all compile-time type definitions, and can perform high-level operations including programmatic flow control based on evaluation of strictly type-checked parameters. Macros are capable of conditional control over compilation based on predetermined criteria but cannot instantiate new types, recurse, or perform type evaluation and in effect are limited to pre-compilation text-substitution and text-inclusion/exclusion. In other words, macros can control compilation flow based on pre-defined symbols but cannot, unlike templates, independently instantiate new symbols. Templates are a tool for static polymorphism (see below) and generic programming. For example, a template replacing the common, but ill-advised, macro #define max(x,y) ((x)>(y)?(x):(y)):
template
const T& max(const T& x, const T& y)
{
return x <>

}

This can be found in the algorithm header as std::max(). Traditionally the keyword class may also be used in place of typename. In addition, templates are a compile time mechanism in C++ which is Turing-complete, meaning that any computation expressible by a computer program can be computed, in some form, by a template metaprogram prior to runtime. In summary, defining a template for a function or class is the equivalent of defining a function or class for each type that can be used as an argument, but does not require prior knowledge of which types will be used . Objects C++ introduces object-oriented (OO) features to C. It offers classes, which provide the four features commonly present in OO (and some non-OO) languages: abstraction, encapsulation, inheritance and polymorphism. Objects are instances of classes created at runtime. Think of the class as a template from which many different individual objects may be generated as a program runs. Encapsulation Encapsulation is the grouping together of data and functionality. C++ implements encapsulation by allowing all members of a class to be declared as either public, private, or protected. A public member of the class is accessible to any function. A private member is accessible only to functions that are members of that class and to functions and classes explicitly granted access permission by the class ("friends"). A protected member is accessible to members of classes that inherit from the class in addition to the class itself and any friends. The OO principle is that all of the functions (and only the functions) that access the internal representation of a type should be encapsulated within the type definition. C++ supports this (via member functions and friend functions), but does not enforce it: the programmer can declare parts or all of the representation of a type to be public, and is also allowed to make public entities that are not part of the representation of the type. Because of this, C++ supports not just OO programming but other weaker decomposition paradigms, like modular programming. It is generally considered good practice to make all data private or protected, and to make public only those functions that are part of a minimal interface for users of the class. This hides all the details of data implementation, allowing the designer to later fundamentally change the implementation without changing the interface in any way. Inheritance Inheritance allows one data type to acquire properties of other data types. Inheritance from a base class may be declared as public, protected, or private. This access specifier determines whether unrelated and derived classes can access the inherited public and protected members of the base class. Only public inheritance corresponds to what is usually meant by "inheritance". The other two forms are much less frequently used. If the access specifier is omitted, inheritance is assumed to be private for a class base and public for a struct base. Base classes may be declared as virtual; this is called virtual inheritance. Virtual inheritance ensures that only one instance of a base class exists in the inheritance graph, avoiding some of the ambiguity problems of multiple inheritance. Multiple inheritance is a C++ feature sometimes considered controversial. Multiple inheritance allows a class to be derived from more than one base class; this can result in a complicated graph of inheritance relationships. For example, a "Flying Cat" class can inherit from both "Cat" and "Flying Mammal". Some other languages, such as Java or C#, accomplish something similar (although more limited) by allowing inheritance of multiple interfaces while restricting the number of base classes to one (interfaces, unlike classes, provide only declarations of member functions, no implementation or member data). Polymorphism Polymorphism enables one common interface for many implementations, and for objects to act differently under different circumstances. C++ supports several kinds of static (compile-time) and dynamic (run-time) polymorphism. Compile-time polymorphism does not allow for certain run-time decisions, while run-time polymorphism typically incurs a performance penalty. Static polymorphism Function overloading Function overloading allows programs to declare multiple functions having the same name (but with different arguments). The functions are distinguished by the number and/or types of their formal parameters. Thus, the same function name can refer to different functions depending on the context in which it is used. The type returned by the function is not used to distinguish overloaded functions. Default arguments When declaring a function, a programmer can specify default arguments for one or more parameters. Doing so allows the parameters with defaults to optionally be omitted when the function is called, in which case the default arguments will be used. When a function is called with fewer arguments than there are declared parameters, explicit arguments are matched to parameters in left-to-right order, with any unmatched parameters at the end of the parameter list being assigned their default arguments. In many cases, specifying default arguments in a single function declaration is preferable to providing overloaded function definitions with different numbers of parameters. Class and function templates Templates in C++ provide a sophisticated mechanism for writing generic, polymorphic code. In particular, through the Curiously Recurring Template Pattern it's possible to implement a form of static polymorphism that closely mimics the syntax for overriding virtual functions (a dynamic polymorphism technique described below). Since C++ templates are type-aware and Turing-complete they can also be used to let the compiler resolve recursive conditionals and generate substantial programs through template metaprogramming. Dynamic polymorphism Inheritance Variable pointers (and references) to a base class type in C++ can refer to objects of any derived classes of that type in addition to objects exactly matching the variable type. This allows arrays and other kinds of containers to hold pointers to objects of differing types. Because assignment of values to variables usually occurs at run-time, this is necessarily a run-time phenomenon. C++ also provides a dynamic_cast operator, which allows the program to safely attempt conversion of an object into an object of a more specific object type (as opposed to conversion to a more general type, which is always allowed). This feature relies on run-time type information (RTTI). Objects known to be of a certain specific type can also be cast to that type with static_cast, a purely compile-time construct which is faster and does not require RTTI. Virtual member functions Ordinarily when a function in a derived class overrides a function in a base class, the function to call is determined by the type of the object. A given function is overridden when there exists no difference, in the number or type of parameters, between two or more definitions of that function. Hence, at compile time it may not be possible to determine the type of the object and therefore the correct function to call, given only a base class pointer; the decision is therefore put off until runtime. This is called dynamic dispatch. Virtual member functions or methods allow the most specific implementation of the function to be called, according to the actual run-time type of the object. In C++, this is commonly done using virtual function tables. If the object type is known, this may be bypassed by prepending a fully qualified class name before the function call, but in general calls to virtual functions are resolved at run time. In addition to standard member functions, operator overloads and destructors can also be virtual. A general rule of thumb is that if any functions in the class are virtual, the destructor should be as well. As the type of an object at its creation is known at compile time, constructors, and by extension copy constructors, can not be virtual. Nonetheless a situation may arise where a copy of an object needs to be created when a pointer to a derived object is passed as a pointer to a base object. In such a case a common solution is to create a Clone() (or similar) function and declare that as virtual. The Clone() method creates and returns a copy of the derived class when called. A member function can also be made "pure virtual" by appending it with = 0 after the closing bracket and before the semicolon. Objects can not be created of a class with a pure virtual function and are called abstract data types. Such abstract data types can only be derived from. Any derived class inherits the virtual function as pure and must override it (and all other pure virtual functions) with a non-pure virtual function for objects to be created from the derived class. An attempt to create an object from a class with a pure virtual function or inherited pure virtual function will be flagged as a compile-time error. An example:

#include

class Bird // the "generic" base class
{
public:
virtual void OutputName() {std::cout << "a bird";} virtual ~Bird() {} }; class Swan : public Bird // Swan derives from Bird { public: void OutputName() {std::cout << "a swan";} // overrides virtual function }; int main() { Swan mySwan; // Creates a swan. Bird* myBird = &mySwan; // Declares a pointer to a generic Bird, // and sets it pointing to a newly created Swan. myBird->OutputName(); // This will output "a swan", not "a bird".

return 0;
}
This example program makes use of virtual functions, polymorphism, and inheritance to derive new, more specific objects from a base class. In this case, the base class is a Bird, and the more specific Swan is made.
Parsing and processing C++ source code

It is relatively difficult to write a good C++ parser with classic parsing algorithms such as LALR(1). This is partly because the C++ grammar is not LALR. Because of this, there are very few tools for analyzing or performing non-trivial transformations (e.g., refactoring) of existing code. One way to handle this difficulty is to choose a different syntax, such as Significantly Prettier and Easier C++ Syntax, which is LALR(1) parsable. More powerful parsers, such as GLR parsers, can be substantially simpler (though slower).
Parsing (in the literal sense of producing a syntax tree) is not the most difficult problem in building a C++ processing tool. Such tools must also have the same understanding of the meaning of the identifiers in the program as a compiler might have. Practical systems for processing C++ must then not only parse the source text, but be able to resolve for each identifier precisely which definition applies (e.g. they must correctly handle C++'s complex scoping rules) and what its type is, as well as the types of larger expressions.
Finally, a practical C++ processing tool must be able to handle the variety of C++ dialects used in practice (such as that supported by the GNU Compiler Collection and that of Microsoft's Visual C++) and implement appropriate analyzers, source code transformers, and regenerate source text. Combining advanced parsing algorithms such as GLR with symbol table construction and program transformation machinery can enable the construction of arbitrary C++ tools.

Problems and controversies

Standards compliance

Producing a reasonably standards-compliant C++ compiler has proven to be a difficult task for compiler vendors in general. For many years, different C++ compilers implemented the C++ language to different levels of compliance to the standard, and their implementations varied widely in some areas such as partial template specialization. Recent releases of most popular C++ compilers support almost all of the C++ 1998 standard. One particular point of contention is the export keyword, intended to allow template definitions to be separated from their declarations. The first compiler to implement export was Comeau C/C++, in early 2003 (5 years after the release of the standard); in 2004, the beta compiler of Borland C++ Builder X was also released with export. Both of these compilers are based on the EDG C++ front end. It should also be noted that many C++ books provide example code using the keyword export (for example, Beginning ANSI C++ by Ivor Horton) which will not compile in most compilers, but there is no reference to the problem with the keyword export mentioned. Other compilers such as GCC do not support it at all. Herb Sutter, secretary of the C++ standards committee, recommended that export be removed from future versions of the C++ standard, but finally the decision was made to retain it.
In order to give compiler vendors greater freedom, the C++ standards committee decided not to dictate the implementation of name mangling, exception handling, and other implementation-specific features. The downside of this decision is that object code produced by different compilers is expected to be incompatible. There are, however, third party standards for particular machines or operating systems which attempt to standardize compilers on those platforms (for example C++ ABI; some compilers adopt a secondary standard for these items.
Criticism

Modern critics of the language raise several points. First, since C++ is based on and largely compatible with C, it inherits most of the criticisms leveled at that language. Taken as a whole, C++ has a large feature set, including all of C, plus a large set of its own additions, in part leading to criticisms of being a "bloated" and complicated language. Bjarne Stroustrup points out that resultant executables don't support these claims of bloat: "I have even seen the C++ version of the 'hello world' program smaller than the C version." The Embedded C++ standard was specified to deal with part of this, but it received criticism for leaving out useful parts of the language that incur no runtime penalty Because of its large feature set, it can be quite difficult to fully master C++.
While C++ is more complex than some other programming languages, Bjarne Stroustrup points out that "The programming world is far more complex today than it was 30 years ago, and modern programming languages reflect that." The ISO standard of the C++ language is about 310 pages (excluding library). For comparison, the C programming language's is about 160 pages, even though it was designed more than 15 years prior and doesn't consider object-oriented programming.
Other criticism stems from what is missing from C++. For example, the current version of Standard C++ provides no language features to create multi-threaded software other than the volatile keyword. (The next version of C++ will introduce the thread_local keyword.) These facilities are present in some other languages including Java, Ada, and C# (see also Lock). It is possible to use operating system calls or third party libraries to do multi-threaded programming, but both approaches may create portability concerns.
C++ is also sometimes compared unfavorably with single-paradigm object-oriented languages such as Java, on the basis that it allows programmers to "mix and match" object-oriented and procedural programming, rather than strictly enforcing a single paradigm. This is part of a wider debate on the relative merits of the two programming styles.
Incompatibility with C

C++ is often considered to be a superset of C, but this is not strictly true. Most C code can easily be made to compile correctly in C++, but there are a few differences that cause some valid C code to be invalid in C++, or to behave differently in C++.
One commonly encountered difference is that C allows implicit conversion from void* to other pointer types, but C++ does not. So, the following is valid C code:
int *i = malloc(sizeof(int) * 5); /* Implicit conversion from void* to int* */

... but to make it work in both C and C++ one would need to use an explicit cast:
int *i = (int *) malloc(sizeof(int) * 5);

...and in C++-only code, the static cast is recommended:
int *i = static_cast(malloc(sizeof(int) * 5));

In this common case, for C++-only code the issue can be avoided completely by switching from malloc to new:
int *i = new int[5];

C++ also makes a small change in the behavior of the conditional operator. Consider:
// The interpretation of the following expression is different in C and C++
flag ? a=2 : a=3;

// In C the precedence of ?: is strictly higher than all assignment operators
// so the equation is grouped as follows, because ?: beats =
(flag ? (a=2) : a) = 3;

// The C++ grammar allows an assignment as the else-part, so it's interpreted as:
( flag ? (a=2) : (a=3) );

So in essence, the "?" and ":" operators have different precedence levels in C++, the "?" placed higher than assignment operators, and the ":" is lower.
Another common portability issue is that C++ defines many new keywords, such as new and class, that may be used as identifiers (e.g. variable names) in a C program.
Some incompatibilities have been removed by the latest (C99) C standard, which now supports C++ features such as // comments and mixed declarations and code. However, C99 introduced a number of new features that C++ does not support (such as variable-length arrays, native complex-number types, and compound literals), so the languages may be diverging more than they are converging. However, at least some of the new C99 features will likely be included in the next version of the C++ standard, C++0x.
In order to intermix C and C++ code, any function declaration or definition, which is to be called from/used both in C and C++ must be declared with C linkage by placing it within an extern "C" { ... } block. Such function may not rely on features depending on name mangling (i.e., function overloading).

Your Ad Here

Programming language

2008-06-22T10:19:00.000-07:00

Programming Language

A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer. Programming languages are defined by syntactic and semantic rules which describe their structure and meaning respectively. Many programming languages have some form of written specification of their syntax and semantics; some are defined only by an official implementation. Python and batch are not programming languages.
Programming languages are used to facilitate communication about the task of organizing and manipulating information, and to express algorithms precisely. Some authors restrict the term "programming language" to those languages that can express all possible algorithms; sometimes the term "computer language" is used for more limited artificial languages.

Thousands of different programming languages have been created, and new languages are created every year.
Contents
1 Definitions
2 Purpose
3 Elements
3.1 Syntax
3.2 Static semantics
3.3 Type system
3.3.1 Typed versus untyped languages
3.3.2 Static versus dynamic typing
3.3.3 Weak and strong typing
3.4 Execution semantics
3.5 Core library
4 Practice
4.1 Specification
4.2 Implementation
5 History
5.1 Early developments
5.2 Refinement
5.3 Consolidation and growth

5.4 Measuring language usage
6 Taxonomies
Definitions

Traits often considered important for constituting a programming language:
Function: A programming language is a language used to write computer programs, which involve a computer performing some kind of computation or algorithm and possibly control external devices such as printers, robots, and so on.
Target: Programming languages differ from natural languages in that natural languages are only used for interaction between people, while programming languages also allow humans to communicate instructions to machines. Some programming languages are used by one device to control another. For example PostScript programs are frequently created by another program to control a computer printer or display.
Constructs: Programming languages may contain constructs for defining and manipulating data structures or controlling the flow of execution.
Expressive power: The theory of computation classifies languages by the computations they can express (see Chomsky hierarchy). All Turing complete languages can implement the same set of algorithms. ANSI/ISO SQL and Charity are examples of languages that are not Turing complete yet often called programming languages.
Non-computational languages, such as markup languages like HTML or formal grammars like BNF, are usually not considered programming languages. Often a programming language is embedded in the non-computational (host) language.
Purpose

A prominent purpose of programming languages is to provide instructions to a computer. As such, programming languages differ from most other forms of human expression in that they require a greater degree of precision and completeness. When using a natural language to communicate with other people, human authors and speakers can be ambiguous and make small errors, and still expect their intent to be understood. However, computers do exactly what they are told to do, and cannot understand the code the programmer "intended" to write. The combination of the language definition, the program, and the program's inputs must fully specify the external behavior that occurs when the program is executed.
Many languages have been designed from scratch, altered to meet new needs, combined with other languages, and eventually fallen into disuse. Although there have been attempts to design one "universal" computer language that serves all purposes, all of them have failed to be accepted in this role. The need for diverse computer languages arises from the diversity of contexts in which languages are used:
Programs range from tiny scripts written by individual hobbyists to huge systems written by hundreds of programmers.
Programmers range in expertise from novices who need simplicity above all else, to experts who may be comfortable with considerable complexity.
Programs must balance speed, size, and simplicity on systems ranging from microcontrollers to supercomputers.
Programs may be written once and not change for generations, or they may undergo nearly constant modification.
Finally, programmers may simply differ in their tastes: they may be accustomed to discussing problems and expressing them in a particular language.
One common trend in the development of programming languages has been to add more ability to solve problems using a higher level of abstraction. The earliest programming languages were tied very closely to the underlying hardware of the computer. As new programming languages have developed, features have been added that let programmers express ideas that are more removed from simple translation into underlying hardware instructions. Because programmers are less tied to the needs of the computer, their programs can do more computing with less effort from the programmer. This lets them write more programs in the same amount of time.
Natural language processors have been proposed as a way to eliminate the need for a specialized language for programming. However, this goal remains distant and its benefits are open to debate. Edsger Dijkstra took the position that the use of a formal language is essential to prevent the introduction of meaningless constructs, and dismissed natural language programming as "foolish." Alan Perlis was similarly dismissive of the idea.
Elements

Syntax
Parse tree of Python code with inset tokenization
Syntax highlighting is often used to aid programmers in recognizing elements of source code. The language above is Python.
A programming language's surface form is known as its syntax. Most programming languages are purely textual; they use sequences of text including words, numbers, and punctuation, much like written natural languages. On the other hand, there are some programming languages which are more graphical in nature, using spatial relationships between symbols to specify a program.
The syntax of a language describes the possible combinations of symbols that form a syntactically correct program. The meaning given to a combination of symbols is handled by semantics. Since most languages are textual, this article discusses textual syntax.
Programming language syntax is usually defined using a combination of regular expressions (for lexical structure) and Backus-Naur Form (for grammatical structure). Below is a simple grammar, based on Lisp:
expression ::= atom listatom ::= number symbolnumber ::= [+-]?['0'-'9']+symbol ::= ['A'-'Z''a'-'z'].*list ::= '(' expression* ')'
This grammar specifies the following:
an expression is either an atom or a list;
an atom is either a number or a symbol;
a number is an unbroken sequence of one or more decimal digits, optionally preceded by a plus or minus sign;
a symbol is a letter followed by zero or more of any characters (excluding whitespace); and
a list is a matched pair of parentheses, with zero or more expressions inside it.
The following are examples of well-formed token sequences in this grammar: '12345', '()', '(a b c232 (1))'
Not all syntactically correct programs are semantically correct. Many syntactically correct programs are nonetheless ill-formed, per the language's rules; and may (depending on the language specification and the soundness of the implementation) result in an error on translation or execution. In some cases, such programs may exhibit undefined behavior. Even when a program is well-defined within a language, it may still have a meaning that is not intended by the person who wrote it.
Using natural language as an example, it may not be possible to assign a meaning to a grammatically correct sentence or the sentence may be false:
"Colorless green ideas sleep furiously." is grammatically well-formed but has no generally accepted meaning.
"John is a married bachelor." is grammatically well-formed but expresses a meaning that cannot be true.
The following C language fragment is syntactically correct, but performs an operation that is not semantically defined (because p is a null pointer, the operations p->real and p->im have no meaning):
complex *p = NULL;
complex abs_p = sqrt (p->real * p->real + p->im * p->im);

The grammar needed to specify a programming language can be classified by its position in the Chomsky hierarchy. The syntax of most programming languages can be specified using a Type-2 grammar, i.e., they are context-free grammars.
Static semantics
The static semantics defines restrictions on the structure of valid texts that are hard or impossible to express in standard syntactic formalisms. The most important of these restrictions are covered by type systems.
Type system
A type system defines how a programming language classifies values and expressions into types, how it can manipulate those types and how they interact. This generally includes a description of the data structures that can be constructed in the language. The design and study of type systems using formal mathematics is known as type theory.
Internally, all data in modern digital computers are stored simply as zeros or ones (binary).
Typed versus untyped languages
A language is typed if the specification of every operation defines types of data to which the operation is applicable, with the implication that it is not applicable to other types. For example, "this text between the quotes" is a string. In most programming languages, dividing a number by a string has no meaning. Most modern programming languages will therefore reject any program attempting to perform such an operation. In some languages, the meaningless operation will be detected when the program is compiled ("static" type checking), and rejected by the compiler, while in others, it will be detected when the program is run ("dynamic" type checking), resulting in a runtime exception.
A special case of typed languages are the single-type languages. These are often scripting or markup languages, such as Rexx or SGML, and have only one data type — most commonly character strings which are used for both symbolic and numeric data.
In contrast, an untyped language, such as most assembly languages, allows any operation to be performed on any data, which are generally considered to be sequences of bits of various lengths. High-level languages which are untyped include BCPL and some varieties of Forth.
In practice, while few languages are considered typed from the point of view of type theory (verifying or rejecting all operations), most modern languages offer a degree of typing. Many production languages provide means to bypass or subvert the type system.
Static versus dynamic typing
In static typing all expressions have their types determined prior to the program being run (typically at compile-time). For example, 1 and (2+2) are integer expressions; they cannot be passed to a function that expects a string, or stored in a variable that is defined to hold dates.
Statically-typed languages can be manifestly typed or type-inferred. In the first case, the programmer must explicitly write types at certain textual positions (for example, at variable declarations). In the second case, the compiler infers the types of expressions and declarations based on context. Most mainstream statically-typed languages, such as C++, C# and Java, are manifestly typed. Complete type inference has traditionally been associated with less mainstream languages, such as Haskell and ML. However, many manifestly typed languages support partial type inference; for example, Java and C# both infer types in certain limited cases. Dynamic typing, also called latent typing, determines the type-safety of operations at runtime; in other words, types are associated with runtime values rather than textual expressions. As with type-inferred languages, dynamically typed languages do not require the programmer to write explicit type annotations on expressions. Among other things, this may permit a single variable to refer to values of different types at different points in the program execution. However, type errors cannot be automatically detected until a piece of code is actually executed, making debugging more difficult. Ruby, Lisp, JavaScript, and Python are dynamically typed.
Weak and strong typing
Weak typing allows a value of one type to be treated as another, for example treating a string as a number. This can occasionally be useful, but it can also allow some kinds of program faults to go undetected at compile time and even at run time.
Strong typing prevents the above. An attempt to perform an operation on the wrong type of value raises an error. Strongly-typed languages are often termed type-safe or safe.
An alternative definition for "weakly typed" refers to languages, such as Perl, JavaScript, and C++, which permit a large number of implicit type conversions. In JavaScript, for example, the expression 2 * x implicitly converts x to a number, and this conversion succeeds even if x is null, undefined, an Array, or a string of letters. Such implicit conversions are often useful, but they can mask programming errors.
Strong and static are now generally considered orthogonal concepts, but usage in the literature differs. Some use the term strongly typed to mean strongly, statically typed, or, even more confusingly, to mean simply statically typed. Thus C has been called both strongly typed and weakly, statically typed.
Execution semantics
Once data has been specified, the machine must be instructed to perform operations on the data. The execution semantics of a language defines how and when the various constructs of a language should produce a program behavior.
For example, the semantics may define the strategy by which expressions are evaluated to values, or the manner in which control structures conditionally execute statements.
Core library
.
Most programming languages have an associated core library (sometimes known as the 'Standard library', especially if it is included as part of the published language standard), which is conventionally made available by all implementations of the language. Core libraries typically include definitions for commonly used algorithms, data structures, and mechanisms for input and output.
A language's core library is often treated as part of the language by its users, although the designers may have treated it as a separate entity. Many language specifications define a core that must be made available in all implementations, and in the case of standardized languages this core library may be required. The line between a language and its core library therefore differs from language to language. Indeed, some languages are designed so that the meanings of certain syntactic constructs cannot even be described without referring to the core library. For example, in Java, a string literal is defined as an instance of the java.lang.String class; similarly, in Smalltalk, an anonymous function expression (a "block") constructs an instance of the library's BlockContext class. Conversely, Scheme contains multiple coherent subsets that suffice to construct the rest of the language as library macros, and so the language designers do not even bother to say which portions of the language must be implemented as language constructs, and which must be implemented as parts of a library.

Pratice

A language's designers and users must construct a number of artifacts that govern and enable the practice of programming. The most important of these artifacts are the language specification and implementation.
Specification
The specification of a programming language is intended to provide a definition that language users and implementors can use to determine the behavior of a program, given its source code.
A programming language specification can take several forms, including the following:
An explicit definition of the syntax, static semantics, and execution semantics of the language. While syntax is commonly specified using a formal grammar, semantic definitions may be written in natural language (e.g., the C language), or a formal semantics (e.g., the Standard ML and Scheme specifications).
A description of the behavior of a translator for the language (e.g., the C++ and Fortran specifications). The syntax and semantics of the language have to be inferred from this description, which may be written in natural or a formal language.
A reference or model implementation, sometimes written in the language being specified (e.g., Prolog or ANSI REXX). The syntax and semantics of the language are explicit in the behavior of the reference implementation.
Implementation
.
An implementation of a programming language provides a way to execute that program on one or more configurations of hardware and software. There are, broadly, two approaches to programming language implementation: compilation and interpretation. It is generally possible to implement a language using either technique.
The output of a compiler may be executed by hardware or a program called an interpreter. In some implementations that make use of the interpreter approach there is no distinct boundary between compiling and interpreting. For instance, some implementations of the BASIC programming language compile and then execute the source a line at a time.
Programs that are executed directly on the hardware usually run several orders of magnitude faster than those that are interpreted in software.
One technique for improving the performance of interpreted programs is just-in-time compilation. Here the virtual machine monitors which sequences of bytecode are frequently executed and translates them to machine code for direct execution on the hardware.
History

A selection of textbooks that teach programming, in languages both popular and obscure. These are only a few of the thousands of programming languages and dialects that have been designed in history.
.
Early developments
The first programming languages predate the modern computer. The 19th century had "programmable" looms and player piano scrolls which implemented what are today recognized as examples of domain-specific programming languages. By the beginning of the twentieth century, punch cards encoded data and directed mechanical processing. In the 1930s and 1940s, the formalisms of Alonzo Church's lambda calculus and Alan Turing's Turing machines provided mathematical abstractions for expressing algorithms; the lambda calculus remains influential in language design. In the 1940s, the first electrically powered digital computers were created. The computers of the early 1950s, notably the UNIVAC I and the IBM 701 used machine language programs. First generation machine language programming was quickly superseded by a second generation of programming languages known as Assembly languages. Later in the 1950s, assembly language programming, which had evolved to include the use of macro instructions, was followed by the development of three higher-level programming languages: FORTRAN, LISP, and COBOL. Updated versions of all of these are still in general use, and importantly, each has strongly influenced the development of later languages. At the end of the 1950s, the language formalized as Algol 60 was introduced, and most later programming languages are, in many respects, descendants of Algol. The format and use of the early programming languages was heavily influenced by the constraints of the interface.
Refinement
The period from the 1960s to the late 1970s brought the development of the major language paradigms now in use, though many aspects were refinements of ideas in the very first Third-generation programming languages:
APL introduced array programming and influenced functional programming.
PL/I (NPL) was designed in the early 1960s to incorporate the best ideas from FORTRAN and COBOL.
In the 1960s, Simula was the first language designed to support object-oriented programming; in the mid-1970s, Smalltalk followed with the first "purely" object-oriented language.
C was developed between 1969 and 1973 as a systems programming language, and remains popular.
Prolog, designed in 1972, was the first logic programming language.
In 1978, ML built a polymorphic type system on top of Lisp, pioneering statically typed functional programming languages. Each of these languages spawned an entire family of descendants, and most modern languages count at least one of them in their ancestry.
The 1960s and 1970s also saw considerable debate over the merits of structured programming, and whether programming languages should be designed to support it.
Edsger Dijkstra, in a famous 1968 letter published in the Communications of the ACM, argued that GOTO statements should be eliminated from all "higher level" programming languages. The 1960s and 1970s also saw expansion of techniques that reduced the footprint of a program as well as improved productivity of the programmer and user. The card deck for an early 4GL was a lot smaller for the same functionality expressed in a 3GL deck.
Consolidation and growth
The 1980s were years of relative consolidation. C++ combined object-oriented and systems programming. The United States government standardized Ada, a systems programming language intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called "fifth generation" languages that incorporated logic programming constructs. The functional languages community moved to standardize ML and Lisp. Rather than inventing new paradigms, all of these movements elaborated upon the ideas invented in the previous decade.
One important trend in language design during the 1980s was an increased focus on programming for large-scale systems through the use of modules, or large-scale organizational units of code. Modula-2, Ada, and ML all developed notable module systems in the 1980s, although other languages, such as PL/I, already had extensive support for modular programming. Module systems were often wedded to generic programming constructs.
The rapid growth of the Internet in the mid-1990's created opportunities for new languages. Perl, originally a Unix scripting tool first released in 1987, became common in dynamic Web sites. Java came to be used for server-side programming. These developments were not fundamentally novel, rather they were refinements to existing languages and paradigms, and largely based on the C family of programming languages.
Programming language evolution continues, in both industry and research. Current directions include security and reliability verification, new kinds of modularity (mixins, delegates, aspects), and database integration The 4GLs are examples of languages which are domain-specific, such as SQL, which manipulates and returns sets of data rather than the scalar values which are canonical to most programming languages. Perl, for example, with its 'here document' can hold multiple 4GL programs, as well as multiple JavaScript programs, in part of its own perl code and use variable interpolation in the 'here document' to support multi-language programming.
Measuring language usage
It is difficult to determine which programming languages are most widely used, and what usage means varies by context. One language may occupy the greater number of programmer hours, a different one have more lines of code, and a third utilize the most CPU time. Some languages are very popular for particular kinds of applications. For example, COBOL is still strong in the corporate data center, often on large mainframes; FORTRAN in engineering applications; C in embedded applications and operating systems; and other languages are regularly used to write many different kinds of applications.
Various methods of measuring language popularity, each subject to a different bias over what is measured, have been proposed:
counting the number of job advertisements that mention the language
the number of books sold that teach or describe the language
estimates of the number of existing lines of code written in the language—which may underestimate languages not often found in public searches
counts of language references found using a web search engine.
There is no overarching classification scheme for programming languages. A given programming language does not usually have a single ancestor language. Languages commonly arise by combining the elements of several predecessor languages with new ideas in circulation at the time. Ideas that originate in one language will diffuse throughout a family of related languages, and then leap suddenly across familial gaps to appear in an entirely different family.
Taxonomies

The task is further complicated by the fact that languages can be classified along multiple axes. For example, Java is both an object-oriented language (because it encourages object-oriented organization) and a concurrent language (because it contains built-in constructs for running multiple threads in parallel). Python is an object-oriented scripting language.
In broad strokes, programming languages divide into programming paradigms and a classification by intended domain of use. Paradigms include procedural programming, object-oriented programming, functional programming, and logic programming; some languages are hybrids of paradigms or multi-paradigmatic. An assembly language is not so much a paradigm as a direct model of an underlying machine architecture. By purpose, programming languages might be considered general purpose, system programming languages, scripting languages, domain-specific languages, or concurrent/distributed languages (or a combination of these). Some general purpose languages were designed largely with educational goals.
A programming language may also be classified by factors unrelated to programming paradigm. For instance, most programming languages use English language keywords, while a minority do not. Other languages may be classified as being esoteric or not.

The Complete information About DFD

2008-06-20T10:16:00.000-07:00

Data flow diagram example
A data flow diagram (DFD) is a graphical representation of the "flow" of data through an information system. A data flow diagram can also be used for the visualization of data processing (structured design). It is common practice for a designer to draw a context-level DFD first which shows the interaction between the system and outside entities. This context-level DFD is then "exploded" to show more detail of the system being modeled.
Data flow diagrams were invented by Larry Constantine, the original developer of structured design, based on Martin and Estrin's "data flow graph" model of computation. Data flow diagrams (DFDs) are one of the three essential perspectives of Structured Systems Analysis and Design Method SSADM. The sponsor of a project and the end users will need to be briefed and consulted throughout all stages of a system's evolution. With a dataflow diagram, users are able to visualize how the system will operate, what the system will accomplish, and how the system will be implemented. The old system's dataflow diagrams can be drawn up and compared with the new system's dataflow diagrams to draw comparisons to implement a more efficient system. Dataflow diagrams can be used to provide the end user with a physical idea of where the data they input ultimately has an effect upon the structure of the whole system from order to dispatch to restock. How any system is developed can be determined through a dataflow diagram.
Developing a DFD helps in identifying the transaction data in the data model.
There are different notations to draw data flow diagrams, defining different visual representations for processes, datastores, dataflow, and external entities.

Developing a DFD

1.1 Elements of a DFD
1.2 Top-Down Approach
1.3 Event Partitioning Approach
DFD Levels
2.1 Context Level
2.2 Level 0
2.3 Level 1
DFD tools
3.1 DFD Tool

Developing a DFD

Elements of a DFD
There are 4 key elements in a Data Flow diagram, Processes, Data Flows, Data Stores & External entities.
The Process entity identifies a process taking place, it must have at least one input and output. A process with no input is known as a "miracle process"an output is a "black hole process". Each process has the following
A Number
A Name (verb phrase)
A Description
At least one input
At least one output
The Data Flow entity identifies the flow of data between processes, data stores & external entities. A data flow cannot connect an external entity to a data source, at least one connection must be with a process. There are also "physical" flows, i.e. those that use a physical medium, like a membership card. Each data flow has the following
A Name (Noun)
A Description
One or more connections to a process.
The Data Store entity identifies stores of data, both manual and electronic. Electronic or "digital" stores are identified by the letter D, and manual filing systems by the letter M, e.g. D1 could be a MySQL database, and M4 could be a filing cabinet. Each data store has the following
A Number
A Name
A Description
One or more input data flows.
One or more output data flows.
The External Entity identifies external entities which interacts with the system, usually clients but can be within the same organisation. Multiple existences of the same entity, e.g. the same doctor shown twice on the same diagram, can be identified by a horizontal line in the top left corner of the symbol. Each external entity has the following;
A Name (Noun)
A Description

Top-Down Approach
The system designer makes a context level DFD, which shows the interaction (data flows) between the system (represented by one process) and the system environment (represented by terminators).
The system is decomposed in lower level DFD (Zero) into a set of processes, data stores, and the data flows between these processes and data stores.# Each process is then decomposed into an even lower level diagram containing its subprocesses.
This approach then continues on the subsequent subprocesses, until a necessary and sufficient level of detail is reached which is called the primitive process (aka chewable in one bite).

Event Partitioning Approach
This approach was described by Edward Yourdon in Just Enough Structured Analysis.
Construct detailed DFD.
The list of all events is made.
For each event a process is constructed.
Each process is linked (with incoming data flows) directly with other processes or via datastores, so that it has enough information to respond to a given event.
The reaction of each process to a given event is modeled by an outgoing data flow.

DFD Levels

Context Level

A context level DFD created using Select SSADM.
This level shows the overall context of the system and it's operating environment and shows the whole system as just one process. It does not usually show data stores, unless they are "owned" by external systems, e.g. are accessed by but not maintained by this system, however, these are often shown as external entities.

Level 0

A Level 0 DFD for the same system.
This level shows all processes at the first level of numbering, data stores, external entities and the data flows between them. The purpose of this level is to show the major high level processes of the system and their interrelation. A process model will have one, and only one, level 0 diagram. A level 0 diagram must be balanced with it's parent context level diagram, i.e. there must be the same external entities and the same data flows, these can be broken down to more detail in the level 0, e.g. the "enquiry" data flow could be spilt into "enquiry request" and "enquiry results" and still be valid.

Level 1

A Level 1 DFD showing the "Process Enquiry" process for the same system.
This level is a decomposition of a process shown in a level 0 diagram, as such there should be a level 1 diagram for each and every process shown in a level 0 diagram. In this example processes 1.1, 1.2 & 1.3 are all children of process 1, together they wholly and completely describe process 1, and combined must perform the full capacity of this parent process. As before, a level 1 diagram must be balanced with it's parent level 0 diagram.

DFD tools

CA ERwin Data Modeler, a data modeling tool
ConceptDraw, a Windows and Mac OS X data flow diagramming tool
Dia, a free source diagramming tool with flowchart support
Kivio, a free source diagramming tool for KDE
Microsoft Visio, a Windows diagramming tool which includes very basic DFD support (Images only, does not record data flows)
SmartDraw, a Windows diagraming tool with Yourdon and Coad process notations and Gane and Sarson process notation
System Architect, an enterprise architecture tool, supporting Coad/Yourdon, Gane & Sarson, Ward/Mellor, and SSADM notations and techniques
DFDdeveloper, an open source software application that allows Microsoft Office users to create interactive leveled data flow diagrams and data dictionaries

Your Ad Here