Computer Technology

Troubleshooting-Repair Pendrive / Flashdrive/ External Hard drive

2014-12-12T11:07:00.000+05:30

Hello friends thanks for jumping in. Hope you are all fed up with the Pendrive /Flashdrive /External Hard drive when its not working properly. Here are the few solutions which will help you to come out of this problem. Cheer up!!!

Method 1:

Insert your Pendrive/Flashdrive/External Hard drive to the rear USB port. If you find the removable storage media is showing in My computer its well and good, if not come on don't worry follow the next method. Even after Showing the removable disk you are not able to open it, if you try so it will show Not responding in the My computer Title bar.

So in such situation we can find 2 alternative steps to format the Pendrive/Flashdrive/External Hard drive,

Step 1: open command prompt (press start button and type cmd or press widows button + R then type cmd Then command prompt will appear.

Make sure that you know your removable media name, whether it is E, F,G,N etc.if not check how many drive partition are there in my computer if 3 partition like C, D, E then the removable media will be F.

So type format f: (press enter) you can replace F by your removable media name.

Now press enter and wait until your drive will get formatted.

Method 2:

Insert your Pendrive /Flashdrive /External Hard drive at the rear USB port.

Go to control panel -> Administrative tools ->Computer management ->Disk management

(in windows 7 and higher versions you select small icons in view by drop down list at the right top corner of the control panel then follow Administrative tools ->Computer management ->Disk management)

Congrats!!! you are done :)

If not please revert back here..

How to increase Battery Life and reduce data usage in Android phones

2014-11-13T14:36:00.000+05:30

Now a day’s smart phones can be used for several purpose but we need to compromise with its battery life. Even though smart phone batteries are growing bigger every year, we're not seeing such a benefit because our Android devices are demanding more and more out of them.

Follow the simple ways to increase the battery life of your Android smart phone.

Use power saving mode

Most Android device manufacturers have added some form of power-saving mode in their smartphones. shut down specific apps when the battery dwindles below a predetermined level.

Android Lollipop has a battery saver option built in (which means most phones running Android 5 will too in the future). If you can't find a power saving option, check out an app like Juice Defender.

Automate your phone

You don't need your phone syncing away through the night, so why not introduce a bedtime routine that automatically silences it and kills your data and Wi-Fi connections? With apps like AutomateIt and Tasker, you can also automatically turn things on and off based on triggers and rules you define.

Uninstall or disable apps

Navigate to the Settings > Apps and flick over to the 'All' tab to find a complete list of your apps. Anything in the list that you don't use is a candidate for the uninstall pile. In their infinite wisdom, manufacturers sometimes block you from uninstalling their apps, but you usually have the option to disable them instead, and it's worth doing.

Hibernate or freeze apps

You may also consider installing Greenify to get a good look at what is running and automatically hibernate apps that you aren't using, so they aren't eating system resources unless you start them up.
You'll need to root your device to really take full advantage, which is simple enough but will take a little time to manage if you're new to the process. If you do decide to root then you may also consider Titanium Backup Pro for freezing unwanted apps.

Streamline your home screen

The busier your home screen, the more battery life it's going to suck. Get rid of widgets that you don't need, and consider reducing refresh rates. Animation costs power, so ditch the live wallpapers.

If you have a phone with an AMOLED display (such as nearly all of the high end Samsung Galaxy models or the new Moto X), then use a dark background for the home screen and a dark theme in general. The technology achieves deep blacks by not lighting up those pixels and so dark backgrounds can save you some power.

Tweak display settings

Your screen brightness is going to have a big impact on your battery. Don't rely on auto-brightness because it will generally be set higher than you really need. Reduce brightness manually and keep it as low as is comfortable. You can always pull down the notification shade and tweak it quickly via the quick settings when you have to.

You should also reduce the screen time out in display settings under sleep. The faster your Android device fades to black when not in use, the more power you'll save.

Turn off vibrations

When it comes to Android phones and tablets, vibrations can be an unnecessary battery killer. Fortunately, you can control it manually.

Start with haptic feedback for key presses. You'll usually find the option to turn 'Vibrate on keypress' off in Settings > Language & Input in the options for the keyboard you are using. You could also turn off 'Sound on Keypress' for extra saving.

You can also go into Settings > Sound and turn off 'Vibrate when Ringing'. You'll find a Vibrate option that you can turn off in your SMS app settings as well.

Turn off notifications

Do you need to know every time someone likes a post or comments on something you've engaged with on Facebook? Do you want to hear about the latest special offer or new app in your notification shade?

When you install any app, it automatically gains the right to fire notifications at you, but you can stop it in Settings > Apps by tapping on the app and clearing the 'Show Notifications' box.

Turn off GPS

Go to Settings > Location and you can see which services and apps are trying to track you. Switch the mode to lower accuracy or just turn it off and you can save a lot of power.

Under - clocking the CPU

If you're willing to root then you can sweep away bloatware and get an optimized custom ROM, you can even download an app like SetCPU for Root Users and tell your processor to run at a slower speed in order to use less power. It's an extreme step, but it definitely has an impact.

Bendable Smartphones

2013-04-30T11:36:00.000+05:30

Researchers, including an Indian origin scientist, have developed prototypes for gen-next shape-shifting smartphones and mobile devices that can change form on-demand. The research introduces the term 'shape resolution' and its ten features, to describe the resolution of an interactive device, in addition to display and touch resolution.

The research, led by Dr Anne Roudaut and Professor Sriram Subramanian, from the University of Bristol's Department of Computer Science, have used 'shape resolution' to compare the resolution of six prototypes the team have built using the latest technologies in shape changing material, such as shape memory alloy and electro active polymer.

One example of a device is the team's concept of Morphees, self-actuated flexible mobile devices that can change shape on-demand to better fit the many services they are likely to support.

The team believes Morphees will be the next generation of mobile devices, where users can download applications that embed a dedicated form factor, for instance the "stress ball app" that collapses the device in on itself or the "game app" that makes it adopt a console-like shape.

"The interesting thing about our work is that we are a step towards enabling our mobile devices to change shape on-demand," Roudaut, Research Assistant in the Department of Computer Science's Bristol Interaction and Graphics group, said. "Imagine downloading a game application on the app-store and that the mobile phone would shape-shift into a console-like shape in order to help the device to be grasped properly.

"The device could also transform into a sphere to serve as a stress ball, or bend itself to hide the screen when a password is being typed so passers-by can't see private information," said Roudaut.

By comparing the shape resolution of their prototypes, the researchers have created insights to help designers towards creating high shape resolution Morphees.

In future, the team hopes to build higher shape resolution Morphees by investigating the flexibility of materials. They are also interested in exploring other kinds of deformations that the prototypes did not explore, such as porosity and stretchability.

How To Turn Your Boring Old Laptop Into A Cool Touch Screen Machine

2013-02-08T14:21:00.004+05:30

Windows 8 - Microsoft's new touchscreen operating system - will run just fine on PCs designed for Windows 7. But you won't be able to take advantage of the new touch capabilities the OS enables unless you scrap your existing PC and upgrade to a new computer.

At the Consumer Electronics Show (CES) in Las Vegas, a company out of China demonstrated a peripheral that combines a stylus and either a USB or wireless receiver to touch-enable a non-touchscreen LCD monitor or laptop screen.

The technology has made its way to the United States via Shenzhen Yifang Digital Technology Co. Ltd., mercifully shortened to Yifang Digital, whose E Fun brand markets the APEN Touch8 system in the United States. Got that?

Discovering the Touch8 digitizer was a happy coincidence. Wandering though CES' maze of booths, you never quite know what you'll find. In the rear of the South Hall, for example, Trojan was handing out thousands of vibrators. So there's that.

Yifang was showing off several versions of the Touch8, including a USB-powered model and one that used wireless technology. According to Eric Ju, an account development manager with the digital pen business unit within Yifang, the company is attempting to license or has already licensed the technology to accessory vendor Targus, which is marketing a very similar device known as the Touch Pen.

The Targus Touch Pen costs $99.99 and will be available during the second quarter; the Touch8 will be available this quarter for $79.99. Targus representatives, who were likely flying home from Las Vegas, could not be reached for comment.The Touch8 system, and presumably the Touch Pen as well, both use a receiver that mounts to one side of your screen.

A combination of ultrasonic and infrared beams detects the stylus' soft, fuzzy tip, orienting it on the screen. Touch8 learns the boundaries of the available touchscreen real estate. The stylus itself requires power, but it can be used for 500 hours (about 62 days of 8-hour workdays) without replacing the small, watch-sized batteries that power it.

Now, smartphones that can detect radiation

2012-06-29T23:15:00.001+05:30

TOKYO: Mobile phone operator Softbank Corpsaid it would soon begin selling smartphoneswith radiation detectors, tapping into concerns that atomic hotspots remain along Japan's eastern coast more than a year after theFukushima crisis. Parts of northeastern Japan are still off-limits due to high radiation levels after the Fukushima nuclear plant was devastated by a huge earthquake and tsunami, triggering meltdowns and spewing radiation. Anti-nuclear sentiment is high, with advocacy groups in Tokyo and other cities calling for radiation monitoring at schools and other public facilities. "The threat from the nuclear accident cannot be seen by the human eye and continues to be a concern for many people, especially for mothers with small children," said Softbank founder and president, Masayoshi Son, standing in front of an aerial photo of the crippled plant.

The smartphone in the company's "Pantone" series will come in eight bright colors and include customized IC chips made by Sharp that measure radiation levels in microsieverts per hour. The phone, which goes on sale this summer, can also keep track of each location a user tests for radiation levels. Son, who emerged as an outspoken critic of nuclear power and advocate of renewable energy sources after last year's quake, told vendors and reporters that the smartphone was more portable and user-friendly than conventional Geiger counters. Softbank, Japan's No. 3 mobile phone operator, has not set a price on the new smartphone yet, but Son told reporters after the event that it would be in an affordable price range.

Computer Troubleshooting Tips

2012-01-15T09:15:00.010+05:30

The first step to keep your computer running at it's peak performance is preventative maintenance. You can save yourself costly repair by spending 30 minutes a week running a few free programs that will keep your computer running like new. You are probably thinking, "this is a great idea, but how much is this going to cost me?" Well, it is not going to cost you a thing, other than about 30 minutes of your time per week! Here are the things that you are going to need to get started.

The first thing that you are going to want to do is to get rid of the unneeded files that accumulate from browsing the Internet and installing software. There is a great program that is free called CCleaner (formally know as Crap Cleaner). This nifty little program does all of the work for you, it deletes your temporary internet and temporary files. Temporary internet files are just like the name implies, files that are stored temporarily while you are browsing the internet. Temporary files are files that are only needed while programs are being installed. CCleaner knows where these files are located and will remove them once it is ran. You can download CCleaner from the Software section of this website. Once the program is downloaded you need to install it. To install it you can double click on the file and then click next and accept the default values. Next you will need to click run cleaner, next click on the Registry button and click scan for issues, then click fix selected issues, click no and then click fix all selected issues and that's it your done!

The next piece of software that you will need is called Spybot Search and Destroy and it is also a free program that removes spyware and tracking cookies from your computer. It can be downloaded from the Software section of this website. Once it is downloaded you will need to install it by double clicking on the file. You can accept the default vales for this as well. Once the program is installed it will open the first time run wizard which will create a backup of your registry as well as download updates and immunize your system, you will need to click create registry backup. Once it is done you will need to click on search for updates and then select a download location. Next you will need to click on immunize this system. OK the hard part is over, lets get down to letting the program do it's work.The next step is to click on check for problems and then wait, it will take around 15 to 30 minutes depending on the speed of your computer. You will see anything that it finds in the window pain below. It is safe to remove anything that it finds. You see what each problem is and what it is by clicking on the blue arrows to the right and then click on a individual result to see what it is. Next you will need to lick on the fix selected problems button. And you are done!

For more details on troubleshooting techniques, refer the below links of DIRECTION.COM

Common Troubleshooting Techniques & Strategies

Troubleshooting - Monitor

Troubleshooting - Motherboard

Troubleshooting - Hard Drive

Troubleshooting - Sound

Troubleshooting - Network

Troubleshooting - Modem

Troubleshooting - Case & PS

Troubleshooting - Video

Troubleshooting - HardDrive

Troubleshooting - Hard Drive Partition and Formatting

How to Maintain a System?

Apple iCloud

2011-06-07T21:13:00.002+05:30

Apple® introduced iCloud®on June 6, 2011 in San Francisco , a breakthrough set of free new cloud services that work seamlessly with applications on your iPhone®, iPad®, iPod touch®, Mac® or PC to automatically and wirelessly store your content in iCloud and automatically and wirelessly push it to all your devices. When anything changes on one of your devices, all of your devices are wirelessly updated almost instantly.

“Today it is a real hassle and very frustrating to keep all your information and content up-to-date across all your devices,” said Steve Jobs, Apple’s CEO. “iCloud keeps your important information and content up to date across all your devices. All of this happens automatically and wirelessly, and because it’s integrated into our apps you don’t even need to think about it—it all just works.”

The free iCloud services include:

The former MobileMe® services—Contacts, Calendar and Mail—all completely re-architected and rewritten to work seamlessly with iCloud. Users can share calendars with friends and family, and the ad-free push Mail account is hosted at me.com. Your inbox and mailboxes are kept up-to-date across all your iOS devices and computers.

The App Store™ and iBookstore℠ now download purchased iOS apps and books to all your devices, not just the device they were purchased on. In addition, the App Store and iBookstore now let you see your purchase history, and simply tapping the iCloud icon will download any apps and books to any iOS device (up to 10 devices) at no additional cost.

iCloud Backup automatically and securely backs up your iOS devices to iCloud daily over Wi-Fi when you charge your iPhone, iPad or iPod touch. Backed up content includes purchased music, apps and books, Camera Roll (photos and videos), device settings and app data. If you replace your iOS device, just enter your Apple ID and password during setup and iCloud restores your new device.

iCloud Storage seamlessly stores all documents created using iCloud Storage APIs, and automatically pushes them to all your devices. When you change a document on any device, iCloud automatically pushes the changes to all your devices. Apple’s Pages®, Numbers® and Keynote® apps already take advantage of iCloud Storage. Users get up to 5GB of free storage for their mail, documents and backup—which is more amazing since the storage for music, apps and books purchased from Apple, and the storage required by Photo Stream doesn’t count towards this 5GB total. Users will be able to buy even more storage, with details announced when iCloud ships this fall.

iCloud’s innovative Photo Stream service automatically uploads the photos you take or import on any of your devices and wirelessly pushes them to all your devices and computers. So you can use your iPhone to take a dozen photos of your friends during the afternoon baseball game, and they will be ready to share with the entire group on your iPad (or even Apple TV®) when you return home. Photo Stream is built into the photo apps on all iOS devices, iPhoto® on Macs, and saved to the Pictures folder on a PC. To save space, the last 1,000 photos are stored on each device so they can be viewed or moved to an album to save forever. Macs and PCs will store all photos from the Photo Stream, since they have more storage. iCloud will store each photo in the cloud for 30 days, which is plenty of time to connect your devices to iCloud and automatically download the latest photos from Photo Stream via Wi-Fi.

iTunes® in the Cloud lets you download your previously purchased iTunes music to all your iOS devices at no additional cost, and new music purchases can be downloaded automatically to all your devices. In addition, music not purchased from iTunes can gain the same benefits by using iTunes Match, a service that replaces your music with a 256 kbps AAC DRM-free version if we can match it to the over 18 million songs in the iTunes Store®, it makes the matched music available in minutes (instead of weeks to upload your entire music library), and uploads only the small percentage of unmatched music. iTunes Match will be available this fall for a $24.99 annual fee. Apple today is releasing a free beta version of iTunes in the Cloud, without iTunes Match, for iPhone, iPad and iPod touch users running iOS 4.3. iTunes in the Cloud will support all iPhones that iOS 5 supports this fall.

Apple is ready to ramp iCloud in its three data centers, including the third recently completed in Maiden, NC. Apple has invested over $500 million in its Maiden data center to support the expected customer demand for the free iCloud services.

Pricing & Availability

The iCloud beta and Cloud Storage APIs are available immediately to iOS and Mac Developer Program members at developer.apple.com. iCloud will be available this fall concurrent with iOS 5. Users can sign up for iCloud for free on an iPhone, iPad or iPod touch running iOS 5 or a Mac running Mac OS® X Lion with a valid Apple ID. iCloud includes 5GB of free cloud storage for Mail, Document Storage and Backup. Purchased music, apps, books and Photo Stream do not count against the storage limit. iTunes Match will be available for $24.99 per year (US only).

iTunes in the Cloud is available today in the US and requires iTunes 10.3 and iOS 4.3.3. Automatic download of apps and books is available today. Using iCloud with a PC requires Windows Vista or Windows 7; Outlook 2010 or 2007 is recommended for accessing contacts and calendars.

Apple designs Macs, the best personal computers in the world, along with OS X, iLife, iWork and professional software. Apple leads the digital music revolution with its iPods and iTunes online store. Apple has reinvented the mobile phone with its revolutionary iPhone and App Store, and has recently introduced iPad 2 which is defining the future of mobile media and computing devices.

Reference: http://www.apple.com/pr/library/2011/06/06icloud.html

Bendable computer

2011-05-06T08:12:00.002+05:30

Queen's University team designs bendable computer that it sees replacing paper. A research team at Queen's University has entered the race to slim down tablets and smartphones with a plastic, flexible prototype that's just about paper thin. The Kingston, Ont.-based school's Human Media Lab has unveiled a type of e-paper technology nicknamed the Paper Phone, which is described as a bendable iPhone.The device measures in at 9.5 centimeters diagonally and its electronics are housed in a thin, flexible film that can be rolled up. It has a grayscale E Ink screen — which looks like the display on Amazon's Kindle e-reader — and has a few applications that can make phone calls, play music, read eBooks and maps.

Rather than using buttons or touch screen controls, the plastic device responds to different bends. Commands are triggered by bending the corners of the device, or rolling the right edge backward or forward. Users can also use a stylus to write on the screen.

As technology evolves and gets cheaper, a high-resolution color screen capable of playing video would be integrated into the device, as well as some touch screen controls, says creator Roel Vertegaal.
While he admits that the technology would likely need at least five to 10 years to go mass market in a sophisticated way, he boldly claims the research team is onto a game-changing technology.
"It's a replacement for the computer as we know it, it's going to change everything," Vertegaal says.
While the prototype cost about $7,000 to make, he imagines they could be cheaply mass produced in a few years.And because the technology would eventually be so inexpensive, consumers and businesses could conceivably own multiple e-paper sheets in different sizes — including huge desk-covering displays— and have them stacked on their desks or in a bag. Users could choose to use just one sheet, or multitask with a pile of electronic paper.

Eventually, the devices will also be designed to fold, Vertegaal says, so you could carry around a huge screen that neatly folds into a shirt pocket. But the Queen's researchers have competition in the development of e-paper type products. Arizona State University has partnered with the likes of Boeing, HP and Lockheed Martin in researching similar technology and is expected to conduct a test sometime this year with the U.S. Army.

Keep Your Computer Safe from USB

2011-02-24T03:51:00.001+05:30

USB security software is an essential solution to have in many scenarios, especially in larger commercial networks where information seep out is something that needs to be prevented as much as possible. Also, for businesses which habitually rely on their computers for their day-to-day functioning, it is of important that computers do not end up getting down by malware or other technical problems. In commercial or public networks especially, unobstructed usage of USB devices is something that should be avoided, since USB drives can contain malware or be used for leaking important, confidential information.

USB security software provides users with an important additional safeguard that will give network administrators and the owners of home computers alike a higher degree of power over how other people use their systems. One such solution which provides everything you need for USB security is USB Security software. Using this solution, you can help protect your computers from the connection of any illegal USB devices, though it will not simply block off the ports entirely. What it does allow you to set limitations on is hardware such as USB memory card readers, flash disks and other removable USB storage. The program will not cause any tribulations for other types of USB device such as USB printers, keyboards and other input devices. These can continue to be used as normal.

USB Security will allow you to secure individual computers such as in the case of home use or entire networks. This makes the software extremely versatile, making it highly useful in all sorts of different scenarios ranging from small, single computer home installations or entire networks over extensive commercial installations. When used on a network-wide basis, USB Security can also be centrally deployed and managed, allowing network administrators to easily enforce their security policies from one, central location. Helping to control file transfers, guard against potential information leak and prevent infections from malware, this simple, yet powerful utility provides a solution that in many cases should be considered essential.

Using the program's settings, administrators can easily set a white-list of USB devices deemed as safe. These can include devices such as printers, scanners, or anything else in addition to USB storage devices which are explicitly acceptable by the administrator. It is perfectly possible, an easy, to allow access to specific USB storage devices which, using the software, you can consign passwords to for added security. This means, that when such a device is linked to a computer running USB security, it will prompt the user for a password before they can continue.

USB Security is also completely inconspicuous. It runs invisibly in the background and is completely barely visible to PC users. It will not open fire on the user with any warning messages or pop-up windows unless explicitly configured by the system administrator to do so. Another thing that administrators will certainly realize is the fact that the software can be installed and managed from the central server computer. Settings can be applied this way for all of the computers across the network.

Software Engineering

2010-12-31T00:02:00.001+05:30

"Software" redirects here. For other uses, see Software (disambiguation).
Computer software, or just software, is the collection of computer programs and related data that provide the instructions telling a computer what to do. We can also say software refers to one or more computer programs and data held in the storage of the computer for some purposes. Program software performs the function of the program it implements, either by directly providing instructions to the computer hardware or by serving as input to another piece of software. The term was coined to contrast to the old term hardware (meaning physical devices). In contrast to hardware, software is intangible, meaning it "cannot be touched".[1] Software is also sometimes used in a more narrow sense, meaning application software only. Sometimes the term includes data that has not traditionally been associated with computers, such as film, tapes, and records.[2]

Examples of computer software include:

Application software includes end-user applications of computers such as word processors or video games, and ERP software for groups of users.
Middleware controls and co-ordinates distributed systems.
Programming languages define the syntax and semantics of computer programs. For example, many mature banking applications were written in the COBOL language, originally invented in 1959. Newer applications are often written in more modern programming languages.
System software includes operating systems, which govern computing resources. Today[when?] large[quantify] applications running on remote machines such as Websites are considered[by whom?] to be system software, because[citation needed] the end-user interface is generally through a graphical user interface, such as a web browser.
Testware is software for testing hardware or a software package.
Firmware is low-level software often stored on electrically programmable memory devices. Firmware is given its name because it is treated like hardware and run ("executed") by other software programs.

Shrinkware is the older name given to consumer-purchased software, because it was often sold in retail stores in a shrink-wrapped box.
Device drivers control parts of computers such as disk drives, printers, CD drives, or computer monitors.

Programming tools help conduct computing tasks in any category listed above. For programmers, these could be tools for debugging or reverse engineering older legacy systems in order to check source code compatibility.

Contents
1 History
2 Overview
3 Types of software
3.1 System software
3.2 Programming software
3.3 Application software
4 Software topics
4.1 Architecture
4.2 Documentation
4.3 Library
4.4 Standard
4.5 Execution
4.6 Quality and reliability
4.7 License
4.8 Patents
5 Design and implementation
6 Industry and organizations
7 References
8 External links

History

For the history prior to 1946, see History of computing hardware.
The first theory about software was proposed by Alan Turing in his 1935 essay Computable numbers with an application to the Entscheidungsproblem (Decision problem).[3] The term "software" was first used in print by John W. Tukey in 1958[citation needed]. Colloquially, the term is often used to mean application software. In computer science and software engineering, software is all information processed by computer system, programs and data.[4] The academic fields studying software are computer science and software engineering.

The history of computer software is most often traced back to the first software bug in 1946[citation needed]. As more and more programs enter the realm of firmware, and the hardware itself becomes smaller, cheaper and faster as predicted by Moore's law, elements of computing first considered to be software, join the ranks of hardware. Most hardware companies today have more software programmers on the payroll than hardware designers[citation needed], since software tools have automated many tasks of Printed circuit board engineers. Just like the Auto industry, the Software industry has grown from a few visionaries operating out of their garage with prototypes. Steve Jobs and Bill Gates were the Henry Ford and Louis Chevrolet of their times[citation needed], who capitalized on ideas already commonly known before they started in the business. In the case of Software development, this moment is generally agreed to be the publication in the 1980s of the specifications for the IBM Personal Computer published by IBM employee Philip Don Estridge. Today his move would be seen as a type of crowd-sourcing.
Until that time, software was bundled with the hardware by Original equipment manufacturers (OEMs) such as Data General, Digital Equipment and IBM[citation needed]. When a customer bought a minicomputer, at that time the smallest computer on the market, the computer did not come with Pre-installed software, but needed to be installed by engineers employed by the OEM. Computer hardware companies not only bundled their software, they also placed demands on the location of the hardware in a refrigerated space called a computer room. Most companies had their software on the books for 0 dollars, unable to claim it as an asset (this is similar to financing of popular music in those days). When Data General introduced the Data General Nova, a company called Digidyne wanted to use its RDOS operating system on its own hardware clone. Data General refused to license their software (which was hard to do, since it was on the books as a free asset), and claimed their "bundling rights". The Supreme Court set a precedent called Digidyne v. Data General in 1985. The Supreme Court let a 9th circuit decision stand, and Data General was eventually forced into licensing the Operating System software because it was ruled that restricting the license to only DG hardware was an illegal tying arrangement.[5] Soon after, IBM 'published' its DOS source for free, and Microsoft was born. Unable to sustain the loss from lawyer's fees, Data General ended up being taken over by EMC Corporation. The Supreme Court decision made it possible to value software, and also purchase Software patents. The move by IBM was almost a protest at the time. Few in the industry believed that anyone would profit from it other than IBM (through free publicity). Microsoft and Apple were able to thus cash in on 'soft' products. It is hard to imagine today that people once felt that software was worthless without a machine. There are many successful companies today that sell only software products, though there are still many common software licensing problems due to the complexity of designs and poor documentation, leading to patent trolls.

With open software specifications and the possibility of software licensing, new opportunities arose for software tools that then became the de facto standard, such as DOS for operating systems, but also various proprietary word processing and spreadsheet programs. In a similar growth pattern, proprietary development methods became standard Software development methodology.

A layer structure showing where operating system is located on generally used software systems on desktops
Software includes all the various forms and roles that digitally stored data may have and play in a computer (or similar system), regardless of whether the data is used as code for a CPU, or other interpreter, or whether it represents other kinds of information. Software thus encompasses a wide array of products that may be developed using different techniques such as ordinary programming languages, scripting languages, microcode, or an FPGA configuration.
The types of software include web pages developed in languages and frameworks like HTML, PHP, Perl, JSP, ASP.NET, XML, and desktop applications like OpenOffice.org, Microsoft Word developed in languages like C, C++, Java, C#, or Smalltalk. Application software usually runs on an underlying software operating systems such as Linux or Microsoft Windows. Software (or firmware) is also used in video games and for the configurable parts of the logic systems of automobiles, televisions, and other consumer electronics.
Computer software is so called to distinguish it from computer hardware, which encompasses the physical interconnections and devices required to store and execute (or run) the software. At the lowest level, executable code consists of machine language instructions specific to an individual processor. A machine language consists of groups of binary values signifying processor instructions that change the state of the computer from its preceding state. Programs are an ordered sequence of instructions for changing the state of the computer in a particular sequence. It is usually written in high-level programming languages that are easier and more efficient for humans to use (closer to natural language) than machine language. High-level languages are compiled or interpreted into machine language object code. Software may also be written in an assembly language, essentially, a mnemonic representation of a machine language using a natural language alphabet. Assembly language must be assembled into object code via an assembler.

Types of software

This section does not cite any references or sources.
Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (August 2010)
Practical computer systems divide software systems into three major classes[citation needed]: system software, programming software and application software, although the distinction is arbitrary, and often blurred.
[edit]System software
System software provides the basic functions for computer usage and helps run the computer

hardware and system. It includes a combination of the following:
device drivers
operating systems
servers
utilities
window systems

System software is responsible for managing a variety of independent hardware components, so that they can work together harmoniously. Its purpose is to unburden the application software programmer from the often complex details of the particular computer being used, including such accessories as communications devices, printers, device readers, displays and keyboards, and also to partition the computer's resources such as memory and processor time in a safe and stable manner.

Programming software

Programming software usually provides tools to assist a programmer in writing computer programs, and software using different programming languages in a more convenient way. The tools include:
compilers
debuggers
interpreters
linkers
text editors
An Integrated development environment (IDE) is a single application that attempts to manage all these functions.

Application software

System software does not aim at a certain application fields. In contrast,different application software offers different functions based on users and the area it served.Application software is developed for some certain purpose,which either can be a certain program or a collection of some programmes,such as a graphic browser or the data base management system. Application software allows end users to accomplish one or more specific (not directly computer development related) tasks. Typical applications include:
industrial automation
business software
video games
quantum chemistry and solid state physics software
telecommunications (i.e., the Internet and everything that flows on it)
databases
educational software
Mathematical software
medical software
molecular modeling software
image editing
spreadsheet
simulation software
Word processing
Decision making software
Application software exists for and has impacted a wide variety of topics.

Software topics

Architecture:

See also: Software architecture
Users often see things differently than programmers. People who use modern general purpose computers (as opposed to embedded systems, analog computers and supercomputers) usually see three layers of software performing a variety of tasks: platform, application, and user software.

Platform software: Platform includes the firmware, device drivers, an operating system, and typically a graphical user interface which, in total, allow a user to interact with the computer and its peripherals (associated equipment). Platform software often comes bundled with the computer. On a PC you will usually have the ability to change the platform software.
Application software: Application software or Applications are what most people think of when they think of software. Typical examples include office suites and video games. Application software is often purchased separately from computer hardware. Sometimes applications are bundled with the computer, but that does not change the fact that they run as independent applications. Applications are usually independent programs from the operating system, though they are often tailored for specific platforms. Most users think of compilers, databases, and other "system software" as applications.

User-written software: End-user development tailors systems to meet users' specific needs. User software include spreadsheet templates and word processor templates. Even email filters are a kind of user software. Users create this software themselves and often overlook how important it is. Depending on how competently the user-written software has been integrated into default application packages, many users may not be aware of the distinction between the original packages, and what has been added by co-workers.

Documentation

Main article: Software documentation
Most software has software documentation so that the end user can understand the program, what it does, and how to use it. Without clear documentation, software can be hard to use—especially if it is very specialized and relatively complex like Photoshop or AutoCAD.
Developer documentation may also exist, either with the code as comments and/or as separate files, detailing how the programs works and can be modified.
Library

Main article: Software library
An executable is almost always not sufficiently complete for direct execution. Software libraries include collections of functions and functionality that may be embedded in other applications. Operating systems include many standard Software libraries, and applications are often distributed with their own libraries.
Standard

Main article: Software standard
Since software can be designed using many different programming languages and in many different operating systems and operating environments, software standard is needed so that different software can understand and exchange information between each other. For instance, an email sent from a Microsoft Outlook should be readable from Yahoo! Mail and vice versa.
Execution

Main article: Execution (computing)
Computer software has to be "loaded" into the computer's storage (such as the hard drive or memory). Once the software has loaded, the computer is able to execute the software. This involves passing instructions from the application software, through the system software, to the hardware which ultimately receives the instruction as machine code. Each instruction causes the computer to carry out an operation – moving data, carrying out a computation, or altering the control flow of instructions.

Data movement is typically from one place in memory to another. Sometimes it involves moving data between memory and registers which enable high-speed data access in the CPU. Moving data, especially large amounts of it, can be costly. So, this is sometimes avoided by using "pointers" to data instead. Computations include simple operations such as incrementing the value of a variable data element. More complex computations may involve many operations and data elements together.

Quality and reliability

Main articles: Software quality, Software testing, and Software reliability
Software quality is very important, especially for commercial and system software like Microsoft Office, Microsoft Windows and Linux. If software is faulty (buggy), it can delete a person's work, crash the computer and do other unexpected things. Faults and errors are called "bugs." Many bugs are discovered and eliminated (debugged) through software testing. However, software testing rarely – if ever – eliminates every bug; some programmers say that "every program has at least one more bug" (Lubarsky's Law). All major software companies, such as Microsoft, Novell and Sun Microsystems, have their own software testing departments with the specific goal of just testing. Software can be tested through unit testing, regression testing and other methods, which are done manually, or most commonly, automatically, since the amount of code to be tested can be quite large. For instance, NASA has extremely rigorous software testing procedures for many operating systems and communication functions. Many NASA based operations interact and identify each other through command programs called software. This enables many people who work at NASA to check and evaluate functional systems overall. Programs containing command software enable hardware engineering and system operations to function much easier together.

License
Main article: Software license
The software's license gives the user the right to use the software in the licensed environment. Some software comes with the license when purchased off the shelf, or an OEM license when bundled with hardware. Other software comes with a free software license, granting the recipient the rights to modify and redistribute the software. Software can also be in the form of freeware or shareware.

Patents
Main articles: Software patent and Software patent debate
Software can be patented; however, software patents can be controversial in the software industry with many people holding different views about it. The controversy over software patents is that a specific algorithm or technique that the software has may not be duplicated by others and is considered an intellectual property and copyright infringement depending on the severity.

Design and implementation

Main articles: Software development, Computer programming, and Software engineering
Design and implementation of software varies depending on the complexity of the software. For instance, design and creation of Microsoft Word software will take much more time than designing and developing Microsoft Notepad because of the difference in functionalities in each one.
Software is usually designed and created (coded/written/programmed) in integrated development environments (IDE) like Eclipse, Emacs and Microsoft Visual Studio that can simplify the process and compile the program. As noted in different section, software is usually created on top of existing software and the application programming interface (API) that the underlying software provides like GTK+, JavaBeans or Swing. Libraries (APIs) are categorized for different purposes. For instance, JavaBeans library is used for designing enterprise applications, Windows Forms library is used for designing graphical user interface (GUI) applications like Microsoft Word, and Windows Communication Foundation is used for designing web services. Underlying computer programming concepts like quicksort, hashtable, array, and binary tree can be useful to creating software. When a program is designed, it relies on the API. For instance, if a user is designing a Microsoft Windows desktop application, he/she might use the .NET Windows Forms library to design the desktop application and call its APIs like Form1.Close() and Form1.Show()[6] to close or open the application and write the additional operations him/herself that it need to have. Without these APIs, the programmer needs to write these APIs him/herself. Companies like Sun Microsystems, Novell, and Microsoft provide their own APIs so that many applications are written using their software libraries that usually have numerous APIs in them.
Computer software has special economic characteristics that make its design, creation, and distribution different from most other economic goods.[7][8] A person who creates software is called a programmer, software engineer, software developer, or code monkey, terms that all have a similar meaning.

Industry and organizations

Main article: Software industry

A great variety of software companies and programmers in the world comprise a software industry . Software can be quite a profitable industry: Bill Gates, the founder of Microsoft was the richest person in the world in 2009 largely by selling the Microsoft Windows and Microsoft Office software products. The same goes for Larry Ellison, largely through his Oracle database software. Through time the software industry has become increasingly specialized.
Non-profit software organizations include the Free Software Foundation, GNU Project and Mozilla Foundation. Software standard organizations like the W3C, IETF develop software standards so that most software can interoperate through standards such as XML, HTML, HTTP or FTP.
Other well-known large software companies include Novell, SAP, Symantec, Adobe Systems, and Corel, while small companies often provide innovation.

References:
^ "Wikipedia"
^ "Wordreference.com: WordNet 2.0". Princeton University, Princeton, NJ. Retrieved 2007-08-19.
^ software..(n.d.). Dictionary.com Unabridged (v 1.1). Retrieved 2007-04-13, from Dictionary.com website: http://dictionary.reference.com/browse/software
^ Hally, Mike (2005:79). Electronic brains/Stories from the dawn of the computer age. British Broadcasting Corporation and Granta Books, London. ISBN 1-86207-663-4.
^ Leonhardt, David (July 28, 2000). "John Tukey, 85, Statistician; Coined the Word 'Software'". New York Times.
^ Tying Arrangements and the Computer Industry: Digidyne Corp. vs. Data General
^ "MSDN Library". Retrieved 2010-06-14.
^ v. Engelhardt, Sebastian (2008): "The Economic Properties of Software", Jena Economic Research Papers, Volume 2 (2008), Number 2008-045. (in Adobe pdf format)
^ "Why Open Source Is The Optimum Economic Paradigm for Software" by Dan Kaminsky 1999

Engineers you can become scientist..!

2010-03-28T09:10:00.003+05:30

The following are the syllabus for the scientist entrance test for the respective engineering branch.

1. Chemical Engineering – CH

Process Calculations and Thermodynamics: Laws of conservation of mass and energy; use of tie components; recycle, bypass and purge calculations; degree of freedom analysis. First and Second laws of thermodynamics. First law application to close and open systems. Second law and Entropy Thermodynamic properties of pure substances: equation of state and departure function, properties of mixtures: partial molar properties, fugacity, excess properties and activity coefficients; phase equilibria: predicting VLE of systems; chemical reaction equilibria.
Fluid Mechanics and Mechanical Operations: Fluid statics, Newtonian and non-Newtonian fluids, Bernoulli equation, Macroscopic friction factors, energy balance, dimensional analysis, shell balances, flow through pipeline systems, flow meters, pumps and compressors, packed and fluidized beds, elementary boundary layer theory, size reduction and size separation; free and hindered settling; centrifuge and cyclones; thickening and classification, filtration, mixing and agitation; conveying of solids.
Heat Transfer: Conduction, convection and radiation, heat transfer coefficients, steady and unsteady heat conduction, boiling, condensation and evaporation; types of heat exchangers and evaporators and their design.
Mass Transfer: Fick’s laws, molecular diffusion in fluids, mass transfer coefficients, film, penetration and surface renewal theories; momentum, heat and mass transfer analogies; stagewise and continuous contacting and stage efficiencies; HTU & NTU concepts design and operation of equipment for distillation, absorption, leaching, liquid-liquid extraction, drying, humidification, dehumidification and adsorption.
Chemical Reaction Engineering: Theories of reaction rates; kinetics of homogeneous reactions, interpretation of kinetic data, single and multiple reactions in ideal reactors, non-ideal reactors; residence time distribution, single parameter model; non-isothermal reactors; kinetics of heterogeneous catalytic reactions; diffusion effects in catalysis.
Instrumentation and Process Control: Measurement of process variables; sensors, transducers and their dynamics, transfer functions and dynamic responses of simple systems, process reaction curve, controller modes (P, PI, and PID); control valves; analysis of closed loop systems including stability, frequency response and controller tuning, cascade, feed forward control.
Plant Design and Economics: Process design and sizing of chemical engineering equipment such as compressors, heat exchangers, multistage contactors; principles of process economics and cost estimation including total annualized cost, cost indexes, rate of return, payback period, discounted cash flow, optimization in design.Chemical Technology: Inorganic chemical industries; sulfuric acid, NaOH, fertilizers (Ammonia, Urea, SSP and TSP); natural products industries (Pulp and Paper, Sugar, Oil, and Fats); petroleum refining and petrochemicals; polymerization industries; polyethylene, polypropylene, PVC and polyester synthetic fibers.

2. Computer Science and Engineering – CS
Theory of Computation: Regular languages and finite automata, Context free languages and Push-down automata, Recursively enumerable sets and Turing machines, Undecidability; NP-completeness.
Digital Logic: Logic functions, Minimization, Design and synthesis of combinational and sequential circuits; Number representation and computer arithmetic (fixed and floating point).
Computer Organization and Architecture: Machine instructions and addressing modes, ALU and data-path, CPU control design, Memory interface, I/O interface (Interrupt and DMA mode), Instruction pipelining, Cache and main memory, Secondary storage.
Programming and Data Structures: Programming in C; Functions, Recursion, Parameter passing, Scope, Binding; Abstract data types, Arrays, Stacks, Queues, Linked Lists, Trees, Binary search trees, Binary heaps. Algorithms: Analysis, Asymptotic notation, Notions of space and time complexity, Worst and average case analysis; Design: Greedy approach, Dynamic programming, Divide-and-conquer; Tree and graph traversals, Connected components, Spanning trees, Shortest paths; Hashing, Sorting, Searching.
Compiler Design: Lexical analysis, Parsing, Syntax directed translation, Runtime environments, Intermediate and target code generation, Basics of code optimization.
Operating System: Processes, Threads, Inter-process communication, Concurrency, Synchronization, Deadlock, CPU scheduling, Memory management and virtual memory, File systems, I/O systems, Protection and security.
Databases: ER-model, Relational model (relational algebra, tuple calculus), Database design (integrity constraints, normal forms), Query languages (SQL), File structures (sequential files, indexing, B and B+ trees), Transactions and concurrency control.
Computer Networks: ISO/OSI stack, LAN technologies (Ethernet, Token ring), Flow and error control techniques, Routing algorithms, Congestion control, TCP/UDP and sockets, IP(v4), Application layer protocols (icmp, dns, smtp, pop, ftp, http); Basic concepts of hubs, switches, gateways, and routers.
3. Electronics and Communication Engineering – EC

Networks: Network graphs: matrices associated with graphs; incidence, fundamental cut set and fundamental circuit matrices. Solution methods: nodal and mesh analysis. Network theorems: superposition, Thevenin and Norton’s maximum power transfer, Wye-Delta transformation. Steady state sinusoidal analysis using phasors. Linear constant coefficient differential equations; time domain analysis of simple RLC circuits, Solution of network equations using Laplace transform: frequency domain analysis of RLC circuits. 2-port network parameters: driving point and transfer functions. State equations for networks.
Electronic Devices: Energy bands in silicon, intrinsic and extrinsic silicon. Carrier transport in silicon: diffusion current, drift current, mobility, and resistivity. Generation and recombination of carriers. p-n junction diode, Zener diode, tunnel diode, BJT, JFET, MOS capacitor, MOSFET, LED, p-I-n and avalanche photo diode, Basics of LASERs. Device technology: integrated circuits fabrication process, oxidation, diffusion, ion implantation, photolithography, n-tub, p-tub and twin-tub CMOS process.
Analog Circuits: Small Signal Equivalent circuits of diodes, BJTs, MOSFETs and analog CMOS. Simple diode circuits, clipping, clamping, rectifier. Biasing and bias stability of transistor and FET amplifiers. Amplifiers: single-and multi-stage, differential and operational, feedback, and power. Frequency response of amplifiers. Simple op-amp circuits. Filters. Sinusoidal oscillators; criterion for oscillation; single-transistor and op-amp configurations. Function generators and wave-shaping circuits, 555 Timers. Power supplies.
Digital Circuits: Boolean algebra, minimization of Boolean functions; logic gates; digital IC families (DTL, TTL, ECL, MOS, CMOS). Combinatorial circuits: arithmetic circuits, code converters, multiplexers, decoders, PROMs and PLAs. Sequential circuits: latches and flip-flops, counters and shift-registers. Sample and hold circuits, ADCs, DACs. Semiconductor memories. Microprocessor(8085): architecture, programming, memory and I/O interfacing.
Signals and Systems: Definitions and properties of Laplace transform, continuous-time and discrete-time Fourier series, continuous-time and discrete-time Fourier Transform, DFT and FFT, z-transform. Sampling theorem. Linear Time-Invariant (LTI) Systems: definitions and properties; causality, stability, impulse response, convolution, poles and zeros, parallel and cascade structure, frequency response, group delay, phase delay. Signal transmission through LTI systems.
Control Systems: Basic control system components; block diagrammatic description, reduction of block diagrams. Open loop and closed loop (feedback) systems and stability analysis of these systems. Signal flow graphs and their use in determining transfer functions of systems; transient and steady state analysis of LTI control systems and frequency response. Tools and techniques for LTI control system analysis: root loci, Routh-Hurwitz criterion, Bode and Nyquist plots. Control system compensators: elements of lead and lag compensation, elements of Proportional-Integral-Derivative (PID) control. State variable representation and solution of state equation of LTI control systems.
Communications: Random signals and noise: probability, random variables, probability density function, autocorrelation, power spectral density. Analog communication systems: amplitude and angle modulation and demodulation systems, spectral analysis of these operations, superheterodyne receivers; elements of hardware, realizations of analog communication systems; signal-to-noise ratio (SNR) calculations for amplitude modulation (AM) and frequency modulation (FM) for low noise conditions. Fundamentals of information theory and channel capacity theorem. Digital communication systems: pulse code modulation (PCM), differential pulse code modulation (DPCM), digital modulation schemes: amplitude, phase and frequency shift keying schemes (ASK, PSK, FSK), matched filter receivers, bandwidth consideration and probability of error calculations for these schemes. Basics of TDMA, FDMA and CDMA and GSM.
Electromagnetics: Elements of vector calculus: divergence and curl; Gauss’ and Stokes’ theorems, Maxwell’s equations: differential and integral forms. Wave equation, Poynting vector. Plane waves: propagation through various media; reflection and refraction; phase and group velocity; skin depth. Transmission lines: characteristic impedance; impedance transformation; Smith chart; impedance matching; S parameters, pulse excitation. Waveguides: modes in rectangular waveguides; boundary conditions; cut-off frequencies; dispersion relations. Basics of propagation in dielectric waveguide and optical fibers. Basics of Antennas: Dipole antennas; radiation pattern; antenna gain.

4. Electrical Engineering – EE
Electric Circuits and Fields: Network graph, KCL, KVL, node and mesh analysis, transient response of dc and ac networks; sinusoidal steady-state analysis, resonance, basic filter concepts; ideal current and voltage sources, Thevenin’s, Norton’s and Superposition and Maximum Power Transfer theorems, two-port networks, three phase circuits; Gauss Theorem, electric field and potential due to point, line, plane and spherical charge distributions; Ampere’s and Biot-Savart’s laws; inductance; dielectrics; capacitance.
Signals and Systems: Representation of continuous and discrete-time signals; shifting and scaling operations; linear, time-invariant and causal systems; Fourier series representation of continuous periodic signals; sampling theorem; Fourier, Laplace and Z transforms.
Electrical Machines: Single phase transformer - equivalent circuit, phasor diagram, tests, regulation and efficiency; three phase transformers - connections, parallel operation; auto-transformer; energy conversion principles; DC machines - types, windings, generator characteristics, armature reaction and commutation, starting and speed control of motors; three phase induction motors - principles, types, performance characteristics, starting and speed control; single phase induction motors; synchronous machines – performance, regulation and parallel operation of generators, motor starting, characteristics and applications; servo and stepper motors.
Power Systems: Basic power generation concepts; transmission line models and performance; cable performance, insulation; corona and radio interference; distribution systems; per-unit quantities; bus impedance and admittance matrices; load flow; voltage control; power factor correction; economic operation; symmetrical components; fault analysis; principles of over-current, differential and distance protection; solid state relays and digital protection; circuit breakers; system stability concepts, swing curves and equal area criterion; HVDC transmission and FACTS concepts.
Control Systems: Principles of feedback; transfer function; block diagrams; steady-state errors; Routh and Niquist techniques; Bode plots; root loci; lag, lead and lead-lag compensation; state space model; state transition matrix, controllability and observability. Electrical and Electronic Measurements: Bridges and potentiometers; PMMC, moving iron, dynamometer and induction type instruments; measurement of voltage, current, power, energy and power factor; instrument transformers; digital voltmeters and multimeters; phase, time and frequency measurement; Q-meters; oscilloscopes; potentiometric recorders; error analysis.
Analog and Digital Electronics: Characteristics of diodes, BJT, FET; amplifiers – biasing, equivalent circuit and frequency response; oscillators and feedback amplifiers; operational amplifiers - characteristics and applications; simple active filters; VCOs and timers; combinational and sequential logic circuits; multiplexer; Schmitt trigger; multi-vibrators; sample and hold circuits; A/D and D/A converters; 8-bit microprocessor basics, architecture, programming and interfacing.
Power Electronics and Drives: Semiconductor power diodes, transistors, thyristors, triacs, GTOs, MOSFETs and IGBTs - static characteristics and principles of operation; triggering circuits; phase control rectifiers; bridge converters – fully controlled and half controlled; principles of choppers and inverters; basis concepts of adjustable speed dc and ac drives.
5. Mechanical Engineering – ME

Engineering Mechanics: Free body diagrams and equilibrium; trusses and frames; virtual work; kinematics
and dynamics of particles and of rigid bodies in plane motion, including impulse and momentum (linear and
angular) and energy formulations; impact.
Strength of Materials: Stress and strain, stress-strain relationship and elastic constants, Mohr’s circle for
plane stress and plane strain, thin cylinders; shear force and bending moment diagrams; bending and shear
stresses; deflection of beams; torsion of circular shafts; Euler’s theory of columns; strain energy methods;
thermal stresses.
Theory of Machines: Displacement, velocity and acceleration analysis of plane mechanisms; dynamic analysis of slider-crank mechanism; gear trains; flywheels.
Vibrations: Free and forced vibration of single degree of freedom systems; effect of damping; vibration isolation; resonance, critical speeds of shafts.
Design: Design for static and dynamic loading; failure theories; fatigue strength and the S-N diagram; principles of the design of machine elements such as bolted, riveted and welded joints, shafts, spur gears, rolling and sliding contact bearings, brakes and clutches.
Fluid Mechanics: Fluid properties; fluid statics, manometry, buoyancy; control-volume analysis of mass, momentum and energy; fluid acceleration; differential equations of continuity and momentum; Bernoulli’s equation; viscous flow of incompressible fluids; boundary layer; elementary turbulent flow; flow through pipes, head losses in pipes, bends etc.
Heat-Transfer: Modes of heat transfer; one dimensional heat conduction, resistance concept, electrical analogy, unsteady heat conduction, fins; dimensionless parameters in free and forced convective heat transfer, various correlations for heat transfer in flow over flat plates and through pipes; thermal boundary layer; effect of turbulence; radiative heat transfer, black and grey surfaces, shape factors, network analysis; heat exchanger performance, LMTD and NTU methods.
Thermodynamics: Zeroth, First and Second laws of thermodynamics; thermodynamic system and processes; Carnot cycle. irreversibility and availability; behaviour of ideal and real gases, properties of pure substances, calculation of work and heat in ideal processes; analysis of thermodynamic cycles related to energy conversion.
Applications: Power Engineering: Steam Tables, Rankine, Brayton cycles with regeneration and reheat. I.C. Engines: air-standard Otto, Diesel cycles. Refrigeration and air-conditioning: Vapour refrigeration cycle, heat pumps, gas refrigeration, Reverse Brayton cycle; moist air: psychrometric chart, basic psychrometric processes. Turbomachinery: Pelton-wheel, Francis and Kaplan turbines — impulse and reaction principles, velocity diagrams.
Engineering Materials: Structure and properties of engineering materials, heat treatment, stress-strain diagrams for engineering materials.
Metal Casting: Design of patterns, moulds and cores; solidification and cooling; riser and gating design, design considerations.
Forming: Plastic deformation and yield criteria; fundamentals of hot and cold working processes; load estimation for bulk (forging, rolling, extrusion, drawing) and sheet (shearing, deep drawing, bending) metal forming processes; principles of powder metallurgy.
Joining: Physics of welding, brazing and soldering; adhesive bonding; design considerations in welding.
Machining and Machine Tool Operations: Mechanics of machining, single and multi-point cutting tools, tool geometry and materials, tool life and wear; economics of machining; principles of non-traditional machining processes; principles of work holding, principles of design of jigs and fixtures Metrology and Inspection: Limits, fits and tolerances; linear and angular measurements; comparators; gauge design; interferometry; form and finish measurement; alignment and testing methods; tolerance analysis in manufacturing and assembly.
• Computer Integrated Manufacturing: Basic concepts of CAD/CAM and their integration tools.
• Production Planning and Control: Forecasting models, aggregate production planning, scheduling, materials requirement planning.
• Inventory Control: Deterministic and probabilistic models; safety stock inventory control systems.
• Operations Research: Linear programming, simplex and duplex method, transportation, assignment, network flow models, simple queuing models, PERT and CPM.

Introduction to Mobile Computing and Communications

2010-01-26T16:08:00.000+05:30

The most familiar aspect of mobile computing technology is the hand phone. About two decades ago, a hand phone was bulky and was only used for voice communication. It was merely an extension of the fixed line telephony that allowed users to keep in touch with colleagues. Now the hand phone is not only used for voice communication, it is also used to send text and multimedia messages. Future mobile devices will not only enable Internet access, but will also support high-speed data services.

In addition to the hand phone, various types of mobile devices are now available, for example, personal digital assistants (PDAs) and pocket personal computers (PCs). Road warriors use mobile devices to access up-to-date information from the corporate database. A police officer at a crime scene may send a fingerprint picked up there for matching with data in a central database through a wireless network, hence leading to faster identification and arrest of potential suspects. The global positioning system (GPS) is used in search and rescue missions, for monitoring and preservation of wildlife, and for vehicle theft prevention. Though many of us are unaware of when mobile computing technology is being used, it has permeated all aspects of our lives.

What is mobile computing? Simply defined, it is the use of a wireless network infrastructure to provide anytime, anywhere communications and access to information. There are many aspects of mobile computing and, sometimes, different terms are used to refer to them. This chapter gives an overview of what mobile computing has to offer and how it improves the quality of our lives. Later chapters discuss the underlying wireless networks and technologies that make mobile computing applications possible.
Mobile Computing Applications

In 1991, Mark Weiser envisioned the next-generation computer technologies that "weave themselves into the fabric of everyday life until they are indistinguishable from it." He described a ubiquitous computing environment that enhances the environment by making many computers available throughout the physical realm, while making them effectively invisible to the user. Weiser pointed out that anthropological studies of work life showed that people primarily work in a world of shared situations and unexamined technological skills. Today's computer technology does not conform to this description because it remains the focus of attention instead of being a tool that disappears from users' awareness. Ubiquitous computing aims to make computers widely available throughout users' environments and effortless to use. In other words, users should be able to work with computing devices without having to acquire the technological skills to use them. Computers are integrated into their environments so that users are not even aware that they are using a computer to accomplish a task. Unlike the computer technology of today, users need not acquire specific skills to use computers because their use would be intuitive. The aim of ubiquitous computing is to create a new relationship between people and computers in which the computers are kept out of the way of users as they go about their lives.

Instead of computers that sit passively on desks, ubiquitous computers are aware of their surroundings and locations. They come in different sizes, each tailored to a specific task. At the Xerox Lab, Weiser and his colleagues developed a tab that is analogous to a Post-it® note, a pad that is analogous to a sheet of paper, and a board that is analogous to a yard-scale display. An office may contain hundreds of tabs, tens of pads, and one or two boards. These devices are not personal computers, but are a pervasive part of everyday life, with users often having many units in simultaneous operation. Unlike a laptop or a notebook, which is associated with a particular user, tabs and pads can be grabbed and used anywhere-they have no individualized identity and importance. You may have a few pads on your desk, each dedicated to a particular task in the same way that you spread papers on your desk.

An employee ID card is replaced by an active badge that is of the same size. It identifies itself to receivers placed throughout a building. It makes it possible to keep track of people and objects that it is attached to. Because an active badge is associated to a particular user, it can become a form of ID; for example, an electronic door to a restricted area would only open to authorized users. When I am not in my office, the system detects my current location and forwards phone calls there. When I walk into a lecture hall, the system detects my presence, checks the timetable, deduces that I am there for a WRES3405 lecture, and automatically downloads that day's lecture notes. When the system detects the presence of a team working on a particular project in a meeting room, it checks the room booking system to determine if there is a scheduled meeting. Confirming that it is indeed the case, it downloads and displays the previous minutes on the board. As the meeting progresses, team members may manipulate the board using a tetherless pen that need not touch the screen, but can operate from a few meters away. Using the pen, a team member may point to an object on the board, select it, and modify it.
Pervasive computing is a term that is synonymous with ubiquitous computing. Many interesting projects on pervasive computing are carried out at Carnegie-Mellon University. The Portable Help Desk (PHD) is an application developed under Project Aura that makes use of spatial (a user's relative and absolute position and orientation) and temporal (scheduled time of private and public events) awareness. PHD allows a user to determine the location of colleagues and information about them. It is equipped with the capability to display maps of surrounding areas, indicating resources and nearby people. It also notifies users of the availability of resources they may need, for example, a nearby printer or café. PHD is equipped with visual and audio interfaces, each of which provides support in different contexts; for example, a user who is walking is more likely to prefer an audio interface to interact with PHD.

An important requirement of the applications discussed so far is that for them to offer relevant information to the user (e.g., a café is about 100 m to your left), they need to be aware of their context. This is a very important aspect of mobile computing applications. To be useful, an application needs to be aware of its current environment. For example, if I am currently in Kuching and I request information about seafood restaurants, I expect the application to give me a list of seafood restaurants in Kuching, not Kuala Lumpur. For this reason, a tourist guide application must have context awareness embedded so that it can deliver information that is relevant to the users.
HyperAudio and HIPS are handheld electronic museum guides that adapt their behavior to that of a visitor. A visitor to a museum is given a handheld device equipped with headphones. As the visitor approaches an exhibit, the system dynamically composes a presentation of the object in sight. When the system detects that a visitor pauses in front of a display, it presents information about it. The information is presented in the form of audio recording, a relevant image, and a set of links for obtaining more information about it. The system obtains an estimate of the distance between the visitor and the display and adapts the way the information is presented. For example, if it detects that the visitor is standing right in front of the display, the audio message would say, "this item is. . . ." If the visitor is a distance away, it may attract his attention to it by saying, "the display in front of you . . ." or "the display to your left is. . . ." The system deduces that the visitor is very interested in the display if he or she pauses in front of it for more than a certain period of time and proceeds to present more detailed information about it. As the visitor moves away to view another display, the system detects the distance between the current display and the next one and starts to download the presentation for the next display.

Another class of information that makes use of wireless technology is wearable computing, which involves integrating computers into our clothes to perform certain functions, for example, monitor the wearer's heartbeat and blood pressure. There are many practical and useful applications of wearable computing. Guide dogs and canes are very useful in assisting visually impaired people to avoid obstacles and negotiate changes in ground level, such as steps. However, they are not helpful in avoiding higher obstacles such as street signs and tree branches. This difficulty may be overcome with the use of a wearable headset consisting of a laptop, a video camera with infrared (IR) light emitting diodes mounted on one side of an eyeglass frame, and a scanning fiber display and optics mounted in a tube. The software comprises a machine vision program that identifies potential collision objects, a program that controls the display, and a graphical user interface (GUI) to help set parameters for the embedded processors and generate bright warning icons.

A more recent technology is a wireless sensor network (WSN). In a WSN, sensors are placed at strategic locations to monitor certain aspects of the environment. For example, biologists may use it for habitat monitoring to study behavioral patterns of a species. The use of sensor networks assists ecologists to accurately measure the degree of micro-environmental variance that organisms experience. Data collected by scientists regarding population dynamics and habitat needs is important in conservation biology, landscape monitoring and management, and species-recovery efforts. Sensor nodes are also used to monitor personnel and mobile assets; for example, an alarm is triggered when a printer is detected leaving an office area without authorization. One application of this technology is in agriculture, where sensors are used to monitor environmental conditions that may affect the crop. Early detection and alert of a change in temperature, for example, would help farmers to take precautionary steps to protect their crops.

Another novel invention using wireless technology is the virtual fence. Cowboys on horsebacks herding cattle might one day become a feature of a bygone era as the introduction of virtual fences allows ranchers to herd their cattle from the comfort of their homes. The virtual fence is downloaded to the cows by transmitting GPS coordinates to head collars worn by the cows. The dynamic virtual fences are moved along desired trajectories. The collars are equipped with a wireless fidelity (Wi-Fi) networking card, a Zaurus PDA, an eTrex GPS unit, and a loudspeaker that transmits occurring sounds (e.g., roaring tigers, barking dogs) when a cow strays from the intended path. This multidisciplinary project, the brain child of a biologist, is made possible in collaboration with computer scientists.

Sensor technology can potentially play an important role in search and rescue operations by first responders (i.e., emergency personnel), such as firefighters, paramedics, and police, who arrive at the scene immediately after an event (e.g., a fire, an earthquake, a building collapse) occurs. Firefighters wear tags to allow easy tracking of their movements to coordinate search and rescue operations more effectively. The firefighters can be informed if a particular section of a building is found to be unstable and is about to collapse, and they are directed to evacuate it immediately. A wireless vital sign monitor is attached to victims found trapped so that their condition can be monitored to ensure that they receive the appropriate medical attention as soon as they are rescued. This noninvasive sensor monitors vital signs such as heart rate, oxygen saturation, and serum chemistry measurements. The vital sign monitor helps the paramedic team determine which victims' conditions are more critical so that they can prioritize medical attention to more severely injured victims. The application and architecture required to support this emergency response application is being developed under the CodeBlue project at Harvard University.

Wireless technology is also used in healthcare. The Arrhythmia Monitoring System (AMS) is a medical telemetry (telemedicine) system that makes use of wireless technology to monitor patients suffering from arrhythmia (Liszka et al. 2004). Among the complications that arise from arrhythmia are the loss of regular heartbeat and subsequent loss of function and rapid heartbeats. AMS provides a means for healthcare professionals to continuously monitor a patient's electrical cardiac rhythms remotely even though the patient is not at the hospital. This technology allows patients to be in the comfort of their homes without jeopardizing their health. It is also useful for monitoring the heart functions of astronauts who are more susceptible to cardiac dysrhythmias when in space.

The system architecture consists of a wearable server, a central server, and a call center. The wearable server is a small communications device worn by the patient that collects the patient's electrocardiogram ([ECG], i.e., the heart muscles' electrical activity). The data is collected using wires attached to skin-contact biosensors. The wearable server receives analog signals from the sensors and converts them into digital signals. Data is collected every 4 ms and requires a minimum baud rate of 22.5 kbps to transmit over a wireless link to the central server.

The central server is located close to the patient. Its functions are data compression, location awareness utilizing GPS, and rudimentary arrhythmia detection. It serves as a wireless gateway to a long-distance cellular network. Data is routed via the call center that is manned 24/7, by healthcare professionals who monitor the ECG signals and respond to alerts. The system transmits an alert automatically if it detects that the patient is about to have or is having an arrhythmia attack. A patient can press a button on the wearable server to send a non-critical alert to the call center if the heart flutters or other unusual feeling occurs. There is also a panic button that a patient can press to send a critical alert for help so that an emergency response team can be rushed to the most recent GPS location.

The GPS location service is a critical part of the system as it is imperative that an emergency response team is dispatched in the quickest time possible. A patient's location is tracked using a GPS transceiver equipped with a 1.55 GHz GPS antenna and a 2.4 GHz Bluetooth antenna. The location information is sent to the receiver every 10 s and acquires a minimum of three GSP satellite signals. A patient's location can be accurately tracked within 10 m.
Another category of mobile applications that is gaining popularity is mobile commerce or m-commerce, which is likely to become an important application of this technology. M-commerce application can be classified into ten types:

1. Mobile financial application (business-to-customer [B2C] and business-to-business [B2B]): The mobile device is used as a powerful financial medium.

2. Mobile advertising (B2C): It turns the wireless infrastructure and devices into a powerful marketing medium.

3. Mobile inventory management (B2C and B2B) or product locating and shopping (B2C and B2B): It is an attempt to reduce the amount of inventory needed by managing in-house and on-the-move inventory. It also includes applications that help to locate products and services that are needed.

4. Proactive service management (B2C and B2B): It attempts to locate products and services that are needed.

5. Wireless reengineering (B2C and B2B): It focuses on improving the quality of business services using mobile devices and wireless infrastructure.

6. Mobile auction or reverse auction (B2C and B2B): It allows users to buy or sell certain items using multicast support of wireless infrastructure.

7. Mobile entertainment services and games (B2C): It provides entertainment services to users on a per-event or subscription basis.

8. Mobile office (B2C): It provides the complete office environment to mobile users anywhere, anytime.

. Mobile distance education (B2C): It extends distance or virtual education support for mobile uses everywhere.

10. Wireless data center (B2C and B2B): It supports large amounts of stored data to be made available to mobile users for making "intelligent" decisions.
The mobile computing applications discussed so far provide a glimpse of what mobile computing technology has to offer. The applications are used in many different fields and may perform generic functions or be tailored to specific needs. The next section gives an overview the evolution of wireless networks that have made these applications possible.
Evolution of Wireless Networks and Services

The first generation (1G) wireless network was analog. The first in North America was advanced mobile phone system (AMPS), which was based on frequency division multiple access. A total of 1664 channels were available in the 824 to 849 MHz and 869 to 894 MHz band, providing 832 downlink (DL) and 832 uplink (UL) channels. AMPS, widely used in North America, supports frequency reuse. The underlying network is a cellular network where a geographical region is divided into cells. A base station (BS) at the center of the cell transmits signals to and from users within the cell.
The second generation (2G) systems onward are digital. Digital systems make possible an array of new services such as caller ID. The Global System for Mobile Communications (GSM) is a popular 2G system. GSM offers a data rate of 9.6 to 14.4 kbps. It supports international roaming, which means users may have access to wireless services even when traveling abroad. The most popular service offered by GSM is the Short Message Service (SMS), which allows users to send text messages up to 160 characters long.

2.5G systems support more than just voice communications. In addition to text messaging, 2.5G systems offer a data rate on the order of 100 kbps to support various data technologies, such as Internet access. Most 2.5G systems implement packet switching. The 2.5G systems help provide seamless transition technology between 2G and third generation (3G) systems. The following are 2.5G systems:

High-Speed Circuit-Switched Data (HSCSD): Even though most 2.5G systems implement packet switching, HSCSD continues support for circuit-switched data. It offers a data rate of 115 kbps and is designed to enhance GSM networks. The access technology used is time division multiple access (TDMA). It provides support for Web browsing and file transfers.
General Packet Radio Service (GPRS): GPRS offers a data rate of 168 kbps. It enhances the performance and transmission speeds of GSM. GPRS provides always-on connectivity, which means users do not have to reconnect to the network for each transmission. Because there is a maximum of eight slots to transmit calls on one device, it allows more than one transmission at one time; for example, a voice call and an incoming text message can be handled simultaneously.
Enhanced Data Rates for GSM Evolution (EDGE): EDGE works in conjunction with GPRS and TDMA over GSM networks. Its offered data rate is 384 kbps. EDGE supports data communications while voice communications are supported using the technology on existing networks.

Third-generation (3G) wireless systems are designed to support high bit rate telecommunications. 3G systems are designed to meet the requirements of multimedia applications and Internet services. The bit rate offered ranges from 144 kbps for full mobility applications, 384 kbps for limited mobility applications in macro- and microcellular environments, and 2 Mbps for low-mobility applications in micro- and picocellular environments. A very useful service provided by 3G systems is an emergency service with the ability to identify a user's location within 125 m 67% of time. Figure 1.1 shows the evolution of wireless standards.

Initially, the International Telecommunication Union (ITU) intended to design a single 3G standard; however, due to a number of difficulties, it has ratified two 3G standards. The two standards are CDMA2000, which provides a bit rate of up to 2.4 Mbps, and wideband CDMA (WCDMA), which provides a bit rate of up to 8 Mbps. The high bit rate enables new wireless services that can be classified into three categories:

1. Information retrieval: It permits location-aware applications to remotely download information from a corporate database.

2. Mobile commerce: It allows users to book a flight or pay bills.

3. General communication: It permits users to make or receive phone calls, send or receive messages, or activate an air conditioner at home.

Compound wireless service enables users to combine different types of services to carry out specialized functions. For example, you can take a photo using a camera phone and send it to a friend using the multimedia message service (MMS). A more useful application would be to combine a home alarm system with a wireless service so that when an intruder is detected, a photo of the intruder is captured by the surveillance camera and sent to the authorities, while the owner is alerted via mobile phone.

A compound service comprises a fundamental wireless service (one that cannot be partitioned into smaller identifiable services), a utility service (one that carries out a function within a particular compound service sequence), and possibly another compound service. For example, consider a courier service driver who has to deliver a document before a certain deadline and he has to find the fastest and least congested route to his destination. He makes use of a route planning application on the wireless terminal in his van, which consists of three fundamental wireless services:

1. A location service to determine the current location of the driver.

2. A travel route computation to determine the least congested and fastest route to his destination.

3. Traffic information retrieval to obtain traffic information from various sources.
The compound service consists of continuous iterations of these services: determine the current location and provide it to the wireless terminal, compute the least congested route from the current location to the destination, and retrieve the most updated traffic information. It involves executing step 1 and deciding whether to repeat step 2. Going back to step 1 is the utility service.

Summary

Mobile computing is an active area of research. Most applications available to users today are targeted at teenagers and yuppies and are mostly infotainment applications, for example, music downloads, friend locators, news updates. It will probably be a few more years before mobile enterprise applications appear on the market as there are many issues that need to be addressed to efficiently and effectively provide such applications. For this reason, several examples discussed in this book are based on ongoing and experimental work at various universities and research institutes. Therefore, a list of references, bibliographies, and online resources are provided at the end of each chapter so that readers may further explore the topic.

Copied from www.ittoday.info

________________________________________________________________________________________________

How to be a Programmer: A Short, Comprehensive, and Personal Summary

2010-01-25T23:50:00.005+05:30

How to be a Programmer: A Short, Comprehensive, and Personal Summary
Robert L Read
Copyright � 2002, 2003 Robert L. Read
Copyright
Copyright � 2002, 2003
by Robert L. Read. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with one Invariant Section being ‘History (As of February, 2003)’, no Front-Cover Texts, and one Back-Cover Text: ‘The original version of this document was written by Robert L. Read without renumeration and dedicated to the programmers of Hire.com.’ A copy of the license is included in the section entitled ‘GNU Free Documentation License’.
2002
________________________________________
Dedication
To the programmers of Hire.com.
Table of Contents
1. Introduction
2. Beginner
Personal Skills
Learn to Debug
How to Debug by Splitting the Problem Space
How to Remove an Error
How to Debug Using a Log
How to Understand Performance Problems
How to Fix Performance Problems
How to Optimize Loops
How to Deal with I/O Expense
How to Manage Memory
How to Deal with Intermittent Bugs
How to Learn Design Skills
How to Conduct Experiments
Team Skills
Why Estimation is Important
How to Estimate Programming Time
How to Find Out Information
How to Utilize People as Information Sources
How to Document Wisely
How to Work with Poor Code
How to Use Source Code Control
How to Unit Test
Take Breaks when Stumped
How to Recognize When to Go Home
How to Deal with Difficult People
3. Intermediate
Personal Skills
How to Stay Motivated
How to be Widely Trusted
How to Tradeoff Time vs. Space
How to Stress Test
How to Balance Brevity and Abstraction
How to Learn New Skills
Learn to Type
How to Do Integration Testing
Communication Languages
Heavy Tools
How to analyze data
Team Skills
How to Manage Development Time
How to Manage Third-Party Software Risks
How to Manage Consultants
How to Communicate the Right Amount
How to Disagree Honestly and Get Away with It
Judgement
How to Tradeoff Quality Against Development Time
How to Manage Software System Dependence
How to Decide if Software is Too Immature
How to Make a Buy vs. Build Decision
How to Grow Professionally
How to Evaluate Interviewees
How to Know When to Apply Fancy Computer Science
How to Talk to Non-Engineers
4. Advanced
Technological Judgment
How to Tell the Hard From the Impossible
How to Utilize Embedded Languages
Choosing Languages
Compromising Wisely
How to Fight Schedule Pressure
How to Understand the User
How to Get a Promotion
Serving Your Team
How to Develop Talent
How to Choose What to Work On
How to Get the Most From Your Teammates
How to Divide Problems Up
How to Handle Boring Tasks
How to Gather Support for a Project
How to Grow a System
How to Communicate Well
How to Tell People Things They Don't Want to Hear
How to Deal with Managerial Myths
How to Deal with Organizational Chaos
Glossary
A.
B. History (As Of February, 2003)
C. GNU Free Documentation License
PREAMBLE
APPLICABILITY AND DEFINITIONS
VERBATIM COPYING
COPYING IN QUANTITY
MODIFICATIONS
COMBINING DOCUMENTS
COLLECTIONS OF DOCUMENTS
AGGREGATION WITH INDEPENDENT WORKS
TRANSLATION
TERMINATION
FUTURE REVISIONS OF THIS LICENSE
ADDENDUM: How to use this License for your documents
Chapter�1.�Introduction
Table of Contents
To be a good programmer is difficult and noble. The hardest part of making real a collective vision of a software project is dealing with one's coworkers and customers. Writing computer programs is important and takes great intelligence and skill. But it is really child's play compared to everything else that a good programmer must do to make a software system that succeeds for both the customer and myriad colleagues for whom she is partially responsible. In this essay I attempt to summarize as concisely as possible those things that I wish someone had explained to me when I was twenty-one.
This is very subjective and, therefore, this essay is doomed to be personal and somewhat opinionated. I confine myself to problems that a programmer is very likely to have to face in her work. Many of these problems and their solutions are so general to the human condition that I will probably seem preachy. I hope in spite of this that this essay will be useful.
Computer programming is taught in courses. The excellent books: The Pragmatic Programmer [Prag99], Code Complete [CodeC93], Rapid Development [RDev96], and Extreme Programming Explained [XP99] all teach computer programming and the larger issues of being a good programmer. The essays of Paul Graham[PGSite] and Eric Raymond[Hacker] should certainly be read before or along with this article. This essay differs from those excellent works by emphasizing social problems and comprehensively summarizing the entire set of necessary skills as I see them.
In this essay the term boss to refer to whomever gives you projects to do. I use the words business, company, and tribe, synonymously except that business connotes moneymaking, company connotes the modern workplace and tribe is generally the people you share loyalty with.
Welcome to the tribe.
Chapter�2.�Beginner
Table of Contents
Personal Skills
Learn to Debug
How to Debug by Splitting the Problem Space
How to Remove an Error
How to Debug Using a Log
How to Understand Performance Problems
How to Fix Performance Problems
How to Optimize Loops
How to Deal with I/O Expense
How to Manage Memory
How to Deal with Intermittent Bugs
How to Learn Design Skills
How to Conduct Experiments
Team Skills
Why Estimation is Important
How to Estimate Programming Time
How to Find Out Information
How to Utilize People as Information Sources
How to Document Wisely
How to Work with Poor Code
How to Use Source Code Control
How to Unit Test
Take Breaks when Stumped
How to Recognize When to Go Home
How to Deal with Difficult People
Personal Skills
Learn to Debug
Debugging is the cornerstone of being a programmer. The first meaning of the verb to debug is to remove errors, but the meaning that really matters is to see into the execution of a program by examining it. A programmer that cannot debug effectively is blind.
Idealists that think design, or analysis, or complexity theory, or whatnot, are more fundamental are not working programmers. The working programmer does not live in an ideal world. Even if you are perfect, your are surrounded by and must interact with code written by major software companies, organizations like GNU, and your colleagues. Most of this code is imperfect and imperfectly documented. Without the ability to gain visibility into the execution of this code the slightest bump will throw you permanently. Often this visibility can only be gained by experimentation, that is, debugging.
Debugging is about the running of programs, not programs themselves. If you buy something from a major software company, you usually don't get to see the program. But there will still arise places where the code does not conform to the documentation (crashing your entire machine is a common and spectacular example), or where the documentation is mute. More commonly, you create an error, examine the code you wrote and have no clue how the error can be occurring. Inevitably, this means some assumption you are making is not quite correct, or some condition arises that you did not anticipate. Sometimes the magic trick of staring into the source code works. When it doesn't, you must debug.
To get visibility into the execution of a program you must be able to execute the code and observe something about it. Sometimes this is visible, like what is being displayed on a screen, or the delay between two events. In many other cases, it involves things that are not meant to be visible, like the state of some variables inside the code, which lines of code are actually being executed, or whether certain assertions hold across a complicated data structure. These hidden things must be revealed.
The common ways of looking into the ‘innards’ of an executing program can be categorized as:
• Using a debugging tool,
• Printlining --- Making a temporary modification to the program, typically adding lines that print information out, and
• Logging --- Creating a permanent window into the programs execution in the form of a log.
Debugging tools are wonderful when they are stable and available, but the printlining and logging are even more important. Debugging tools often lag behind language development, so at any point in time they may not be available. In addition, because the debugging tool may subtly change the way the program executes it may not always be practical. Finally, there are some kinds of debugging, such as checking an assertion against a large data structure, that require writing code and changing the execution of the program. It is good to know how to use debugging tools when they are stable, but it is critical to be able to employ the other two methods.
Some beginners fear debugging when it requires modifying code. This is understandable---it is a little like exploratory surgery. But you have to learn to poke at the code and make it jump; you have to learn to experiment on it, and understand that nothing that you temporarily do to it will make it worse. If you feel this fear, seek out a mentor---we lose a lot of good programmers at the delicate onset of their learning to this fear.
How to Debug by Splitting the Problem Space
Debugging is fun, because it begins with a mystery. You think it should do something, but instead it does something else. It is not always quite so simple---any examples I can give will be contrived compared to what sometimes happens in practice. Debugging requires creativity and ingenuity. If there is a single key to debugging is to use the divide and conquer technique on the mystery.
Suppose, for example, you created a program that should do ten things in a sequence. When you run it, it crashes. Since you didn't program it to crash, you now have a mystery. When out look at the output, you see that the first seven things in the sequence were run successfully. The last three are not visible from the output, so now your mystery is smaller: ‘It crashed on thing #8, #9, or #10.’
Can you design an experiment to see which thing it crashed on? Sure. You can use a debugger or we can add printline statements (or the equivalent in whatever language you are working in) after #8 and #9. When we run it again, our mystery will be smaller, such as ‘It crashed on thing #9.’ I find that bearing in mind exactly what the mystery is at any point in time helps keep one focused. When several people are working together under pressure on a problem it is easy to forget what the most important mystery is.
The key to divide and conquer as a debugging technique is the same as it is for algorithm design: as long as you do a good job splitting the mystery in the middle, you won't have to split it too many times, and you will be debugging quickly. But what is the middle of a mystery? There is where true creativity and experience comes in.
To a true beginner, the space of all possible errors looks like every line in the source code. You don't have the vision you will later develop to see the other dimensions of the program, such as the space of executed lines, the data structure, the memory management, the interaction with foreign code, the code that is risky, and the code that is simple. For the experience programmer, these other dimensions form an imperfect but very useful mental model of all the things that can go wrong. Having that mental model is what helps one find the middle of the mystery effectively.
Once you have evenly subdivided the space of all that can go wrong, you must try to decide in which space the error lies. In the simple case where the mystery is: ‘Which single unknown line makes my program crash?’, you can ask yourself: ‘Is the unknown line executed before or after this line that I judge to be executed in the about the middle of the running program?’ Usually you will not be so lucky as to know that the error exists in a single line, or even a single block. Often the mystery will be more like: ‘Either there is a pointer in that graph that points to the wrong node, or my algorithm that adds up the variables in that graph doesn't work.’ In that case you may have to write a small program to check that the pointers in the graph are all correct in order to decide which part of the subdivided mystery can be eliminated.
How to Remove an Error
I've intentionally separated the act of examining a program's execution from the act of fixing an error. But of course, debugging does also mean removing the bug. Ideally you will have perfect understanding of the code and will reach an ‘A-Ha!’ moment where you perfectly see the error and how to fix it. But since your program will often use insufficiently documented systems into which you have no visibility, this is not always possible. In other cases the code is so complicated that your understanding cannot be perfect.
In fixing a bug, you want to make the smallest change that fixes the bug. You may see other things that need improvement; but don't fix those at the same time. Attempt to employ the scientific method of changing one thing and only one thing at a time. The best process for this is to be able to easily reproduce the bug, then put your fix in place, and then rerun the program and observe that the bug no longer exists. Of course, sometimes more than one line must be changed, but you should still conceptually apply a single atomic change to fix the bug.
Sometimes, there are really several bugs that look like one. It is up to you to define the bugs and fix them one at a time. Sometimes it is unclear what the program should do or what the original author intended. In this case, you must exercise your experience and judgment and assign your own meaning to the code. Decide what it should do, and comment it or clarify it in some way and then make the code conform to your meaning. This is an intermediate or advanced skill that is sometimes harder than writing the original function in the first place, but the real world is often messy. You may have to fix a system you cannot rewrite.
How to Debug Using a Log
Logging is the practice of writing a system so that it produces a sequence of informative records, called a log. Printlining is just producing a simple, usually temporary, log. Absolute beginners must understand and use logs because their knowledge of the programming is limited; system architects must understand and use logs because of the complexity of the system. The amount of information that is provided by the log should be configurable, ideally while the program is running. In general, logs offer three basic advantages:
• Logs can provide useful information about bugs that are hard to reproduce (such as those that occur in the production environment but that cannot be reproduced in the test environment).
• Logs can provide statistics and data relevant to performance, such as the time passing between statements.
• When configurable, logs allow general information to be captured in order to debug unanticipated specific problems without having to modify and/or redeploy the code just to deal with those specific problems.
The amount to output into the log is always a compromise between information and brevity. Too much information makes the log expensive and produces scroll blindness, making it hard to find the information you need. Too little information and it may not contain what you need. For this reason, making what is output configurable is very useful. Typically, each record in the log will identify its position in the source code, the thread that executed it if applicable, the precise time of execution, and, commonly, an additional useful piece of information, such as the value of some variable, the amount of free memory, the number of data objects, etc. These log statements are sprinkled throughout the source code but are particularly at major functionality points and around risky code. Each statement can be assigned a level and will only output a record if the system is currently configured to output that level. You should design the log statements to address problems that you anticipate. Anticipate the need to measure performance.
If you have a permanent log, printlining can now be done in terms of the log records, and some of the debugging statements will probably be permanently added to the logging system.
How to Understand Performance Problems
Learning to understand the performance of a running system is unavoidable for the same reason that learning debugging is. Even if the code you understand perfectly precisely the cost of the code you write, your code will make calls into other software systems that you have little control over or visibility into. However, in practice performance problems are a little different and a little easier than debugging in general.
Suppose that you or your customers consider a system or a subsystem to be too slow. Before you try to make it faster, you must build a mental model of why it is slow. To do this you can use a profiling tool or a good log to figure out where the time or other resources are really being spent. There is a famous dictum that 90% of the time will be spent in 10% of the code. I would add to that the importance of input/output expense (I/O) to performance issues. Often most of the time is spent in I/O in one way or another. Finding the expensive I/O and the expensive 10% of the code is a good first step to building your mental model.
There are many dimensions to the performance of a computer system, and many resources consumed. The first resource to measure is wall--clock time, the total time that passes for the computation. Logging wall-clock time is particularly valuable because it can inform about unpredictable circumstance that arise in situations where other profiling is impractical. However, this may not always represent the whole picture. Sometimes something that takes a little longer but doesn't burn up so many processor seconds will be much better in computing environment you actually have to deal with. Similarly, memory, network bandwidth, database or other server accesses may, in the end, be far more expensive than processor seconds.
Contention for shared resources that are synchronized can cause deadlock and starvation. Deadlock is the inability to proceed because of improper synchronization or resource demands. Starvation is the failure to schedule a component properly. If it can be at all anticipated, it is best to have a way of measuring this contention from the start of your project. Even if this contention does not occur, it is very helpful to be able to assert that with confidence.
How to Fix Performance Problems
Most software projects can be made with relatively little effort 10 to 100 times faster than they are at the they are first released. Under time-to-market pressure, it is both wise and effective to choose a solution that gets the job done simply and quickly, but less efficiently than some other solution. However, performance is a part of usability, and often it must eventually be considered more carefully.
The key to improving the performance of a very complicated system is to analyze it well enough to find the bottlenecks, or places where most of the resources are consumed. There is not much sense in optimizing a function that accounts for only 1% of the computation time. As a rule of thumb you should think carefully before doing anything unless you think it is going to make the system or a significant part of it at least twice as fast. There is usually a way to do this. Consider the test and quality assurance effort that your change will require. Each change brings a test burden with it, so it is much better to have a few big changes.
After you've made a two-fold improvement in something, you need to at least rethink and perhaps reanalyze to discover the next-most-expensive bottleneck in the system, and attack that to get another two-fold improvement.
Often, the bottlenecks in performance will be an example of counting cows by counting legs and dividing by four, instead of counting heads. For example, I've made errors such as failing to provide a relational database system with a proper index on a column I look up a lot, which probably made it at least 20 times slower. Other examples include doing unnecessary I/O in inner loops, leaving in debugging statements that are no longer needed, unnecessary memory allocation, and, in particular, inexpert use of libraries and other subsystems that are often poorly documented with respect to performance. This kind of improvement is sometimes called low-hanging fruit, meaning that it can be easily picked to provide some benefit.
What do you do when you start to run out of low-hanging fruit? Well, you can reach higher, or chop the tree down. You can continue making small improvements or you can seriously redesign a system or a subsystem. (This is a great opportunity to use your skills as a good programmer, not only in the new design but also in convincing your boss that this is a good idea.) However, before you argue for the redesign of a subsystem, you should ask yourself whether or not your proposal will make it five to ten time better.
How to Optimize Loops
Sometimes you'll encounter loops, or recursive functions, that take a long time to execute and are bottlenecks in your product. Before you try to make the loop a little faster, but spend a few minutes considering if there is a way to remove it entirely. Would a different algorithm do? Could you compute that while computing something else? If you can't find away around it, then you can optimize the loop. This is simple; move stuff out. In the end, this will require not only ingenuity but also an understanding of the expense of each kind of statement and expression. Here are some suggestions:
• Remove floating point operations.
• Don't allocate new memory blocks unnecessarily.
• Fold constants together.
• Move I/O into a buffer.
• Try not to divide.
• Try not to do expensive typecasts.
• Move a pointer rather than recomputing indices.
The cost of each of these operations depends on your specific system. On some systems compilers and hardware do these things for you. Clear, efficient code is better than code that requires an understanding of a particular platform.
How to Deal with I/O Expense
For a lot of problems, processors are fast compared to the cost of communicating with a hardware device. This cost is usually abbreviated I/O, and can include network cost, disk I/O, database queries, file I/O, and other use of some hardware not very close to the processor. Therefore building a fast system is often more a question of improving I/O than improving the code in some tight loop, or even improving an algorithm.
There are two very fundamental techniques to improving I/O: caching and representation. Caching is avoiding I/O (generally avoiding the reading of some abstract value) by storing a copy of that value locally so no I/O is performed to get the value. The first key to caching is to make it crystal clear which data is the master and which are copies. There is only one master---period. Caching brings with it the danger that the copy is sometimes can't reflect changes to the master instantaneously.
Representation is the approach of making I/O cheaper by representing data more efficiently. This is often in tension with other demands, like human readability and portability.
Representations can often be improved by a factor of two or three from their first implementation. Techniques for doing this include using a binary representation instead of one that is human readable, transmitting a dictionary of symbols along with the data so that long symbols don't have to be encoded, and, at the extreme, things like Huffman encoding.
A third technique that is sometimes possible is to improve the locality of reference by pushing the computation closer to the data. For instance, if you are reading some data from a database and computing something simple from it, such as a summation, try to get the database server to do it for you. This is highly dependent on the kind of system you're working with, but you should explore it.
How to Manage Memory
Memory is a precious resource that you can't afford to run out of. You can ignore it for a while but eventually you will have to decide how to manage memory.
Space that needs to persist beyond the scope of a single subroutine is often called heap allocated. A chunk of memory is useless, hence garbage, when nothing refers to it. Depending on the system you use, you may have to explicitly deallocate memory yourself when it is about to become garbage. More often you may be able to use a system that provides a garbage collector. A garbage collector notices garbage and frees its space without any action required by the programmer. Garbage collection is wonderful: it lessens errors and increases code brevity and concision cheaply. Use it when you can.
But even with garbage collection, you can fill up all memory with garbage. A classic mistake is to use a hash table as a cache and forget to remove the references in the hash table. Since the reference remains, the referent is noncollectable but useless. This is called a memory leak. You should look for and fix memory leaks early. If you have long running systems memory may never be exhausted in testing but will be exhausted by the user.
The creation of new objects is moderately expensive on any system. Memory allocated directly in the local variables of a subroutine, however, is usually cheap because the policy for freeing it can be very simple. You should avoid unnecessary object creation.
An important case occurs when you can define an upper bound on the number of objects you will need at one time. If these objects all take up the same amount of memory, you may be able to allocate a single block of memory, or a buffer, to hold them all. The objects you need can be allocated and released inside this buffer in a set rotation pattern, so it is sometimes called a ring buffer. This is usually faster than heap allocation.
Sometimes you have to explicitly free allocated space so it can be reallocated rather than rely on garbage collection. Then you must apply careful intelligence to each chunk of allocated memory and design a way for it to be deallocated at the appropriate time. The method may differ for each kind of object you create. You must make sure that every execution of a memory allocating operation is matched by a memory deallocating operation eventually. This is so difficult that programmers often simply implement a rudimentary form or garbage collection, such as reference counting, to do this for them.
How to Deal with Intermittent Bugs
The intermittent bug is a cousin of the 50-foot-invisible-scorpion-from-outer-space kind of bug. This nightmare occurs so rarely that it is hard to observe, yet often enough that it can't be ignored. You can't debug because you can't find it.
Although after 8 hours you will start to doubt it, the intermittent bug has to obey the same laws of logic everything else does. What makes it hard is that it occurs only under unknown conditions. Try to record the circumstances under which the bug does occur, so that you can guess at what the variability really is. The condition may be related to data values, such as ‘This only happens when we enter Wyoming as a value.’ If that is not the source of variability, the next suspect should be improperly synchronized concurrency.
Try, try, try to reproduce the bug in a controlled way. If you can't reproduce it, set a trap for it by building a logging system, a special one if you have to, that can log what you guess you need when it really does occur. Resign yourself to that if the bug only occurs in production and not at your whim, this is may be a long process. The hints that you get from the log may not provide the solution but may give you enough information to improve the logging. The improved logging system may take a long time to be put into production. Then, you have to wait for the bug to reoccur to get more information. This cycle can go on for some time.
The stupidest intermittent bug I ever created was in a multi-threaded implementation of a functional programming language for a class project. I had very carefully insured correct concurrent evaluation of the functional program, good utilization of all the CPUs available (eight, in this case). I simply forgot to synchronize the garbage collector. The system could run a long time, often finishing whatever task I began, before anything noticeable went wrong. I'm ashamed to admit I had begun to question the hardware before my mistake dawned on me.
At work we recently had an intermittent bug that took us several weeks to find. We have multi-threaded application servers in Java™ behind Apache™ web servers. To maintain fast page turns, we do all I/O in small set of four separate threads that are different than the page-turning threads. Every once in a while these would apparently get ‘stuck’ and cease doing anything useful, so far as our logging allowed us to tell, for hours. Since we had four threads, this was not in itself a giant problem---unless all four got stuck. Then the queues emptied by these threads would quickly fill up all available memory and crash our server. It took us about a week to figure this much out, and we still didn't know what caused it, when it would happen, or even what the threads where doing when they got ‘stuck’.
This illustrates some risk associated with third-party software. We were using a licensed piece of code that removed HTML tags from text. Due to its place of origin we affectionately referred to this as ‘the French stripper.’ Although we had the source code (thank goodness!) we had not studied it carefully until by turning up the logging on our servers we finally realized that the email threads were getting stuck in the French stripper.
The stripper performed well except on some long and unusual kinds of texts. On these texts, the code was quadratic or worse. This means that the processing time was proportional to the square of the length of the text. Had these texts occurred commonly, we would have found the bug right away. If they had never occurred at all, we would never have had a problem. As it happens, it took us weeks to finally understand and resolve the problem.
How to Learn Design Skills
To learn how to design software, study the action of a mentor by being physically present when they are designing. Then study well-written pieces of software. After that, you can read some books on the latest design techniques.
Then you must do it yourself. Start with a small project. When you are finally done, consider how the design failed or succeeded and how you diverged from your original conception. They move on to larger projects, hopefully in conjunction with other people. Design is a matter of judgment that takes years to acquire. A smart programmer can learn the basics adequately in two months and can improve from there.
It is natural and helpful to develop your own style, but remember that design is an art, not a science. People who write books on the subject have a vested interest in making it seem scientific. Don't become dogmatic about particular design styles.
How to Conduct Experiments
The late, great Edsger Dijkstra has eloquently explained that Computer Science is not an experimental science[ExpCS] and doesn't depend on electronic computers. As he puts it referring to the 1960s[Knife],
...the harm was done: the topic became known as “computer science”---which, actually, is like referring to surgery as “knife science” --- and it was firmly implanted in people's minds that computing science is about machines and their peripheral equipment.
Programming ought not to be an experimental science, but most working programmers do not have the luxury of engaging in what Dijkstra means by computing science. We must work in the realm of experimentation, just as some, but not all, physicists do. If thirty years from now programming can be performed without experimentation, it will be a great accomplishment of Computer Science.
The kinds of experiments you will have to perform include:
• Testing systems with small examples to verify that they conform to the documentation or to understand their response when there is no documentation,
• Testing small code changes to see if they actually fix a bug,
• Measuring the performance of a system under two different conditions due to imperfect knowledge of there performance characteristics,
• Checking the integrity of data, and
• Collecting statistics that may hint at the solution to difficult or hard-to-repeat bugs.
I don't think in this essay I can explain the design of experiments; you will have to study and practice. However, I can offer two bits of advice.
First, try to be very clear about your hypothesis, or the assertion that you are trying to test. It also helps to write the hypothesis down, especially if you find yourself confused or are working with others.
You will often find yourself having to design a series of experiments, each of which is based on the knowledge gained from the last experiment. Therefore, you should design your experiments to provide the most information possible. Unfortunately, this is in tension with keeping each experiment simple---you will have to develop this judgment through experience.
Team Skills
Why Estimation is Important
To get a working software system in active use as quickly as possible requires not only planning the development, but also planning the documentation, deployment, marketing. In a commercial project it also requires sales and finance. Without predictability of the development time, it is impossible to plan these effectively.
Good estimation provides predictability. Managers love it, as well they should. The fact that it is impossible, both theoretically and practically, to predict accurately how long it will take to develop software is often lost on managers. We are asked to do this impossible thing all the time, and we must face up to it honestly. However, it would be dishonest not to admit the impossibility of this task, and when necessary, explain it. There is a lot of room for miscommunication about estimates, as people have a startling tendency to think wishfully that the sentence:
I estimate that, if I really understand the problem, it is about 50% likely that we will be done in five weeks (if no one bothers us during that time).
really means:
I promise to have it all done five weeks from now.
This common interpretation problem requires that you explicitly discuss what the estimate means with your boss or customer as if they were a simpleton. Restate your assumptions, no matter how obvious they seem to you.
How to Estimate Programming Time
Estimation takes practice. It also takes labor. It takes so much labor it may be a good idea to estimate the time it will take to make the estimate, especially if you are asked to estimate something big.
When asked to provide an estimate of something big, the most honest thing to do is to stall. Most engineers are enthusiastic and eager to please, and stalling certainly will displease the stalled. But an on-the-spot estimate probably won't be accurate and honest.
While stalling, it may be possible to consider doing or prototyping the task. If political pressure permits, this is the most accurate way of producing the estimate, and it makes real progress.
When not possible to take the time for some investigation, you should first establish the meaning of the estimate very clearly. Restate that meaning as the first and last part of your written estimate. Prepare a written estimate by deconstructing the task into progressively smaller subtasks until each small task is no more than a day; ideally at most in length. The most important thing is not to leave anything out. For instance, documentation, testing, time for planning, time for communicating with other groups, and vacation time are all very important. If you spend part of each day dealing with knuckleheads, put a line item for that in the estimate. This gives your boss visibility into what is using up your time at a minimum, and might get you more time.
I know good engineers who pad estimates implicitly, but I recommend that you do not. One of the results of padding is trust in you may be depleted. For instance, an engineer might estimate three days for a task that she truly thinks will take one day. The engineer may plan to spend two days documenting it, or two days working on some other useful project. But it will be detectable that the task was done in only one day (if it turns out that way), and the appearance of slacking or overestimating is born. It's far better to give proper visibility into what you are actually doing. If documentation takes twice as long as coding and the estimate says so, tremendous advantage is gained by making this visible to the manager.
Pad explicitly instead. If a task will probably take one day---but might take ten days if your approach doesn't work---note this somehow in the estimate if you can; if not, at least do an average weighted by your estimates of the probabilities. Any risk factor that you can identify and assign an estimate to should go into the schedule. One person is unlikely to be sick in any given week. But a large project with many engineers will have some sick time; likewise vacation time. And what is the probability of a mandatory company-wide training seminar? If it can be estimated, stick it in. There are of course, unknown unknowns, or unk-unks. Unk-unks by definition cannot be estimated individually. You can try to create a global line item for all unk-unks, or handle them in some other way that you communicate to your boss. You cannot, however, let your boss forget that they exist, and it is devilishly easy for an estimate to become a schedule without the unk-unks considered.
In a team environment, you should try to have the people who will do the work do the estimate, and you should try to have team-wide consensus on estimates. People vary widely in skill, experience, preparedness, and confidence. Calamity strikes when a strong programmer estimates for herself and then weak programmers are held to this estimate. The act of having the whole team agree on a line-by-line basis to the estimate clarifies the team understanding, as well as allowing the opportunity for tactical reassignment of resources (for instance, shifting burden away from weaker team members to stronger).
If there are big risks that cannot be evaluated, it is your duty to state so forcefully enough that your manager does not commit to them and then become embarrassed when the risk occurs. Hopefully in such a case whatever is needed will be done to decrease the risk.
If you can convince your company to use Extreme Programming, you will only have to estimate relatively small things, and this is both more fun and more productive.
How to Find Out Information
The nature of what you need to know determines how you should find it.
If you need information about concrete things that are objective and easy to verify, for example the latest patch level of a software product, ask a large number of people politely by searching the internet for it or by posting on a discussion group. Don't search on the internet for anything that smacks of either opinion or subjective interpretation: the ratio of drivel to truth is too high.
If you need general knowledge about something subjective the history of what people have thought about it, go to the library (the physical building in which books are stored). For example, to learn about math or mushrooms or mysticism, go to the library.
If you need to know how to do something that is not trivial get two or three books on the subject and read them. You might learn how to do something trivial, like install a software package, from the Internet. You can even learn important things, like good programming technique, but you can easily spend more time searching and sorting the results and attempting to divine the authority of the results than it would take to read the pertinent part of a solid book.
If you need information that no one else could be expected to know for example, ‘does this software that is brand new work on gigantic data sets?’, you must still search the internet and the library. After those options are completely exhausted, you may design an experiment to ascertain it.
If you want an opinion or a value judgment that takes into account some unique circumstance, talk to an expert. For instance, if you want to know whether or not it is a good idea to build a modern database management system in LISP, you should talk to a LISP expert and a database expert.
If you want to know how likely it is that a faster algorithm for a particular application exists that has not yet been published, talk to someone working in that field.
If you want to make a personal decision that only you can make like whether or not you should start a business, try putting into writing a list of arguments for and against the idea. If that fails, consider divination. Suppose you have studied the idea from all angles, have done all your homework, and worked out all the consequences and pros and cons in your mind, and yet still remain indecisive. You now must follow your heart and tell your brain to shut up. The multitude of available divination techniques are very useful for determining your own semi-conscious desires, as they each present a complete ambiguous and random pattern that your own subconscious will assign meaning to.
How to Utilize People as Information Sources
Respect every person's time and balance it against your own. Asking someone a question accomplishes far more than just receiving the answer. The person learns about you, both by enjoying your presence and hearing the particular question. You learn about the person in the same way, and you may learn the answer you seek. This is usually far more important than your question.
However, the value of this diminishes the more you do it. You are, after all, using the most precious commodity a person has: their time. The benefits of communication must be weighed against the costs. Furthermore, the particular costs and benefits derived differ from person to person. I strongly believe that an executive of 100 people should spend five minutes a month talking to each person in her organization, which would be about 5% of their time. But ten minutes might be too much, and five minutes is too much if they have one thousand employees. The amount of time you spend talking to each person in your organization depends on their role (more than their position). You should talk to your boss more than your boss's boss, but you should talk to your boss's boss a little. It may be uncomfortable, but I believe you have a duty to talk a little bit to all your superiors, each month, no matter what.
The basic rule is that everyone benefits from talking to you a little bit, and the more they talk to you, the less benefit they derive. It is your job to provide them this benefit, and to get the benefit of communicating with them, keeping the benefit in balance with the time spent.
It is important to respect your own time. If talking to someone, even if it will cost them time, will save you a great deal of time, then you should do it unless you think their time is more valuable than yours, to the tribe, by that factor.
A strange example of this is the summer intern. A summer intern in a highly technical position can't be expected to accomplish too much; they can be expected to pester the hell out of everybody there. So why is this tolerated? Because the pestered are receiving something important from the intern. They get a chance to showoff a little. They get a chance to hear some new ideas, maybe; they get a chance to see things from a different perspective. They may also be trying to recruit the intern, but even if this is not the case there is much to gain.
You should ask people for a little bit of their wisdom and judgment whenever you honestly believe they have something to say. This flatters them and you will learn something and teach them something. A good programmer does not often need the advice of a Vice President of Sales, but if you ever do, you be sure to ask for it. I once asked to listen in on a few sales calls to better understand the job of our sales staff. This took no more than 30 minutes but I think that small effort made an impression on the sales force.
How to Document Wisely
Life is too short to write crap nobody will read; if you write crap, nobody will read it. Therefore a little good documentation is best. Managers often don't understand this, because even bad documentation gives them a false sense of security that they are not dependent on their programmers. If someone absolutely insists that you write truly useless documentation, say ``yes'' and quietly begin looking for a better job.
There's nothing quite as effective as putting an accurate estimate of the amount of time it will take to produce good documentation into an estimate to slacken the demand for documentation. The truth is cold and hard: documentation, like testing, can take many times longer than developing code.
Writing good documentation is, first of all, good writing. I suggest you find books on writing, study them, and practice. But even if you are a lousy writer or have poor command of the language in which you must document, the Golden Rule is all you really need: ``Do unto others as you would have them do unto you.'' Take time to really think about who will be reading your documentation, what they need to get out of it, and how you can teach that to them. If you do that, you will be an above average documentation writer, and a good programmer.
When it comes to actually documenting code itself, as opposed to producing documents that can actually be read by non-programmers, the best programmers I've ever known hold a universal sentiment: write self-explanatory code and only document code in the places that you cannot make it clear by writing the code itself. There are two good reasons for this. First, anyone who needs to see code-level documentation will in most cases be able to and prefer to read the code anyway. Admittedly, this seems easier to the experienced programmer than to the beginner. More importantly however, is that the code and the documentation cannot be inconsistent if there is no documentation. The source code can at worst be wrong and confusing. The documentation, if not written perfectly, can lie, and that is a thousand times worse.
This does not make it easier on the responsible programmer. How does one write self-explanatory code? What does that even mean? It means:
• Writing code knowing that someone will have to read it;
• Applying the golden rule;
• Choosing a solution that is straightforward, even if you could get by with another solution faster;
• Sacrificing small optimizations that obfuscate the code;
• Thinking about the reader and spending some of your precious time to make it easier on her; and
• Not ever using a function name like ``foo'',``bar'', or ``doIt''!
How to Work with Poor Code
It is very common to have to work with poor quality code that someone else has written. Don't think too poorly of them, however, until you have walked in their shoes. They may have been asked very consciously to get something done quickly to meet schedule pressure. Regardless, in order to work with unclear code you must understand it. To understand it takes learning time, and that time will have to come out of some schedule, somewhere, and you must insist on it. To understand it, you will have to read the source code. You will probably have to experiment with it.
This is a good time to document, even if it is only for yourself, because the act of trying to document the code will force you to consider angles you might not have considered, and the resulting document may be useful. While you're doing this, consider what it would take to rewrite some or all of the code. Would it actually save time to rewrite some of it? Could you trust it better if you rewrote it? Be careful of arrogance here. If you rewrite it, it will be easier for you to deal with, but will it really be easier for the next person who has to read it? If you rewrite it, what will the test burden be? Will the need to re-test it outweigh any benefits that might be gained?
In any estimate that you make for work against code you didn't write, the quality of that code should affect your perception of the risk of problems and unk-unks.
It is important to remember that abstraction and encapsulation, two of a programmer's best tools, are particularly applicable to lousy code. You may not be able to redesign a large block of code, but if you can add a certain amount of abstraction to it you can obtain some of the benefits of a good design without reworking the whole mess. In particular, you can try to wall off the parts that are particularly bad so that they may be redesigned independently.
How to Use Source Code Control
Source code control systems let you manage projects effectively. They're very useful for one person and essential for a group. They track all changes in different versions so that no code is ever lost and meaning can be assigned to changes. One can create throw-away and debugging code with confidence with a source code control system, since the code you modify is kept carefully separate from committed, official code that will be shared with the team or released.
I was late to appreciate the benefits of source code control systems but now I wouldn't live without one even on a one-person project. Generally they are necessary when you have team working on the same code base. However, they have another great advantage: they encourage thinking about the code as a growing, organic system. Since each change is marked as a new revision with a new name or number, one begins to think of the software as a visibly progressive series of improvements. I think this is especially useful for beginners.
A good technique for using a source code control system is to stay within a few days of being up-to-date at all time. Code that can't be finished in a few days is checked in, but in a way that it is inactive and will not be called, and therefore not create any problems for anybody else. Committing a mistake that slows down your teammates is a serious error; it is often taboo.
How to Unit Test
Unit testing, the testing of an individual piece of coded functionality by the team that wrote it, is a part of coding, not something different from it. Part of designing the code is designing how it will be tested. You should write down a test plan, even if it is only one sentence. Sometimes the test will be simple: ``Does the button look good?'' Sometimes it will be complex: ``Did this matching algorithm return precisely the correct matches?''
Use assertion checking and test drivers whenever possible. This not only catches bugs early, but is very useful later on and lets you eliminate mysteries that you would otherwise have to worry about.
The Extreme Programming developers are writing extensively on unit testing effectively; I can do no better than to recommend their writings.
Take Breaks when Stumped
When stumped, take a break. I sometimes meditate for 15 minutes when stumped and the problem magically unravels when I come back to it. A night's sleep sometimes does the same thing on a larger scale. It's possible that temporarily switching to any other activity may work.
How to Recognize When to Go Home
Computer programming is an activity that is also a culture. The unfortunate fact is that it is not a culture that values mental or physical health very much. For both cultural/historical reasons (the need to work at night on unloaded computers, for example) and because of overwhelming time-to-market pressure and the scarcity of programmers, computer programmers are traditionally overworked. I don't think you can trust all the stories you hear, but I think 60 hours a week is common, and 50 is pretty much a minimum. This means that often much more than that is required. This is serious problem for a good programmer, who is responsible not only for themselves but their teammates as well. You have to recognize when to go home, and sometimes when to suggest that other people go home. There can't be any fixed rules for solving this problem, anymore than there can be fixed rules for raising a child, for the same reason---every human being is different.
Beyond 60 hours a week is an extraordinary effort for me, which I can apply for short periods of time (about one week), and that is sometimes expected of me. I don't know if it is fair to expect 60 hours of work from a person; I don't even know if 40 is fair. I am sure, however, that it is stupid to work so much that you are getting little out of that extra hour you work. For me personally, that's any more than 60 hours a week. I personally think a programmer should exercise noblesse oblige and shoulder a heavy burden. However, it is not a programmer's duty to be a patsy. The sad fact is programmers are often asked to be patsies in order to put on a show for somebody, for example a manager trying to impress an executive. Programmers often succumb to this because they are eager to please and not very good at saying no. There are four defenses against this:
• Communicate as much as possible with everyone in the company so that no one can mislead the executives about what is going on,
• Learn to estimate and schedule defensively and explicitly and give everyone visibility into what the schedule is and where it stands,
• Learn to say no, and say no as a team when necessary, and
• Quit if you have to.
Most programmers are good programmers, and good programmers want to get a lot done. To do that, they have to manage their time effectively. There is a certain amount of mental inertia associated with getting warmed-up to a problem and deeply involved in it. Many programmers find they work best when they have long, uninterrupted blocks of time in which to get warmed-up and concentrate. However, people must sleep and perform other duties. Each person needs to find a way to satisfy both their human rhythm and their work rhythm. Each programmer needs to do whatever it takes to procure efficient work periods, such as reserving certain days in which you will attend only the most critical meetings.
Since I have children, I try to spend evenings with them sometimes. The rhythm that works best for me is to work a very long day, sleep in the office or near the office (I have a long commute from home to work) then go home early enough the next day to spend time with my children before they go to bed. I am not comfortable with this, but it is the best compromise I have been able to work out. Go home if you have a contagious disease. You should go home if you are thinking suicidal thoughts. You should take a break or go home if you think homicidal thoughts for more than a few seconds. You should send someone home if they show serious mental malfunctioning or signs of mental illness beyond mild depression. If you are tempted to be dishonest or deceptive in a way that you normally are not due to fatigue, you should take a break. Don't use cocaine or amphetamines to combat fatigue. Don't abuse caffeine.
How to Deal with Difficult People
You will probably have to deal with difficult people. You may even be a difficult person yourself. If you are the kind of person who has a lot of conflicts with coworkers and authority figures, you should cherish the independence this implies, but work on your interpersonal skills without sacrificing your intelligence or principles.
This can be very disturbing to some programmers who have no experience in this sort of thing and whose previous life experience has taught them patterns of behavior that are not useful in the workplace. Difficult people are often inured to disagreement and they are less affected by social pressure to compromise than others. The key is to respect them appropriately, which is more than you will want to but not as much as they might want.
Programmers have to work together as a team. When disagreement arises, it must be resolved somehow, it cannot be ducked for long. Difficult people are often extremely intelligent and have something very useful to say. It is critical that you listen and understand the difficult person without prejudice caused by the person. A failure to communicate is often the basis of disagreement but it can sometimes be removed with great patience. Try to keep this communication cool and cordial, and don't accept any baits for greater conflict that may be offered. After a reasonable period of trying to understand, make a decision.
Don't let a bully force you to do something you don't agree with. If you are the leader, do what you think is best. Don't make a decision for any personal reasons, and be prepared to explain the reasons for your decision. If you are a teammate with a difficult person, don't let the leader's decision have any personal impact. If it doesn't go your way, do it the other way whole-heartedly.
Difficult people do change and improve. I've seen it with my own eyes, but it is very rare. However, everyone has transitory ups and downs.
One of the challenges that every programmer but especially leaders face is keeping the difficult person fully engaged. They are more prone to duck work and resist passively than others.
Chapter�3.�Intermediate
Table of Contents
Personal Skills
How to Stay Motivated
How to be Widely Trusted
How to Tradeoff Time vs. Space
How to Stress Test
How to Balance Brevity and Abstraction
How to Learn New Skills
Learn to Type
How to Do Integration Testing
Communication Languages
Heavy Tools
How to analyze data
Team Skills
How to Manage Development Time
How to Manage Third-Party Software Risks
How to Manage Consultants
How to Communicate the Right Amount
How to Disagree Honestly and Get Away with It
Judgement
How to Tradeoff Quality Against Development Time
How to Manage Software System Dependence
How to Decide if Software is Too Immature
How to Make a Buy vs. Build Decision
How to Grow Professionally
How to Evaluate Interviewees
How to Know When to Apply Fancy Computer Science
How to Talk to Non-Engineers
Personal Skills
How to Stay Motivated
It is a wonderful and surprising fact that programmers are highly motivated by the desire to create artifacts that are beautiful, useful, or nifty. This desire is not unique to programmers nor universal but it is so strong and common among programmers that it separates them from others in other roles.
This has practical and important consequences. If programmers are asked to do something that is not beautiful, useful, or nifty, they will have low morale. There's a lot of money to be made doing ugly, stupid, and boring stuff; but in the end, fun will make the most money for the company.
Obviously, there are entire industries organized around motivational techniques some of which apply here. The things that are specific to programming that I can identify are:
• Use the best language for the job.
• Look for opportunities to apply new techniques, languages, and technologies.
• Try to either learn or teach something, however small, in each project.
Finally, if possible, measure the impact of your work in terms of something that will be personally motivating. For example, when fixing bugs, counting the number of bugs that I have fixed is not at all motivational to me, because it is independent of the number that may still exist, and is also affects the total value I'm adding to my company's customers in only the smallest possible way. Relating each bug to a happy customer, however, ispersonally motivating to me.
How to be Widely Trusted
To be trusted you must be trustworthy. You must also be visible. If know one knows about you, no trust will be invested in you. With those close to you, such as your teammates, this should not be an issue. You establish trust by being responsive and informative to those outside your department or team. Occasionally someone will abuse this trust, and ask for unreasonable favors. Don't be afraid of this, just explain what you would have to give up doing to perform the favor.
Don't pretend to know something that you don't. With people that are not teammates, you may have to make a clear distinction between ``not knowing right off the top of my head'' and ``not being able to figure it out, ever.''
How to Tradeoff Time vs. Space
You can be a good programmer without going to college, but you can't be a good intermediate programmer without knowing basic computational complexity theory. You don't need to know ``big O'' notation, but I personally think you should be able to understand the difference between ``constant-time'',``n log n'' and ``n squared''. You might be able to intuit how to tradeoff time against space without this knowledge, but in its absence you will not have a firm basis for communicating with your colleagues.
In designing or understanding an algorithm, the amount of time it takes to run is sometimes a function of the size of the input. When that is true, we can say an algorithm's worst/expected/best-case running time is ``n log n'' if it is proportional to the size ($n$) times the logarithm of the size. The notation and way of speaking can be also be applied to the space taken up by a data structure.
To me, computational complexity theory is beautiful and as profound as physics---and a little bit goes a long way!
Time (processor cycles) and space (memory) can be traded off against each other. Engineering is about compromise, and this is a fine example. It is not always systematic. In general, however, one can save space by encoding things more tightly, at the expense of more computation time when you have to decode them. You can save time by caching, that is, spending space to store a local copy of something, at the expense of having to maintain the consistency of the cache. You can sometimes save time by maintaining more information in a data structure. This usually cost a small amount of space but may complicate the algorithm.
Improving the space/time tradeoff can often change one or the other dramatically. However, before you work on this you should ask yourself if what you are improving is really the thing that needs the most improvement. It's fun to work on an algorithm, but you can't let that blind you to the cold hard fact that improving something that is not a problem will not make any noticeable difference and will create a test burden.
Memory on modern computers appears cheap, because unlike processor time, you can't see it being used until you hit the wall; but then failure is catastrophic. There are also other hidden costs to using memory, such as your effect on other programs that must be resident, and the time to allocate and deallocate it. Consider this carefully before you trade away space to gain speed.
How to Stress Test
Stress testing is fun. At first it appears that the purpose of stress testing is to find out if the system works under a load. In reality, it is common that the system does work under a load but fails to work in some way when the load is heavy enough. I call this hitting the wall or bonking[1]. There may be some exceptions, but there is almost always a ‘wall’. The purpose of stress testing is to figure out where the wall is, and then figure out how to move the wall further out.
A plan for stress testing should be developed early in the project, because it often helps to clarify exactly what is expected. Is two seconds for a web page request a miserable failure or a smashing success? Is 500 concurrent users enough? That, of course, depends, but one must know the answer when designing the system that answers the request. The stress test needs to model reality well enough to be useful. It isn't really possible to simulate 500 erratic and unpredictable humans using a system concurrently very easily, but one can at least create 500 simulations and try to model some part of what they might do.
In stress testing, start out with a light load and load the system along some dimension---such as input rate or input size---until you hit the wall. If the wall is too close to satisfy your needs, figure out which resource is the bottleneck (there is usually a dominant one.) Is it memory, processor, I/O, network bandwidth, or data contention? Then figure out how you can move the wall. Note that moving the wall, that is, increasing the maximum load the system can handle, might not help or might actually hurt the performance of a lightly loaded system. Usually performance under heavy load is more important than performance under a light load.
You may have to get visibility into several different dimensions to build up a mental model of it; no single technique is sufficient. For instance, logging often gives a good idea of the wall-clock time between two events in the system, but unless carefully constructed, doesn't give visibility into memory utilization or even data structure size. Similarly, in a modern system, a number of computers and many software systems may be cooperating. Particularly when you are hitting the wall (that is, the performance is non-linear in the size of the input) these other software systems may be a bottleneck. Visibility into these systems, even if only measuring the processor load on all participating machines, can be very helpful.
Knowing where the wall is is essential not only to moving the wall, but also to providing predictability so that the business can be managed effectively.
How to Balance Brevity and Abstraction
Abstraction is key to programming. You should carefully choose how abstract you need to be. Beginning programmers in their enthusiasm often create more abstraction than is really useful. One sign of this is if you create classes that don't really contain any code and don't really do anything except serve to abstract something. The attraction of this is understandable but the value of code brevity must be measured against the value of abstraction. Occasionally, one sees a mistake made by enthusiastic idealists: at the start of the project a lot of classes are defined that seem wonderfully abstract and one may speculate that they will handle every eventuality that may arise. As the project progresses and fatigue sets in, the code itself becomes messy. Function bodies become longer than they should be. The empty classes are a burden to document that is ignored when under pressure. The final result would have been better if the energy spent on abstraction had been spent on keeping things short and simple. This is a form of speculative programming. I strongly recommend the article ``Succinctness is Power'' by Paul Graham[PGSite].
There is a certain dogma associated with useful techniques such as information hiding and object oriented programming that are sometimes taken too far. These techniques let one code abstractly and anticipate change. I personally think, however, that you should not produce much speculative code. For example, it is an accepted style to hide an integer variable on an object behind mutators and accessors, so that the variable itself is not exposed, only the little interface to it. This does allow the implementation of that variable to be changed without affecting the calling code, and is perhaps appropriate to a library writer who must publish a very stable API. But I don't think the benefit of this outweighs the cost of the wordiness of it when my team owns the calling code and hence can recode the caller as easily as the called. Four or five extra lines of code is a heavy price to pay for this speculative benefit.
Portability poses a similar problem. Should code be portable to a different computer, compiler, software system or platform, or simply easily ported? I think a non-portable, short-and-easily-ported piece of code is better than a long portable one. It is relatively easy and certainly a good idea to confine non-portable code to designated areas, such as a class that makes database queries that are specific to a given DBMS.
How to Learn New Skills
Learning new skills, especially non-technical ones, is the greatest fun of all. Most companies would have better morale if they understood how much this motivates programmers.
Humans learn by doing. Book-reading and class-taking are useful. But could you have any respect for a programmer who had never written a program? To learn any skill, you have to put yourself in a forgiving position where you can exercise that skill. When learning a new programming language, try to do a small project it in before you have to do a large project. When learning to manage a software project, try to manage a small one first.
A good mentor is no replacement for doing things yourself, but is a lot better than a book. What can you offer a potential mentor in exchange for their knowledge? At a minimum, you should offer to study hard so their time won't be wasted.
Try to get your boss to let you have formal training, but understand that it often not much better than the same amount of time spent simply playing with the new skill you want to learn. It is, however, easier to ask for training than playtime in our imperfect world, even though a lot of formal training is just sleeping through lectures waiting for the dinner party.
If you lead people, understand how they learn and assist them by assigning them projects that are the right size and that exercise skills they are interested in. Don't forget that the most important skills for a programmer are not the technical ones. Give your people a chance to play and practice courage, honesty, and communication.
Learn to Type
Learn to touch-type. This is an intermediate skill because writing code is so hard that the speed at which you can type is irrelevant and can't put much of a dent in the time it takes to write code, no matter how good you are. However, by the time you are an intermediate programmer you will probably spend a lot of time writing natural language to your colleagues and others. This is a fun test of your commitment; it takes dedicated time that is not much fun to learn something like that. Legend has it that when Michael Tiemann[2] was at MCC people would stand outside his door to listen to the hum generated by his keystrokes which were so rapid as to be indistinguishable.
How to Do Integration Testing
Integration testing is the testing of the integration of various components that have been unit tested. Integration is expensive and it comes out in the testing. You must include time for this in your estimates and your schedule.
Ideally you should organize a project so that there is not a phase at the end where integration must explicitly take place. It is far better to gradually integrate things as they are completed over the course of the project. If it is unavoidable estimate it carefully.
Communication Languages
There are some languages, that is, formally defined syntactic systems, that are not programming languages but communication languages---they are designed specifically to facillitate communication through standardization. In 2003 the most important of these are UML, XML, and SQL. You should have some familiarity with all of these so that you can communicate well and decide when to use them.
UML is a rich formal system for making drawings that describe designs. It's beauty lines in that is both visual and formal, capable of conveying a great deal of information if both the author and the audience know UML. You need to know about it because designs are sometimes communicated in it. There are very helpful tools for making UML drawings that look very professional. In a lot of cases UML is too formal, and I find myself using a simpler boxes and arrows style for design drawings. But I'm fairly sure UML is at least as good for you as studying Latin.
XML is a standard for defining new standards. It is not a solution to data interchange problems, though you sometimes see it presented as if it was. Rather, it is a welcome automation of the most boring part of data interchange, namely, structuring the representation into a linear sequence and parsing back into a structure. It provides some nice type- and correctness-checking, though again only a fraction of what you are likely to need in practicen.
SQL is a very powerful and rich data query and manipulation language that is not quite a programming language. It has many variations, typically quite product-dependent, which are less important than the standardized core. SQL is the lingua franca of relational databases. You may or may not work in any field that can benefit from an understanding of relational databases, but you should have a basic understanding of them and they syntax and meaning of SQL.
Heavy Tools
As our technological culture progresses, software technology moves from inconceivable, to research, to new products, to standardized products, to widely available and inexpensive products. These heavy tools can pull great loads, but can be intimidating and require a large investment in understanding. The intermediate programmer has to know how to manage them and when they should be used or considered.
To my mind right some of the best heavy tools are:
• Relational Databases,
• Full-text Search Engines,
• Math libraries,
• OpenGL,
• XML parsers, and
• Spreadsheets.
How to analyze data
--
Data analysis is a process in the early stages of software development, when you examine a business activity and find the requirements to convert it into a software application. This is a formal definition, which may lead you to believe that data analysis is an action that you should better leave to the systems analysts, while you, the programmer, should focus on coding what somebody else has designed. If we follow strictly the software engineering paradigm, it may be correct. Experienced programmers become designers and the sharpest designers become business analysts, thus being entitled to think about all the data requirements and give you a well defined task to carry out. This is not entirely accurate, because data is the core value of every programming activity. Whatever you do in your programs, you are either moving around or modifying data. The business analyst is analyzing the needs in a larger scale, and the software designer is further squeezing such scale so that, when the problem lands on your desk, it seems that all you need to do is to apply clever algorithms and start moving existing data.
Not so.
No matter at which stage you start looking at it, data is the main concern of a well designed application. If you look closely at how a business analyst gets the requirements out of the customer?s requests, you?ll realize that data plays a fundamental role. The analyst creates so called Data Flow Diagrams, where all data sources are identified and the flow of information is shaped. Having clearly defined which data should be part of the system, the designer will shape up the data sources, in terms of database relations, data exchange protocols, and file formats, so that the task is ready to be passed down to the programmer. However, the process is not over yet, because you ? the programmer ? even after this thorough process of data refinement, are required to analyze data to perform the task in the best possible way. The bottom line of your task is the core message of Niklaus Wirth, the father of several languages. ?Algorithms + Data Structures = Programs.? There is never an algorithm standing alone, doing something to itself. Every algorithm is supposed to do something to at least one piece of data.
Therefore, since algorithms don't spin their wheels in a vacuum, you need to analyze both the data that somebody else has identified for you and the data that is necessary to write down your code. A trivial example will make the matter clearer. You are implementing a search routine for a library. According to your specifications, the user can select books by a combination of genre, author, title, publisher, printing year, and number of pages. The ultimate goal of your routine is to produce a legal SQL statement to search the back-end database. Based on these requirements, you have several choices: check each control in turn, using a "switch" statement, or several "if" ones; make an array of data controls, checking each element to see if it is set; create (or use) an abstract control object from which inherit all your specific controls, and connect them to an event-driven engine. If your requirements include also tuning up the query performance, by making sure that the items are checked in a specific order, you may consider using a tree of components to build your SQL statement. As you can see, the choice of the algorithm depends on the data you decide to use, or to create. Such decisions can make all the difference between an efficient algorithm and a disastrous one. However, efficiency is not the only concern. You may use a dozen named variables in your code and make it as efficient as it can ever be. But such a piece of code might not be easily maintainable. Perhaps choosing an appropriate container for your variables could keep the same speed and in addition allow your colleagues to understand the code better when they look at it next year. Furthermore, choosing a well defined data structure may allow them to extend the functionality of your code without rewriting it. In the long run, your choices of data determines how long your code will survive after you are finished with it. Let me give you another example, just some more food for thought. Let's suppose that your task is to find all the words in a dictionary with more than three anagrams, where an anagram must be another word in the same dictionary. If you think of it as a computational task, you will end up with an endless effort, trying to work out all the combinations of each word and then comparing it to the other words in the list. However, if you analyze the data at hand, you'll realize that each word may be represented by a record containing the word itself and a sorted array of its letters as ID. Armed with such knowledge, finding anagrams means just sorting the list on the additional field and picking up the ones that share the same ID. The brute force algorithm may take several days to run, while the smart one is just a matter of a few seconds. Remember this example the next time you are facing an intractable problem.
Team Skills
How to Manage Development Time
To manage development time, maintain a concise and up-to-date project plan. A project plan is an estimate, a schedule, a set of milestones for marking progress, and an assignment of your team or your own time to each task on the estimate. It should also include other things you have to remember to do, such as meeting with the quality assurance people, preparing documentation, or ordering equipment. If you are on a team, the project plan should be a consensual agreement, both at the start and as you go.
The project plan exists to help make decisions, not to show how organized you are. If the project plan is either too long or not up-to-date, it will be useless for making decisions. In reality, these decisions are about individual persons. The plan and your judgment let you decide if you should shift tasks from one person to another. The milestones mark your progress. If you use a fancy project planning tool, do not be seduced into creating a Big Design Up Front (BDUF) for the project, but use it maintain concision and up-to-dateness.
If you miss a milestone, you should take immediate action such as informing your boss that the scheduled completion of that project has slipped by that amount. The estimate and schedule could never have been perfect to begin with; this creates the illusion that you might be able to make up the days you missed in the latter part of the project. You might. But it is just as likely that you have underestimated that part as that you have overestimated it. Therefore the scheduled completion of the project has already slipped, whether you like it or not.
Make sure you plan includes time for: internal team meetings, demos, documentation, scheduled periodic activities, integration testing, dealing with outsiders, sickness, vacations, maintenance of existing products, and maintenance of the development environment. The project plan can serve as a way to give outsiders or your boss a view into what you or your team is doing. For this reason it should be short and up-to-date.
How to Manage Third-Party Software Risks
A project often depends on software produced by organizations that it does not control. There are great risks associated with third party software that must be recognized by everyone involved.
Never, ever, rest any hopes on vapor. Vapor is any alleged software that has been promised but is not yet available. This is the surest way to go out of business. It is unwise to be merely skeptical of a software company's promise to release a certain product with a certain feature at a certain date; it is far wiser to ignore it completely and forget you ever heard it. Never let it be written down in any documents used by your company.
If third-party software is not vapor, it is still risky, but at least it is a risk that can be tackled. If you are considering using third-party software, you should devote energy early on to evaluating it. People might not like to hear that it will take two weeks or two months to evaluate each of three products for suitability, but it has to be done as early as possible. The cost of integrating cannot be accurately estimated without a proper evaluation.
Understanding the suitability of existing third party software for a particular purpose is very tribal knowledge. It is very subjective and generally resides in experts. You can save a lot of time if you can find those experts. Often times a project will depend on a third-party software system so completely that if the integration fails the project will fail. Express risks like that clearly in writing in the schedule. Try to have a contingency plan, such as another system that can be used or the ability to write the functionality yourself if the risk can't be removed early. Never let a schedule depend on vapor.
How to Manage Consultants
Use consultants, but don't rely on them. They are wonderful people and deserve a great deal of respect. Since they get to see a lot of different projects, they often know more about specific technologies and even programming techniques than you will. The best way to use them is as educators in-house that can teach by example.
However, they usually cannot become part of the team in the same sense that regular employees are, if only because you may not have enough time to learn their strengths and weaknesses. Their financial commitment is much lower. They can move more easily. They may have less to gain if the company does well. Some will be good, some will be average, and some will be bad, but hopefully your selection of consultants will not be as careful as your selection of employees, so you will get more bad ones.
If consultants are going to write code, you must review it carefully as you go along. You cannot get to the end of the a project with the risk of a large block of code that has not been reviewed. This is true of all team members, really, but you will usually have more knowledge of the team members closer to you.
How to Communicate the Right Amount
Carefully consider the cost of a meeting; it costs its duration multiplied by the number of participants. Meetings are sometimes necessary, but smaller is usually better. The quality of communication in small meetings is better, and less time overall is wasted. If any one person is bored at a meeting take this as a sing, that the meeting should be smaller.
Everything possible should be done to encourage informal communication. More useful work is done during lunches with colleagues than during any other time. It is a shame that more companies do not recognize nor support this fact.
How to Disagree Honestly and Get Away with It
Disagreement is a great opportunity to make a good decision, but it should be handled delicately. Hopefully you feel that you have expressed your thoughts adequately and been heard before the decision is made. In that case there is nothing more to say, and you should decide whether you will stand behind the decision even though you disagree with it. If you can support this decision even though you disagree, say so. This shows how valuable you are because you are independent and are not a yes-man, but respectful of the decision and a team player.
Sometimes a decision that you disagree with will be made when the decision makers did not have the full benefit of you opinion. You should then evaluate whether to raise the issue on the basis of the benefit to the company or tribe. If it is a small mistake in your opinion, it may not be worth reconsidering. If it is a large mistake in you opinion, then of course you must present an argument.
Usually, this is not a problem. In some stressful circumstances and with some personality types this can lead to things being taken personally. For instance, some very good programmers lack the confidence needed to challenge a decision even when they have good reason to believe it is wrong. In the worst of circumstances the decision maker is insecure and takes it as a personal challenge to their authority. It is best to remember that in such circumstances people react with the reptilian part of their brains. You should present your argument in private, and try to show how new knowledge changes the basis on which the decision was made.
Whether the decision is reversed or not, you must remember that you will never be able to say ‘I told you so!’ since the alternate decision was fully explored.
Judgement
How to Tradeoff Quality Against Development Time
Software development is always a compromise between what the project does and getting the project done. But you may be asked to tradeoff quality to speed the deployment of a project in a way that offends your engineering sensibilities or business sensibilities. For example, you may be asked to do something that is a poor software engineering practice and that will lead to a lot of maintenance problems.
If this happens your first responsibility is to inform your team and to clearly explain the cost of the decrease in quality. After all, your understanding of it should be much better than your boss's understanding. Make it clear what is being lost and what is being gained, and at what cost the lost ground will be regained in the next cycle. In this, the visibility provided by a good project plan should be helpful. If the quality tradeoff affects the quality assurance effort, point that out (both to your boss and quality assurance people). If the quality tradeoff will lead to more bugs being reported after the quality assurance period, point that out.
If she still insists you should try to isolate the shoddiness into particular components that you can plan to rewrite or improve in the next cycle. Explain this to your team so that they can plan for it.
NinjaProgrammer at Slashdot sent in this gem:
Remember that a good design will be resillient against poor code implementations. If good interfaces and abstractions exist throughout the code, then the eventual rewrites will be far more painless. If it is hard to write clear code that is hard to fix, consider what is wrong with the core design that is causing this.
How to Manage Software System Dependence
Modern software systems tend to depend on a large number of components that may not be directly under your control. This increases productivity through synergy and reuse. However, each component brings with it some problems:
• How will you fix bugs in the component?
• Does the component restrict you to particular hardware or software systems?
• What will you do if the component fails completely?
It is always best to encapsulate the component in some way so that it is isolated and so that it can be swapped out. If the component proves to be completely unworkable, you may be able to get a different one, but you may have to write your own. Encapsulation is not portability, but it makes porting easier, which is almost as good.
Having the source code for a component decreases the risk by a factor of four. With source code, you can evaluate it easier, debug it easier, find workarounds easier, and make fixes easier. If you make fixes, you should give them to the owner of the component and get the fixes incorporated into an official release; otherwise you will uncomfortably have to maintain an unofficial version .
How to Decide if Software is Too Immature
Using software other people wrote is one of the most effective ways to quickly build a solid system. It should not be discouraged, but the risks associated with it must be examined. One of the biggest risks is the period of bugginess and near inoperability that is often associated with software before it matures, through usage, into a usable product. Before you consider integrating with a software system, whether created in house or by a third party, it is very important to consider if it is really mature enough to be used. Here are ten questions you should ask yourself about it:
1. Is it vapor? (Promises are very immature).
2. Is there an accessible body of lore about the software?
3. Are you the first user?
4. Is there a strong incentive for continuation?
5. Has it had a maintenance effort?
6. Will it survive defection of the current maintainers?
7. Is there a seasoned alternative at least half as good?
8. Is it known to your tribe or company?
9. Is it desirable to your tribe or company?
10. Can you hire people to work on it even if it is bad?
A little consideration of these criteria demonstrates the great value of well-established free software and open-source software in reducing risk to the entrepreneur.
How to Make a Buy vs. Build Decision
An entrepreneurial company or project that is trying to accomplish something with software has to constantly make so-called buy vs. build decisions. This turn of phrase is unfortunate in two ways: it seems to ignore open-source and free software which is not necessarily bought. Even more importantly, it should perhaps be called an obtain and integrate vs. build here and integrate decision because the cost of integration must be considered. This requires a great combination of business, management, and engineering savvy.
• How well do your needs match those for which it was designed?
• What portion of what you buy will you need?
• What is the cost of evaluating the integration?
• What is the cost of integration?
• What is the cost of evaluating the integration?
• Will buying increase or decrease long term maintenance costs?
• Will building it put you in a business position you don't want to be in?
You should think twice before building something that is big enough to serve as the basis for an entire other business. Such ideas are often proposed by bright and optimistic people that will have a lot to contribute to your team. If their idea is compelling, you may wish to change your business plan; but do not invest in a solution bigger than your own business without conscious thought.
After considering these questions, you should perhaps prepare two draft project plans, one for building and one for buying. This will force you to consider the integration costs. You should also consider the long term maintenance costs of both solutions. To estimate the integration costs, you will have to do a thorough evaluation of the software before you buy it. If you can't evaluate it, you will assume an unreasonable risk in buying it and you should decide against buying that particular product. If there are several buy decisions under consideration, some energy will have to be spent evaluating each.
How to Grow Professionally
Assume responsibility in excess of your authority. Play the role that you desire. Express appreciation for people's contribution to the success of the larger organization, as well as things as that help you personally.
If you want to become a team leader, instigate the formation of consensus. If you want to become a manager, take responsibility for the schedule. You can usually do this comfortably while working with a leader or a manager, since this frees them up to take greater responsibility. If that is too much to try, do it a little at a time.
Evaluate yourself. If you want to become a better programmer, ask someone you admire how you can become like them. You can also ask your boss, who will know less but have a greater impact on your career.
Plan ways to learn new skills, both the trivial technical kind, like learning a new software system, and the hard social kind, like writing well, by integrating them into your work.
How to Evaluate Interviewees
Evaluating potential employees is not given the energy it deserves. A bad hire, like a bad marriage, is terrible. A significant portion of everyone's energy should be devoted to recruitment, though this is rarely done.
There are different interviewing styles. Some are torturous, designed to put the candidate under a great deal of stress. This serves a very valuable purpose of possibly revealing character flaws and weaknesses under stress. Candidates are no more honest with interviewers than they are with themselves, and the human capacity for self-deception is astonishing.
You should, at a minimum, give the candidate the equivalent of an oral examination on the technical skills for two hours. With practice, you will be able to quickly cover what they know and quickly retract from what they don't know to mark out the boundary. Interviewees will respect this. I have several times heard interviewees say that the quality of the examination was one of their motivations for choosing a company. Good people want to be hired for their skills, not where they worked last or what school they went to or some other inessential characteristic.
In doing this, you should also evaluate their ability to learn, which is far more important than what they know. You should also watch for the whiff of brimstone that is given off by difficult people. You may be able to recognize it by comparing notes after the interview, but in the heat of the interview it is hard to recognize. How well people communicate and work with people is more important than being up on the latest programming language.
A reader has had good luck using a ‘take-home’ test for interviewees. This has the advantage that can uncover the interviewee that can present themselves well but can't really code---and there are many such people. I personally have not tried this technique, but it sounds sensible.
Finally, interviewing is also a process of selling. You should be selling your company or project to the candidate. However, you are talking to a programmer, so don't try to color the truth. Start off with the bad stuff, then finish strong with the good stuff.
How to Know When to Apply Fancy Computer Science
There is a body of knowledge about algorithms, data structures, mathematics, and other gee-whiz stuff that most programmers know about but rarely use. In practice, this wonderful stuff is too complicated and generally unnecessary. There is no point in improving an algorithm when most of your time is spent making inefficient database calls, for instance. An unfortunate amount of programming consists of getting systems to talk to each other and using very simple data structures to build a nice user interface.
When is high technology the appropriate technology? When should you crack a book to get something other than a run-of-the-mill algorithm? It is sometimes useful to do this but it should be evaluated carefully.
The three most important considerations for the potential computer science technique are:
• Is it well encapsulated so that the risk to other systems is low and the overall increase in complexity and maintenance cost is low?
• Is the benefit startling (for example, a factor of two in a mature system or a factor of ten in a new system)?
• Will you be able to test and evaluate it effectively?
If a well-isolated algorithm that uses a slightly fancy algorithm can decrease hardware cost or increase performance by a factor of two across an entire system, then it would be criminal not to consider it. One of the keys to arguing for such an approach is to show that the risk is really quite low, since the proposed technology has probably been well studied, the only issue is the risk of integration. Here a programmer's experience and judgment can truly synergize with the fancy technology to make integration easy.
How to Talk to Non-Engineers
Engineers and programmers in particular are generally recognized by popular culture as being different from other people. This implies that other people are different from us. This is worth bearing in mind when communicating with non-engineers; you should always understand the audience.
Non-engineers are smart, but not as grounded in creating technical things as we are. We make things. They sell things and handle things and count things and manage things, but they are not experts on making things. They are not as good at working together on teams as engineers are (there are no doubt exceptions.)[3] Their social skills are generally as good as or better than engineers in non-team environments, but their work does not always demand that they practice the kind of intimate, precise communication and careful subdivisions of tasks that we do.
Non-engineers may be too eager to please and they may be intimidated by you. Just like us, they may say ‘yes’ without really meaning it to please you or because they are a little scared of you, and then not stand behind their words.
Non-programmers can understand technical things but they do not have the thing that is so hard even for us---technical judgment. They do understand how technology works, but they cannot understand why a certain approach would take three months and another one three days. (After all, programmers are anecdotally horrible at this kind of estimation as well.) This represents a great opportunity to synergize with them.
When talking to your team you will, without thinking, use a sort of shorthand, an abbreviated language that is effective because you will have much shared experience about technology in general and your product in particular. It takes some effort not to use this shorthand with those that don't have that shared experience, especially when members of your own team are present. This vocabulary create a wall between you and those that do not share it, and, even worse, wastes their time.
With your team, the basic assumptions and goals do not need to be restated often, and most conversation focuses on the details. With outsiders, it must be the other way around. They may not understand things you take for granted. Since you take them for granted and don't repeat them, you can leave a conversation with an outsider thinking that you understand each other when really there is a large misunderstanding. You should assume that you will miscommunicate and watch carefully to find this miscommunication. Try to get them to summarize or paraphrase what you are saying to make sure they understand. If you have the opportunity to meet with them often, spend a little bit of time asking if you you are communicating effectively, and how you can do it better. If there is a problem in communication, seek to alter your own practices before becoming frustrated with theirs.
I love working with non-engineers. It provides great opportunities to learn and to teach. You can often lead by example, in terms of the clarity of your communication. Engineers are trained to bring order out of chaos, to bring clarity out of confusion, and non-engineers like this about us. Because we have technical judgment and can usually understand business issues, we can often find a simple solution to a problem.
Often non-engineers propose solutions that they think will make it easier on us out of kindness and a desire to do the right thing, when in fact a much better overall solution exists which can only be seen by synergizing the outsiders view with your technical judgment. I personally like Extreme Programming because it addresses this inefficiency; by marrying the estimation quickly to the idea, it makes it easier to find the idea that is the best combination of cost and benefit.

________________________________________
[1] “to hit”
Chapter�4.�Advanced
Table of Contents
Technological Judgment
How to Tell the Hard From the Impossible
How to Utilize Embedded Languages
Choosing Languages
Compromising Wisely
How to Fight Schedule Pressure
How to Understand the User
How to Get a Promotion
Serving Your Team
How to Develop Talent
How to Choose What to Work On
How to Get the Most From Your Teammates
How to Divide Problems Up
How to Handle Boring Tasks
How to Gather Support for a Project
How to Grow a System
How to Communicate Well
How to Tell People Things They Don't Want to Hear
How to Deal with Managerial Myths
How to Deal with Organizational Chaos
Technological Judgment
How to Tell the Hard From the Impossible
It is our job to do the hard and discern the impossible. From the point of view of most working programmers, something is impossible if either it cannot be grown from a simple system or it cannot be estimated. By this definition what is called research is impossible. A large volume of mere work is hard, but not necessarily impossible.
The distinction is not facetious because you may very well be asked to do what is practically impossible, either from a scientific point of view or a software engineering point of view. It then becomes your job to help the entrepreneur find a reasonable solution which is merely hard and gets most of what they wanted. A solution is merely hard when it can be confidently scheduled and the risks are understood.
It is impossible to satisfy a vague requirement, such as ‘Build a system that will compute the most attractive hair style and color for any person.’ If the requirement can be made more crisp, it will often become merely hard, such as ‘Build a system to compute an attractive hair style and color for a person, allow them to preview it and make changes, and have the customer satisfaction based on the original styling be so great that we make a lot of money.’ If there is not crisp definition of success, you will not succeed.
How to Utilize Embedded Languages
Embedding a programming language into a system has an almost erotic fascination to a programmer. It is one of the most creative acts that can be performed. It makes the system tremendously powerful. It allows you to exercise her most creative and Promethean skills. It makes the system into your friend.
The best text editors in the world all have embedded languages. This can be used to the extent that the intended audience can master the language. Of course, use of the language can be made optional, as it is in text editors, so that initiates can use it and no one else has to.
I and many other programmers have fallen into the trap of creating special purpose embedded languages. I fell into it twice. There already exist many languages designed specifically to be embedded languages. You should think twice before creating a new one.
The real question to ask oneself before embedding a language is: Does this work with or against the culture of my audience? If you intended audience is exclusively non-programmers, how will it help? If your intended audience is exclusively programmers, would they prefer an applications programmers interface (API)? And what language will it be? Programmers don't want to learn a new language that is narrowly used; but if it meshes with their culture they will not have to spend much time learning it. It is a joy to create a new language. But we should not let that blind us to the needs of the user. Unless you have some truly original needs and ideas, why not use an existing language so that you can leverage the familiarity users already have with it?
Choosing Languages
The solitary programmer that loves his work (a hacker) can choose the best language for the task. Most working programmers have very little control of the language they will use. Generally, this issue is dictated by pointy-haired bosses who are making a political decision, rather than a technological decision, and lack the courage to promote an unconventional tool even when they know, often with firsthand knowledge, that the less accepted tool is best. In other cases the very real benefit of unity among the team, and to some extent with a larger community, precludes choice on the part of the individual. Often managers are driven by the need to be able to hire programmers with experience in a given language. No doubt they are serving what they perceive to be the best interests of the project or company, and must be respected for that. However, I personally believe this the most wasteful and erroneous common practice you are likely to encounter.
But of course, things are never one-dimensional. Even if a core language is mandated and beyond your control, it is often the case that tools and other programs can and should be written in a different language. If a language is to be embedded (and you should always consider it!) the choice of language will depend a lot on the culture of the users. One should take advantage of this to serve your company or project by using the best language for the job, and in so doing make work more interesting.
Programming languages should really be called notations in that learning one is not at all as difficult as learning a natural language. To beginners and to some outsiders ``learning a new language'' seems a daunting task; but after you have three under your belt it's really just a question of becoming familiar with the available libraries. One tends to think of a large system that has components in three or four languages as a messy hodgepodge; but I argue that such a system is in many cases stronger than a one-language system in several ways:
• There is necessarily loose coupling between the components that are written in different notations (though maybe not clean interfaces),
• You can evolve to a new language/platform easily by rewriting each component individually,
• Its possible that some of the modules are actually up-to-date.
Some of these effects may only be psychological; but psychology matters. In the end the costs of language tyranny outweigh any advantage that it provides.
Compromising Wisely
How to Fight Schedule Pressure
Time-to-market pressure is the pressure to deliver a good product quickly. It is good because it reflects a financial reality, and is healthy up to a point. Schedule pressure is the pressure to deliver something faster than it can be delivered and it is wasteful, unhealthy, and all too common.
Schedule pressure exists for several reasons. The people who task programmers do not fully appreciate what a strong work ethic we have and how much fun it is to be a programmer. Perhaps because they project their own behavior onto us, they believe that asking for it sooner will make us work harder to get it there sooner. This is probably actually true, but the effect is very small, and the damage is very great. Additionally, they have no visibility into what it really takes to produce software. Not being able to see it, and not be able to create it themselves, the only thing they can do is see time-to-market pressure and fuss at programmers about it.
The key to fighting schedule pressure is simply to turn it into time-to-market pressure. The way to do this to give visibility into the relationship between the available labor and the product. Producing an honest, detailed, and most of all, understandable estimate of all the labor involved is the best way to do this. It has the added advantage of allowing good management decisions to be made about possible functionality tradeoffs.
The key insight that the estimate must make plain is that labor is an almost incompressible fluid. You can't pack more into a span of time anymore than you can pack more water into a container over and above that container's volume. In a sense, a programmer should never say ‘no’, but rather to say ‘What will you give up to get that thing you want?’ The effect of producing clear estimates will be to increase the respect for programmers. This is how other professionals behave. Programmers' hard work will be visible. Setting an unrealistic schedule will also be painfully obvious to everyone. Programmers cannot be hoodwinked. It is disrespectful and demoralizing to ask them to do something unrealistic. Extreme Programming amplifies this and builds a process around it; I hope that every reader will be lucky enough to use it.
How to Understand the User
It is your duty to understand the user, and to help your boss understand the user. Because the user is not as intimately involved in the creation of your product as you are, they behave a little differently:
• The user generally makes short pronouncements.
• The user has their own job; they will mainly think of small improvements in your product, not big improvements.
• The user can't have a vision that represents the complete body of your product users.
It is your duty to give them what they really want, not what they say they want. It is however, better to propose it to them and get them to agree that your proposal is what they really want before you begin, but they may not have the vision to do this. Your confidence in your own ideas about this should vary. You must guard against both arrogance and false modesty in terms of knowing what the customer really wants. Programmers are trained to design and create. Market researchers are trained to figure out what people want. These two kinds of people, or two modes of thought in the same person, working harmoniously together give the best chance of formulating the correct vision.
The more time you spend with users the better you will be able to understand what will really be successful. You should try to test your ideas against them as much as you can. You should eat and drink with them if you can.
Guy Kawasaki[Rules] has emphasized the importance of watching what your users do in addition to listening to them.
I believe contractors and consultants often have tremendous problems getting their clients to clarify in their own minds what they really want. If you intend to be a consultant, I suggest you choose your clients based on their clear-headedness as well as their pocketbooks.
How to Get a Promotion
To be promoted to a role, act out that role first.
To get promoted to a title, find out what is expected of that title and do that.
To get a pay raise, negotiate armed with information.
If you feel like you are past due for a promotion, talk to your boss about it. Ask them explicitly what you need to do to get promoted, and try to do it. This sounds trite, but often times your perception of what you need to do will differ considerably from your boss's. Also this will pin your boss down in some ways.
Most programmers probably have an exaggerated sense of their relative abilities in some ways---after all, we can't all be in the top 10%! However, I have seem some people who were seriously unappreciated. One cannot expect everyone's evaluation to perfectly match reality at all times, but I think people are generally moderately fair, with one caveat: you cannot be appreciated without visibility into your work. Sometimes, do to happenstance or personal habits, someone will not be noticed much. Working from home a lot or being geographically separated from your team and boss makes this especially difficult.
Serving Your Team
How to Develop Talent
Nietschze exaggerated when he said[Stronger]:
What does not destroy me, makes me stronger.
Your greatest responsibility is to your team. You should know each of them well. You should stretch your team, but not overburden them. You should usually talk to them about the way they are being stretched. If they buy in to it, they will be well motivated. On each project, or every other project, try to stretch them in both a way that they suggest and a way that you think will be good for them. Stretch them not by giving them more work, but by giving them a new skill or better yet a new role to play on the team.
You should allow people (including yourself) to fail occasionally and should plan for some failure in your schedule. If there is never any failure, there can be no sense of adventure. If there are not occasional failures, you are not trying hard enough. When someone fails, you should be as gentle as you can with them while not treating them as though they had succeeded.
Try to get each team member to buy in and be well motivated. Ask each of them explicitly what they need to be well-motivated if they are not. You may have to leave them dissatisfied, but you should know what everybody desires.
You can't give up on someone who is intentionally not carrying their share of the load because of low morale or dissatisfaction and just let them be slack. You must try to get them well-motivated and productive. As long as you have the patience, keep this up. When your patience is exhausted, fire them. You cannot allow someone who is intentionally working below their level to remain on the team, since it is not fair to the team.
Make it clear to the strong members of your team that you think they are strong by saying so in public. Praise should be public and criticism private.
The strong members of the team will naturally have more difficult tasks than the weak members of the team. This is perfectly natural and nobody will be bothered by it as long as everyone works hard.
It is an odd fact that is not reflected in salaries that a good programmer is more productive than 10 bad programmers. This creates a strange situation. It will often be true that you could move faster if your weak programmers would just get out of the way. If you did this you would in fact make more progress in the short term. However, your tribe would lose some important benefits, namely the training of the weaker members, the spreading of tribal knowledge, and the ability to recover from the loss of the strong members. The strong must be gentle in this regard and consider the issue from all angles.
You can often give the stronger team members challenging, but carefully delineated, tasks.
How to Choose What to Work On
You balance your personal needs against the needs of the team in choosing what aspect of a project to work on. You should do what you are best at, but try to find a way to stretch yourself not by taking on more work but by exercising a new skill. Leadership and communication skills are more important than technical skills. If you are very strong, take on the hardest or riskiest task, and do it as early as possible in the project to decrease risk.
How to Get the Most From Your Teammates
To get the most from your teammates, develop a good team spirit and try to keep every individual both personally challenged and personally engaged.
To develop team spirit, corny stuff like logoized clothing and parties are good, but not as good as personal respect. If everyone respects everyone else, nobody will want to let anybody down. Team spirit is created when people make sacrifices for the team and think in terms of the good of the team before their own personal good. As a leader, you can't ask for more than you give yourself in this respect.
One of the keys to team leadership is to facilitate consensus so that everyone has buy in. This occasionally means allowing your teammates to be wrong. That is, if it does not harm the project too much, you must let some of your team do things their own way, based on consensus, even if you believe with great confidence it is the wrong thing to do. When this happens, don't agree, simply disagree openly and accept the consensus. Don't sound hurt, or like you're being forced into it, simply state that you disagree but think the consensus of the team is more important. This will often cause them to backtrack. Don't insist that they go through with their initial plan if they do backtrack.
If there is an individual who will not consent after you have discussed the issues from all appropriate sides, simply assert that you have to make a decision and that is what your decision is. If there is a way to judge if your decision will be wrong or if it is later shown to be wrong, switch as quickly as you can and recognize the persons who were right.
Ask your team, both as a group and individually, what they think would create team spirit and make for an effective team.
Praise frequently rather than lavishly. Especially praise those who disagree with you when they are praiseworthy. Praise in public and criticize in private; with one exception: sometimes growth or the correction of a fault can't be praised without drawing embarrassing attention to the original fault, so that growth should be praised in private.
How to Divide Problems Up
It's fun to take a software project and divide it up into tasks that will be performed by individuals. This should be done early. Sometimes managers like to think that an estimate can be made without consideration of the individuals that will perform the work. This is impossible since the productivity of individuals varies so widely. Who has particular knowledge about a component also constantly changes and can have an order of magnitude effect on performance.
Just as a composer considers the timbre of the instrument that will play a part or the coach of an athletic team considers the strengths of each player, the experienced team leader will not usually be able to separate the division of the project into tasks from the team members to which they will be assigned. This is part of the reason that a high-performing team should not be broken up.
There is a certain danger in this given that people will become bored as they build upon their strengths and never improve their weaknesses or learn new skills. However, specialization is a very useful productivity tool when not overused.
How to Handle Boring Tasks
Sometimes it is not possible to avoid boring tasks that are critical to the success of the company or the project. These tasks can really hurt the morale of those that have to do them. The best technique for dealing with this is to invoke or promote Larry Wall's programmer's virtue of Laziness. Try to find some way to get the computer to do the task for you or to help your teammates do this. Working for a week on a program to do a task that will take a week to do by hand has the great advantage of being more educational and sometimes more repeatable.
If all else fails, apologize to those who have to do the boring task, but under no circumstances allow them to do it alone. At a minimum assign a team of two to do the work and promote healthy teamwork to get the task done.
How to Gather Support for a Project
To gather support for a project, create and communicate a vision that demonstrates real value to the organization as a whole. Attempt to let others share in your vision creation. This gives them a reason to support you and gives you the benefit of their ideas. Individually recruit key supporters for your project. Wherever possible, show, don't tell. If possible, construct a prototype or a mockup to demonstrate your ideas. A prototype is always powerful but in software it is far superior to any written description.
How to Grow a System
The seed of a tree contains the idea of the adult but does not fully realize the form and potency of the adult. The embryo grows. It becomes larger. It looks more like the adult and has more of the uses. Eventually it bears fruit. Later, it dies and its body feeds other organisms.
We have the luxury of treating software like that. A bridge is not like that; there is never a baby bridge, but merely an unfinished bridge. Bridges are a lot simpler than software.
It is good to think of software as growing, because it allows us to make useful progress before we have a perfect mental image. We can get feedback from users and use that to correct the growth. Pruning off weak limbs is healthful.
The programmer must design a finished system that can be delivered and used. But the advanced programmer must do more. You must design a growth path that ends in the finished system. It is your job to take a germ of an idea and build a path that takes it as smoothly as possible into a useful artifact.
To do this, you must visualize the end result and communicate it in a way that the engineering team can get excited about. But you must also communicate to them a path that goes from wherever they are now to where they want to be with no large leaps. The tree must stay alive the whole time; it cannot be dead at one point and resurrected later.
This approach is captured in spiral development. Milestones that are never too far apart are used to mark progress along the path. In the ultra-competitive environment of business, it is best if the milestones can be released and make money as early as possible, even if they are far away from a well-designed endpoint. One of the programmer's jobs is to balance the immediate payoff against future payoff by wisely choosing a growth path expressed in milestones.
The advanced programmer has the triple responsibility of growing software, teams, and persons.
A reader, Rob Hafernik, sent in this comment on this section that I can do no better than to quote in full:
I think you under-emphasize the importance here. It's not just systems, but algorithms, user interfaces, data models, and so on. It's absolutely vital as you work on a large system to have measurable progress toward intermediate goals. Nothing is as bad as the special horror of getting down to the end and discovering that the whole thing just isn't going to work (look at the recent debacle of the Voter News System). I would even go further and state it as a law of nature: no large, complex system can be implemented from scratch, it can only be evolved from a simple system to a complex system in a series of intentional steps.
To which one can only reply Fiat lux!
How to Communicate Well
To communicate well, you have to recognize how hard it is. It is a skill unto itself. It is made harder by the fact that the persons with whom you have to communicate are flawed. They do not work hard at understanding you. They speak poorly and write poorly. They are often overworked or bored, and, at a minimum, somewhat focused on their own work rather than the larger issues you may be addressing. One of the advantages of taking classes and practicing writing, public speaking, and listening is that if you become good at it you can more readily see where problems lie and how to correct them.
The programmer is a social animal whose survival depends on communication with her team. The advanced programmer is a social animal whose satisfaction depends on communication with people outside her team.
The programmer brings order out of chaos. One interesting way to do this is to initiate a proposal of some kind outside the team. This can be done in a strawman or white-paper format or just verbally. This leadership has the tremendous advantage of setting the terms of the debate. It also exposes you to criticism, and worse, rejection and neglect. The advanced programmer must be prepared to accept this, because she has a unique power and therefore a unique responsibility. Entrepreneurs who are not programmers need programmers to provide leadership in some ways. Programmers are the part of the bridge between ideas and reality that rests on reality.
I haven't mastered communicating well, but what I'm currently trying is what I think of a four-pronged approach: After I have my ideas in order and am fully prepared, I try to speak verbally, hand people a white-paper (on real paper, as well as electronically) show them a demo, and then patiently repeat this process. I think a lot of times we are not patient enough in this kind of difficult communication. You should not be disheartened if your ideas are not immediately accepted. If you have invested energy in there preparation, no one will think poorly of you for it.
How to Tell People Things They Don't Want to Hear
You will often have to tell people things that will make them uncomfortable. Remember that you are doing this for a reason. Even if nothing can be done about the problem, you are telling them as early as possible so they will be well-informed.
The best way to tell someone about a problem is to offer a solution at the same time. The second best way is to appeal to them for help with the problem. If there is a danger that you won't be believed, you should gather some support for your assertion.
One of the most unpleasant and common things you will have to say is, ‘The schedule will have to slip.’ The conscientious programmer hates to say this, but must say it as early as possible. There is nothing worse than postponing action when a milestone slips, even if the only action is to inform everyone. In doing this, it is better to do it as a team, at least in spirit, if not physically. You will want your team's input on both where you stand and what can be done about it, and the team will have to face the consequences with you.
How to Deal with Managerial Myths
The word myth sometimes means fiction. But it has a deeper connotation. It also means a story of religious significance that explains the universe and mankind's relationship to it. Managers tend to forget what they learned as programmers and believe in certain myths. It would be as rude and unsuccessful to try to convince them these myths are false as to try to disillusion a devoutly religious person of their beliefs. For that reason, you should recognize these beliefs as myths:
• More documentation is always better. (They want it, but they don't want you to spend any time on it.)
• Programmers can be equated. (Programmers vary by an order of magnitude.)
• Resources can be added to a late project to speed it. (The cost of communication with the new persons is almost always more taxing than helpful.)
• It is possible to estimate software development reliably. (It is not even theoretically possible.)
• Programmers' productivity can be measured in terms of some simple metric, like lines of code. (If succinctness is power, lines of code are bad, not good.)
If you have an opportunity, you can try to explain these things, but don't feel bad if you have no success and don't damage your reputation by confronting these myths belligerently. Each of these myths reinforces the manager's idea that they have some actual control over what is going on. The truth is that managers facilitate if they are good, and impede if they are bad.
How to Deal with Organizational Chaos
There are often brief periods of great organizational chaos, such as layoffs, buyouts, ipos, firings, new hirings, and so on. These are unsettling to everyone, but perhaps a little less unsettling to the programmer whose personal self-esteem is founded in capacity rather than in position. Organizational chaos is a great opportunity for programmers to exercise their magic power. I've saved this for last because it is a deep tribal secret. If you are not a programmer, please stop reading now.
Engineers have the power to create and sustain.
Non-engineers can order people around but, in a typical software company, can create and sustain nothing without engineers, just as engineers typically cannot sell a product or manage a business effectively. This power is proof against almost all of the problems associated with temporary organizational mayhem. When you have it you should ignore the chaos completely and carry on as if nothing is happening. You may, of course, get fired, but if that happens you can probably get a new job because of the magic power. More commonly, some stressed-out person who does not have the magic power will come into your cube and tell you to do something stupid. If you are really sure that it is stupid, it is best to smile and nod until they go away and then carry on doing what you know is best for the company.
If you are a leader, tell your people to do the same thing and tell them to ignore what anybody else tells them. This course of action is the best for you personally, and is the best for your company or project.
Glossary
This is a glossary of terms as used in this essay. These do not necessarily have a standardized meaning to other people. Eric S. Raymond has compiled a massive and informative glossary[HackerDict] that rather surprisingly can pleasurably be read cover-to-cover once you can appreciate a fraction of it.
unk-unk
Slang for unknown-unknown. Problems that cannot presently even be conceptualized that will steal time away from the project and wreck the schedule.
boss
The person or entity that gives you tasks. In some cases this may be the public at large.
printlining
The insertion of statements into a program on a strictly temporary basis that output information about the execution of the program for the purpose of debugging.
logging
The practice of writing a program so that it can produce a configurable output log describing its execution.
divide and conquer
A technique of top-down design and, importantly, of debugging that is the subdivision of a problem or a mystery into progressively smaller problems or mysteries.
vapor
Illusionary and often deceptive promises of software that is not yet for sale and, as often as not, will never materialize into anything solid.
boss
The person who sets your tasks. In some cases, the user is the boss.
tribe
The people with whom you share loyalty to a common goal.
low-hanging fruit
Big improvements that cost little.
Entrepreneur
The initiator of projects.
garbage
Objects that are no longer needed that hold memory.
busines
A group of people organized for making money.
company
A group of people organized for making money.
tribe
A group of people you share cultural affinity and loyalty with.
scroll blindness
The effect of being unable to find information you need because it is buried in too much other, less interesting information.
wall-clock
Actually time as measured by a clock on a wall, as opposed to CPU time.
bottleneck
The most important limitation in the performance of a system. A constriction that limits performance.
master
A unique piece of information from which all cached copies are derived that serves as the official definition of that data.
heap allocated
Memory can be said to be heap allocated whenever the mechanism for freeing it is complicated.
garbage
Allocated memory that no longer has any useful meaning.
garbage collector
A system for recycling garbage.
memory leak
The unwanted collection of references to objects that prevents garbage collection (or a bug in the garbage collector or memory management system!) that causes the program to gradually increase its memory demands over time.
Extreme Programming
A style of programming emphasizing communication with the customer and automated testing.
hitting the wall
To run out of a specific resource causing performance to degrade sharply rather than gradually.
speculative programming
Producing a feature before it is really known if that feature will be useful.
information hiding
A design principle that seeks to keep things independent and decoupled by using interfaces that expose as little information as possible.
object-oriented programming
An programming style emphasizing the the management of state inside objects.
communication languages
A language designed primarily for standardization rather than execution.
boxes and arrows
A loose, informal style of making diagrams consiting of boxes and arrows drawn between those boxes to show the relationships. This contrast with formal diagram methodologies, such as UML.
lingua franca
A language so popular as to be a de facto standard for its field, as French was for international diplomacy at one time.
buy vs. build
An adjective describing a choice between spending money for software or writing it your self.
mere work
Work that requires little creativity and entails little risk. Mere work can be estimated easily.
programming notation
A synonym for programming language that emphasizes the mathematical nature of programming language and their relative simplicity compared to natural languages.
strawman
A document meant to be the starting point of a technical discussion. A strawman may lead to a stickman, tinman, woodman, ironman, etc.
wite-paper
An informative document that is often meant to explain or sell a product or idea to an audience different than the programmers of that product or idea.
Table of Contents
Bibliography/Websiteography
Bibliography/Websiteography
Books
[Rules00] Guy Kawasaki, Michelle Moreno, and Gary Kawasaki. 2000. HarperBusiness. Rules for Revolutionaries: The Capitalist Manifesto for Creating and Marketing New Products and Services.
[RDev96] Steve McConnell. 1996. Microsoft Press. Redmond, Wash. Rapid Development: Taming Wild Software Schedules.
[CodeC93] Steve McConnell. 1993. Microsoft Press. Redmond, Wash. Code Complete.
[XP99] Kent Beck. 1999. 0201616416. Addison-Wesley. Extreme Programming Explained: Embrace Change.
[PlanXP00] Kent Beck and Martin Fowler. 2000. 0201710919. Addison-Wesley. Planning Extreme Programming.
[Prag99] Andrew Hunt, David Thomas, and Ward Cunningham. 1999. 020161622X. Addison-Wesley. The Pragmatic Programmer: From Journeyman to Master.
[Stronger] Friedrich Nietzsche. 1889. Twilight of the Idols, "Maxims and Arrows", section 8..
Web Sites
[PGSite] Paul Graham. 2002. Articles on his website: http://www.paulgraham.com/articles.html. All of them, but especially "Beating the Averages".
[Hacker] Eric S. Raymond. 2003. How to Become a Hacker. http://www.catb.org/~esr/faqs/hacker-howto.html.
[HackDict] Eric S. Raymond. 2003. The New Hacker Dictionary. http://catb.org/esr/jargon/jargon.html.
[ExpCS] Edsger W. Dijkstra. 1986. How Experimental is Computing Science?. http://www.cs.utexas.edu/users/EWD/ewd09xx/EWD988a.PDF.
[Knife] Edsger W. Dijkstra. 1984. On a Cultural Gap. http://www.cs.utexas.edu/users/EWD/ewd09xx/EWD913.PDF .
Appendix�B.�History (As Of February, 2003)
Request for Feedback or Extension
Please send me any comments you may have on this essay. I consider all suggestions, many of which have already improved this essay.
I have placed this essay under the GNU Free Documentation License. This license is not specifically designed for essays. Essays are usually intended to be coherent and convincing arguments that are writtien from a single point of view in a single voice. I hope this essay is a short and pleasant read.
I also hope that it is instructive. Although not a textbook, it is broken into many small sections to which new sections can be freely added. If so inclined, you are encouraged to expand upon this essay as you see fit, subject to the provisions of the License.
It may be arrogance to imagine that this document is worthy of extension; but hope springs eternal. I would be joyous if it were extended in the following ways:
• The addition of a comprehensive reading list to each section,
• The addition of more and better sections,
• Translation into other languages, even if only on a subsection-by-subsection basis, and/or
• Criticism or commentary in-lined into the text.
• The ability to build into different formats, such as palm formats and better HTML.
If you inform me of your work, I will consider it and may include it in subsequent versions that I produce, subject to the provisions of the License. You may of course produce your own versions of this document without my knowledge, as explained in the License.
Thank you.
Robert L. Read
Original Version
The original version of this document was begun by Robert L. Read in the year 2000 and first published electronically at Samizdat Press(http://Samizdat.mines.edu) in 2002. It is dedicated to the programmers of Hire.com.
After this article was mentioned on Slashdot in 2003, about 75 people sent me email with suggestions and errata. I appreciate them all. There was a lot of duplication, but the following people either made major suggestions or were the first to find a bug that I fixed: Morgan McGuire, David Mason, Tom Moertel, Ninja Programmer (145252) at Slashdot, Ben Vierck, Rob Hafernik, Mark Howe, Pieter Pareit, Brian Grayson, Zed A. Shaw, Steve Benz, Maksim Ioffe, Andrew Wu, David Jeschke, and Tom Corcoran.
Finally I would like to thank Christina Vallery, whose editing and proofreading greatly improved the second draft, and Wayne Allen, who encouraged me to initiate this.
Original Author's Bio
Robert L. Read lives in Austin, Texas, with his wife and two children. He is currently a Principal Engineer at Hire.com, where he has worked for four years. Prior to that he founded 4R Technology, which made a scanner-based image analysis quality control tool for the paper industry.
Rob received a PhD from the University of Texas at Austin in 1995 in Computer Science related to database theory. In 1987 he received a BA in Computer Science from Rice University. He has been a paid programmer since the age of 16.
Appendix�C.�GNU Free Documentation License
Version 1.2, November 2002
Table of Contents
PREAMBLE
APPLICABILITY AND DEFINITIONS
VERBATIM COPYING
COPYING IN QUANTITY
MODIFICATIONS
COMBINING DOCUMENTS
COLLECTIONS OF DOCUMENTS
AGGREGATION WITH INDEPENDENT WORKS
TRANSLATION
TERMINATION
FUTURE REVISIONS OF THIS LICENSE
ADDENDUM: How to use this License for your documents
Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
PREAMBLE
The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.
This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
APPLICABILITY AND DEFINITIONS
This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.
A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.
The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.
The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.
A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly display copies.
COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
MODIFICATIONS
You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:
A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.
B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.
C. State on the Title page the name of the publisher of the Modified Version, as the publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.
F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.
G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.
H. Include an unaltered copy of this License.
I. Preserve the section Entitled "History", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.
J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.
K. For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.
L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
M. Delete any section Entitled "Endorsements". Such a section may not be included in the Modified Version.
N. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section.
O. Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.
You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
COMBINING DOCUMENTS
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements".
COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
AGGREGATION WITH INDEPENDENT WORKS
A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.
TRANSLATION
Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.
If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.
ADDENDUM: How to use this License for your documents
To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:
Copyright (c) YEAR YOUR NAME. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this:
with the Invariant Sections being LIST THEIR TITLES, with the Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
Colophon
This work is licensed under the GNU Free Documentation License. It was originally written in LaTeX, then ported to DocBook. It is available in transparent copy in the DocBook/XML format. A build system and special instructions on processing are part of the transparent copy package, though building from the source is system dependent. The source can be built into either HTML or PDF format, and extension to other formats should be possible and is encouraged.
The original version of this document was written by Robert L. Read without renumeration and dedicated to the programmers of Hire.com.

copied from www.freetechbooks.com

________________________________________________________________________________________________

How to score good marks in exams

2010-01-15T20:18:00.000+05:30

Make a revision plan about 6 months before a major exam and start reviewing one topic at a time from then.
I feel envious of people who just perform well in exams without much real effort (so they say). The rest of us mortals have to follow the revision plan and cover everything as well as possible in advance of the big day.

1. Write neatly and clearly, .
2. Write in a language which iseasy to understand for the examiner as most examiners are average person, Keep their IQ in your mind while replying.
3. Reply the question with a direct and simple answer, though the question may look difficult.
3. If requred, explain with some suitable example.
4. Give some simple sketches in support of your answer.
5. If you want to score high, never make spelling mistakes, (this is like the impression we get from newspaper with lot of spelling mistakes we read it but ....but we don't trust the news).
Work hard. Devote minimum 6 hrs .to studies daily. Do revisions.

If you get good marks it means that your future life will be good and you will live comfortably in days ahead. Life is long but it is you only who have to make it safe, secure and comfortable.This is the time of competetion and you must be ahead of others and the best way is to secure good marks in your all the exams.

ALWAYS did the work assigned, made sure to study the MATERIAL BEFORE it was required, and did my projects with maximum effort -- then made sure to get good rest for the week prior to the exam week. That way, I went into the exams well rested, relaxed, and confident.
First, plan your study. Owerview your total work and the estimated time. But note that, it usually takes more time than it has considered so make sure that you speare some extra. Second, always go from easy to the hard. This will help you gain confidence during the study and motivate you positively for the harder task. Third; say, you begun to study math first, then make sure that you study some verbal lesson or task second. Then, you may go on with numeric tasks if you please. Fourth; chalenge yourself. You may get extremely bored during the study and may feel like you could not go on no matter what. if this happens, motivate yourself by challenging yourself. Ex; "I am stronger than boredom" or "I can go on if i want to" but remember to offer yourself a reward while doing this, such as telling yourself that its the only way to deserve your dream holiday, or a movie etc... and the last one; everything seems harder than they really are. To discover how easy they are, is always the hardest part.

_______________________________________________________________________________________________

HTML intoduction

2010-01-11T02:17:00.000+05:30

HTML Introduction

What is HTML?
HTML is a language for describing web pages.
• HTML stands for Hyper Text Markup Language
• HTML is not a programming language, it is a markup language
• A markup language is a set of markup tags
• HTML uses markup tags to describe web pages
________________________________________
HTML Tags
HTML markup tags are usually called HTML tags
• HTML tags are keywords surrounded by angle brackets like
• HTML tags normally come in pairs like and
• The first tag in a pair is the start tag, the second tag is the end tag
• Start and end tags are also called opening tags and closing tags.
________________________________________
HTML Documents = Web Pages
• HTML documents describe web pages
• HTML documents contain HTML tags and plain text
• HTML documents are also called web pages
The purpose of a web browser (like Internet Explorer or Firefox) is to read HTML documents and display them as web pages. The browser does not display the HTML tags, but uses the tags to interpret the content of the page:

My First Heading

My first paragraph

Example Explained
• The text between and describes the web page
• The text between and is the visible page content
• The text between

and

is displayed as a heading
• The text between

and

is displayed as a paragraph
________________________________________

HTML Elements
HTML documents are defined by HTML elements.
________________________________________
HTML Elements
An HTML element is everything from the start tag to the end tag:
Start tag * Element content End tag *

This is a paragraph

This is a link

* The start tag is often called the opening tag. The end tag is often called the closing tag.
________________________________________
HTML Element Syntax
• An HTML element starts with a start tag / opening tag
• An HTML element ends with an end tag / closing tag
• The element content is everything between the start and the end tag
• Some HTML elements have empty content
• Empty elements are closed in the start tag
• Most HTML elements can have attributes
(You will learn about element attributes in the next chapter of this tutorial)
________________________________________
Nested HTML Elements
Most HTML elements can be nested (can contain other HTML elements).
HTML documents consist of nested HTML elements.
________________________________________
HTML Document Example

This is my first paragraph

The example above contains 3 HTML elements.
________________________________________
Example Explained
The

element:

This is my first paragraph

The

element defines a paragraph in the HTML document
The element has a start tag

and an end tag

The element content is: This is my first paragraph
The element:

This is my first paragraph

The element defines the body of the HTML document
The element has a start tag and an end tag
The element content is another HTML element (a paragraph)
The element:

This is my first paragraph

The element defines the whole HTML document.
The element has a start tag and an end tag
The element content is another HTML element (the body)
________________________________________
Don't Forget the End Tag
Most browsers will display HTML correctly even if you forget the end tag:

This is a paragraph

This is a paragraph
The example above will work in most browsers, but don't rely on it. Forgetting the end tag can produce unexpected results or errors.
Note: Future version of HTML will not allow you to skip end tags.
________________________________________
Empty HTML Elements
HTML elements without content are called empty elements. Empty elements can be closed in the start tag.

is an empty element without a closing tag (it defines a line break).
In XHTML, XML, and future versions of HTML, all elements must be closed.
Adding a slash to the start tag, like
, is the proper way of closing empty elements, accepted by HTML, XHTML and XML.
Even if
works in all browsers, writing
instead is more future proof.
________________________________________
HTML Tip: Use Lowercase Tags
HTML tags are not case sensitive:

means the same as

. Plenty of web sites use uppercase HTML tags in their pages.
HTML Attributes
Attributes provide additional information about HTML elements.
________________________________________
HTML Attributes
• HTML elements can have attributes
• Attributes provide additional information about the element
• Attributes are always specified in the start tag
• Attributes come in name/value pairs like: name="value"
________________________________________

Attribute Example
HTML links are defined with the tag. The link address is provided as an attribute:
Example
This is a link

________________________________________
Always Quote Attribute Values
Attribute values should always be enclosed in quotes.
Double style quotes are the most common, but single style quotes are also allowed.
In some rare situations, like when the attribute value itself contains quotes, it is necessary to use single quotes:
name='John "ShotGun" Nelson'
________________________________________
HTML Tip: Use Lowercase Attributes
Attribute names and attribute values are case-insensitive.
Newer versions of (X)HTML will demand lowercase attributes.
________________________________________
HTML Attributes Reference
A full list of legal attributes for each HTML element is listed in our:
Below is a list of some attributes that are standard for most HTML elements:

Attribute Value Description
class class_rule or style_rule The class of the element
id id_name A unique id for the element
style style_definition An inline style definition
title tooltip_text A text to display in a tool tip

HTML Headings

Headings are important in HTML documents.
________________________________________
HTML Headings
Headings are defined with the

to

tags.

defines the largest heading.

defines the smallest heading.
Example

This is a heading

Note: Browsers automatically adds an empty line before and after headings.
________________________________________
Headings Are Important
Use HTML headings for headings only. Don't use headings to make text BIG or bold.
Search engines use your headings to index the structure and content of your web pages.
Since users may skim your pages by its headings, it is important to use headings to show the document structure.
H1 headings should be used as main headings, followed by H2 headings, then less important H3 headings, and so on.
________________________________________
HTML Rules (Lines)
The

tag is used to create an horizontal rule (line).

Example

This is a paragraph

________________________________________
HTML Comments
Comments can be inserted in the HTML code to make it more readable and understandable. Comments are ignored by the browser and are not displayed.
Comments are written like this:
Example

Note: There is an exclamation point after the opening bracket, but not before the closing bracket.
________________________________________
HTML Tip - How to View HTML Source
Have you ever seen a Web page and wondered "Hey! How did they do that?"
To find out, click the VIEW option in your browser's toolbar and select SOURCE or PAGE SOURCE. This will open a window that shows you the HTML code of the page.
________________________________________HTML Tag Reference

Tag Description

Defines an HTML document

Defines the document's body

to

Defines header 1 to header 6

Defines a horizontal rule

Defines a comment
HTML Paragraphs
HTML documents are divided into paragraphs.

HTML Paragraphs
Paragraphs are defined with the
tag.
Example
This is a paragraph

This is another paragraph

Note: Browsers automatically adds an empty line before and after paragraphs.

Don't Forget the End Tag
Most browsers will display HTML correctly even if you forget the end tag:
Example
This is a paragraph
This is another paragraph

The example above will work in most browsers, but don't rely on it. Forgetting the end tag can produce unexpected results or errors.
Note: Future version of HTML will not allow you to skip end tags.

HTML Line Breaks
Use the
tag if you want a line break (a new line) without starting a new paragraph:

Example
This is
a para
graph with line breaks

The
element is an empty HTML element. It has no end tag.

or

In XHTML, XML, and future versions of HTML, HTML elements with no end tag (closing tag) are not allowed.
Even if
works in all browsers, writing
instead is more future proof.

HTML Output - Useful Tips
You cannot be sure how HTML will be displayed. Large or small screens, and resized windows will create different results.
With HTML, you cannot change the output by adding extra spaces or extra lines in your HTML code.
The browser will remove extra spaces and extra lines when the page is displayed. Any number of lines count as one space, and any number of spaces count as one space.

HTML Tag Reference
Tag Description

Defines a paragraph

Inserts a single line break

HTML Text Formatting

HTML Text Formatting
This text is bold

This text is big

This text is italic

This is computer output

This is subscript and superscript

HTML Formatting Tags
HTML uses tags like and for formatting output, like bold or italic text.
These HTML tags are called formatting tags.
Refer to the bottom of this page for a complete reference.

HTML Styles
The style attribute is a new HTML attribute. It introduces CSS to HTML.

Look! Styles and colors
This text is in Verdana and red
This text is in Times and blue
This text is 30 pixels high

The HTML Style Attribute
The purpose of the style attribute is:
To provide a common way to style all HTML elements.
Styles was introduced with HTML 4, as the new and preferred way to style HTML elements. With HTML styles, styles can be added to HTML elements directly by using the style attribute, or indirectly by in separate style sheets (CSS files).
You can learn everything about styles and CSS in our CSS tutorial.
In our HTML tutorial we use the style attribute to introduce you to HTML styles.

HTML Style Examples
style="background-color:yellow"
style="font-size:10px"
style="font-family:Times"
style="text-align:center"

Deprecated Tags and Attributes
In HTML 4, some tags and attributes are defined as deprecated. Deprecated means that they will not be supported in future versions of HTML and XHTML.
The message is clear: Avoid the use of deprecated tags and attributes.
These tags and attributes should be avoided:
Tags Description
Defines centered content
and Defines HTML fonts
and Defines strikeout text
Defines underlined text

Attributes
Description
align Defines the alignment of text
bgcolor Defines the background color
color Defines the text color
For all the above: Use styles instead.

Style Examples:

Background Color

The style attribute defines a style for the element.

Font Family, Color and Size

The style attribute defines a style for the
element.

Text Alignment

The style attribute defines a style for the
element.

HTML Links

A link is the "address" to a document (or a resource) on the web.

Hyperlinks, Anchors, and Links
In web terms, a hyperlink is a reference (an address) to a resource on the web.
Hyperlinks can point to any resource on the web: an HTML page, an image, a sound file, a movie, etc.
An anchor is a term used to define a hyperlink destination inside a document.
The HTML anchor element , is used to define both hyperlinks and anchors.
We will use the term HTML link when the element points to a resource, and the term HTML anchor when the elements defines an address inside a document..

An HTML Link
Link syntax:
Link text
The start tag contains attributes about the link.
The element content (Link text) defines the part to be displayed.
Note: The element content doesn't have to be text. You can link from an image or any other HTML element.

The href Attribute
The href attribute defines the link "address".
This element defines a link to W3Schools:
Visit W3Schools!
The code above will display like this in a browser:
Visit W3Schools!

The target Attribute
The target attribute defines where the linked document will be opened.
The code below will open the document in a new browser window:
Example
target="_blank">Visit W3Schools!

The name Attribute
When the name attribute is used, the element defines a named anchor inside a HTML document.
Named anchor are not displayed in any special way. They are invisible to the reader.
Named anchor syntax:
Any content
The link syntax to a named anchor:
Any content
The # in the href attribute defines a link to a named anchor.
Example:
A named anchor inside an HTML document:
Useful Tips Section
A link to the Useful Tips Section from the same document:

Jump to the Useful Tips Section
A link to the Useful Tips Section from another document:

Jump to the Useful Tips Section
Link Tags
Tag Description

Defines an anchor

HTML Images

The Image Tag and the Src Attribute
In HTML, images are defined with the tag.
The tag is empty, which means that it contains attributes only and it has no closing tag.
To display an image on a page, you need to use the src attribute. Src stands for "source". The value of the src attribute is the URL of the image you want to display on your page.
The syntax of defining an image:

The URL points to the location where the image is stored. An image named "boat.gif" located in the directory "images" on "www.w3schools.com" has the URL: http://www.w3schools.com/images/boat.gif.
The browser puts the image where the image tag occurs in the document. If you put an image tag between two paragraphs, the browser shows the first paragraph, then the image, and then the second paragraph.

The Alt Attribute
The alt attribute is used to define an "alternate text" for an image. The value of the alt attribute is an author-defined text:

The "alt" attribute tells the reader what he or she is missing on a page if the browser can't load images. The browser will then display the alternate text instead of the image. It is a good practice to include the "alt" attribute for each image on a page, to improve the display and usefulness of your document for people who have text-only browsers.

Basic Notes - Useful Tips
If an HTML file contains ten images - eleven files are required to display the page right. Loading images take time, so my best advice is: Use images carefully.

Image Tags
Tag Description

Defines an image

Defines an image map

Defines a clickable area inside an image map

HTML Tables
Tables
Tables are defined with the tag. A table is divided into rows (with the tag), and each row is divided into data cells (with the
tag). The letters td stands for "table data," which is the content of a data cell. A data cell can contain text, images, lists, paragraphs, forms, horizontal rules, tables, etc.

row 1, cell 1 row 1, cell 2

row 2, cell 1 row 2, cell 2

How it looks in a browser:
row 1, cell 1 row 1, cell 2
row 2, cell 1 row 2, cell 2

Tables and the Border Attribute
If you do not specify a border attribute the table will be displayed without any borders. Sometimes this can be useful, but most of the time, you want the borders to show.
To display a table with borders, you will have to use the border attribute:

Row 1, cell 1 Row 1, cell 2

Headings in a Table
Headings in a table are defined with the tag.

Heading Another Heading

row 1, cell 1 row 1, cell 2

row 2, cell 1 row 2, cell 2

How it looks in a browser:
Heading Another Heading
row 1, cell 1 row 1, cell 2
row 2, cell 1 row 2, cell 2

Empty Cells in a Table
Table cells with no content are not displayed very well in most browsers.

row 1, cell 1 row 1, cell 2

row 2, cell 1

How it looks in a browser:
row 1, cell 1 row 1, cell 2
row 2, cell 1
Note that the borders around the empty table cell are missing (NB! Mozilla Firefox displays the border).
To avoid this, add a non-breaking space ( ) to empty data cells, to make the borders visible:

row 1, cell 1 row 1, cell 2

row 2, cell 1

How it looks in a browser:
row 1, cell 1 row 1, cell 2
row 2, cell 1

Table Tags
Tag Description

Defines a table

Defines a table row

Defines groups of table columns

Defines the attribute values for one or more columns in a table

Defines a table head

Defines a table body

Defines a table footer

HTML Lists
HTML supports ordered, unordered and definition lists.

HTML Lists
• This is the first
• This is the second
• This is the third

Unordered Lists
An unordered list is a list of items. The list items are marked with bullets (typically small black circles).
An unordered list starts with the
tag. Each list item starts with the
tag.

Coffee

Milk

Here is how it looks in a browser:
• Coffee
• Milk
Inside a list item you can put paragraphs, line breaks, images, links, other lists, etc.

Ordered Lists
An ordered list is also a list of items. The list items are marked with numbers.
An ordered list starts with the
tag. Each list item starts with the
tag.

Coffee

Milk

Here is how it looks in a browser:
1. Coffee
2. Milk
Inside a list item you can put paragraphs, line breaks, images, links, other lists, etc.

Definition Lists
A definition list is not a list of single items. It is a list of items (terms), with a description of each item (term).
A definition list starts with a
tag (definition list).
Each term starts with a
tag (definition term).
Each description starts with a
tag (definition description).

Coffee

Black hot drink

Milk

White cold drink

Here is how it looks in a browser:
Coffee
Black hot drink
Milk
White cold drink
Inside the
tag you can put paragraphs, line breaks, images, links, other lists, etc.

List Tags
Tag Description

Defines an ordered list

Defines an unordered list

Defines a list item

Defines a definition list

Defines a term (an item) in a definition list

Defines a description of a term in a definition list

Deprecated. Use
instead

Deprecated. Use
instead

HTML Forms and Input

HTML Forms are used to select different kinds of user input.

Forms
A form is an area that can contain form elements.
Form elements are elements that allow the user to enter information (like text fields, textarea fields, drop-down menus, radio buttons, checkboxes, etc.) in a form.
A form is defined with the
tag.

.
input elements
.

Input
The most used form tag is the tag. The type of input is specified with the type attribute. The most commonly used input types are explained below.
Text Fields
Text fields are used when you want the user to type letters, numbers, etc. in a form.

First name:

Last name:

How it looks in a browser:
First name:
Last name:
Note that the form itself is not visible. Also note that in most browsers, the width of the text field is 20 characters by default.
Radio Buttons
Radio Buttons are used when you want the user to select one of a limited number of choices.

Male

Female

How it looks in a browser:
Male
Female
Note that only one option can be chosen.
Checkboxes
Checkboxes are used when you want the user to select one or more options of a limited number of choices.

I have a bike:

I have a car:

I have an airplane:

How it looks in a browser:
I have a bike:
I have a car:
I have an airplane:

The Form's Action Attribute and the Submit Button
When the user clicks on the "Submit" button, the content of the form is sent to the server. The form's action attribute defines the name of the file to send the content to. The file defined in the action attribute usually does something with the received input.

Username:

How it looks in a browser:
Username:
If you type some characters in the text field above, and click the "Submit" button, the browser will send your input to a page called "html_form_submit.asp". The page will show you the received input.

Form Tags
Tag Description

Defines a form for user input

Defines an input field
 Defines a text-area (a multi-line text input control) <label> Defines a label to a control <fieldset> Defines a fieldset <legend> Defines a caption for a fieldset <select> Defines a selectable list (a drop-down box) <optgroup> Defines an option group <option> Defines an option in the drop-down box <button> Defines a push button <isindex> Deprecated. Use <input> instead HTML Color Values Color Names Supported by All Browsers The list below is a complete list of the color names supported by all major browsers. You can click on a color name (or a hex value) to view the color as the background-color along with different text colors. Color Name Color HEX Black #000000 Navy #000080 DarkBlue #00008B MediumBlue #0000CD Blue #0000FF DarkGreen #006400 Green #008000 Teal #008080 DarkCyan #008B8B DeepSkyBlue #00BFFF DarkTurquoise #00CED1 MediumSpringGreen #00FA9A Lime #00FF00 SpringGreen #00FF7F Aqua #00FFFF Cyan #00FFFF MidnightBlue #191970 DodgerBlue #1E90FF LightSeaGreen #20B2AA ForestGreen #228B22 SeaGreen #2E8B57 DarkSlateGray #2F4F4F LimeGreen #32CD32 MediumSeaGreen #3CB371 Turquoise #40E0D0 RoyalBlue #4169E1 SteelBlue #4682B4 DarkSlateBlue #483D8B MediumTurquoise #48D1CC Indigo #4B0082 DarkOliveGreen #556B2F CadetBlue #5F9EA0 CornflowerBlue #6495ED MediumAquaMarine #66CDAA DimGray #696969 SlateBlue #6A5ACD OliveDrab #6B8E23 SlateGray #708090 LightSlateGray #778899 MediumSlateBlue #7B68EE LawnGreen #7CFC00 Chartreuse #7FFF00 Aquamarine #7FFFD4 Maroon #800000 Purple #800080 Olive #808000 Gray #808080 SkyBlue #87CEEB LightSkyBlue #87CEFA BlueViolet #8A2BE2 DarkRed #8B0000 DarkMagenta #8B008B SaddleBrown #8B4513 DarkSeaGreen #8FBC8F LightGreen #90EE90 MediumPurple #9370D8 DarkViolet #9400D3 PaleGreen #98FB98 DarkOrchid #9932CC YellowGreen #9ACD32 Sienna #A0522D Brown #A52A2A DarkGray #A9A9A9 LightBlue #ADD8E6 GreenYellow #ADFF2F PaleTurquoise #AFEEEE LightSteelBlue #B0C4DE PowderBlue #B0E0E6 FireBrick #B22222 DarkGoldenRod #B8860B MediumOrchid #BA55D3 RosyBrown #BC8F8F DarkKhaki #BDB76B Silver #C0C0C0 MediumVioletRed #C71585 IndianRed #CD5C5C Peru #CD853F Chocolate #D2691E Tan #D2B48C LightGrey #D3D3D3 PaleVioletRed #D87093 Thistle #D8BFD8 Orchid #DA70D6 GoldenRod #DAA520 Crimson #DC143C Gainsboro #DCDCDC Plum #DDA0DD BurlyWood #DEB887 LightCyan #E0FFFF Lavender #E6E6FA DarkSalmon #E9967A Violet #EE82EE PaleGoldenRod #EEE8AA LightCoral #F08080 Khaki #F0E68C AliceBlue #F0F8FF HoneyDew #F0FFF0 Azure #F0FFFF SandyBrown #F4A460 Wheat #F5DEB3 Beige #F5F5DC WhiteSmoke #F5F5F5 MintCream #F5FFFA GhostWhite #F8F8FF Salmon #FA8072 AntiqueWhite #FAEBD7 Linen #FAF0E6 LightGoldenRodYellow #FAFAD2 OldLace #FDF5E6 Red #FF0000 Fuchsia #FF00FF Magenta #FF00FF DeepPink #FF1493 OrangeRed #FF4500 Tomato #FF6347 HotPink #FF69B4 Coral #FF7F50 Darkorange #FF8C00 LightSalmon #FFA07A Orange #FFA500 LightPink #FFB6C1 Pink #FFC0CB Gold #FFD700 PeachPuff #FFDAB9 NavajoWhite #FFDEAD Moccasin #FFE4B5 Bisque #FFE4C4 MistyRose #FFE4E1 BlanchedAlmond #FFEBCD PapayaWhip #FFEFD5 LavenderBlush #FFF0F5 SeaShell #FFF5EE Cornsilk #FFF8DC LemonChiffon #FFFACD FloralWhite #FFFAF0 Snow #FFFAFA Yellow #FFFF00 LightYellow #FFFFE0 Ivory #FFFFF0 White #FFFFFF </article> <article> <h1>ASP - Active Server Page</h1> 2010-01-11T01:50:00.001+05:30 <div dir="ltr" style="text-align: left;" trbidi="on"> ASP Introduction ASP is a powerful tool for making dynamic and interactive Web pages. An ASP file can contain text, HTML tags and scripts. Scripts in an ASP file are executed on the server. What you should already know Before you continue you should have some basic understanding of the following: • HTML / XHTML • A scripting language like JavaScript or VBScript What is ASP? • ASP stands for Active Server Pages • ASP is a Microsoft Technology • ASP is a program that runs inside IIS • IIS stands for Internet Information Services • IIS comes as a free component with Windows 2000 • IIS is also a part of the Windows NT 4.0 Option Pack • The Option Pack can be downloaded from Microsoft • PWS is a smaller - but fully functional - version of IIS • PWS can be found on your Windows 95/98 CD ASP Compatibility • To run IIS you must have Windows NT 4.0 or later • To run PWS you must have Windows 95 or later • ChiliASP is a technology that runs ASP without Windows OS • InstantASP is another technology that runs ASP without Windows What is an ASP File? • An ASP file is just the same as an HTML file • An ASP file can contain text, HTML, XML, and scripts • Scripts in an ASP file are executed on the server • An ASP file has the file extension ".asp" How Does ASP Differ from HTML? • When a browser requests an HTML file, the server returns the file • When a browser requests an ASP file, IIS passes the request to the ASP engine. The ASP engine reads the ASP file, line by line, and executes the scripts in the file. Finally, the ASP file is returned to the browser as plain HTML What can ASP do for you? • Dynamically edit, change, or add any content of a Web page • Respond to user queries or data submitted from HTML forms • Access any data or databases and return the results to a browser • Customize a Web page to make it more useful for individual users • The advantages of using ASP instead of CGI and Perl, are those of simplicity and speed • Provide security - since ASP code cannot be viewed from the browser • Clever ASP programming can minimize the network traffic You can run ASP on your own PC. Your Windows PC as a Web Server • Your own PC can act as a web server if you install IIS or PWS • IIS or PWS turns your computer into a web server • Microsoft IIS and PWS are free web server components I IS - Internet Information Server IIS is a set of Internet-based services for servers created by Microsoft for use with Microsoft Windows. IIS comes with Windows 2000, XP, and Vista. It is also available for Windows NT. IIS is easy to install and ideal for developing and testing web applications. PWS - Personal Web Server PWS is for older Windows system like Windows 95, 98, and NT. PWS is easy to install and can be used for developing and testing web applications including ASP. We don't recommend running PWS for anything else than training. It is outdated and has security issues. Windows Web Server Versions • Windows Vista Business, Enterprise and Ultimate come with IIS 7 • Windows Vista Home Premium comes with IIS 7 • Windows Vista Home Edition does not support PWS or IIS • Windows XP Professional comes with IIS 5.1 • Windows XP Home Edition does not support IIS or PWS • Windows 2000 Professional comes with IIS 5.0 • Windows NT Professional comes with IIS 3 and also supports IIS 4 • Windows NT Workstation supports PWS and IIS 3 • Windows ME does not support PWS or IIS • Windows 98 comes with PWS • Windows 95 supports PWS How to Install IIS on Windows Vista Follow these steps to install IIS on Windows Vista: 1. Open the Control Panel from the Start menu 2. Double-click Programs and Features 3. Click "Turn Windows features on or off" (a link to the left) 4. Select the check box for Internet Information Services (IIS), and click OK After you have installed IIS, make sure you install all patches for bugs and security problems. (Run Windows Update). How to Install IIS on Windows XP and Windows 2000 Follow these steps to install IIS on Windows XP and Windows 2000: 1. On the Start menu, click Settings and select Control Panel 2. Double-click Add or Remove Programs 3. Click Add/Remove Windows Components 4. Click Internet Information Services (IIS) 5. Click Details 6. Select the check box for World Wide Web Service, and click OK 7. In Windows Component selection, click Next to install IIS Test Your Web After you have installed IIS or PWS follow these steps: 1. Look for a new folder called Inetpub on your hard drive 2. Open the Inetpub folder, and find a folder named wwwroot 3. Create a new folder, like "MyWeb", under wwwroot 4. Write some ASP code and save the file as "test1.asp" in the new folder 5. Make sure your Web server is running (see below) 6. Open your browser and type "http://localhost/MyWeb/test1.asp", to view your first web page Note: Look for the IIS (or PWS) symbol in your start menu or task bar. The program has functions for starting and stopping the web server, disable and enable ASP, and much more. ASP Basic Syntax Rules Write Output to a Browser An ASP file normally contains HTML tags, just like an HTML file. However, an ASP file can also contain server scripts, surrounded by the delimiters <% and %>. Server scripts are executed on the server, and can contain any expressions, statements, procedures, or operators valid for the scripting language you prefer to use. The response.write Command The response.write command is used to write output to a browser. The following example sends the text "Hello World" to the browser: Example <% response.write("Hello World!") %> There is also a shorthand method for the response.write command. The following example also sends the text "Hello World" to the browser: Example <% ="Hello World!" %> The example above writes "Hello World!" into the body of the document. Using JavaScript in ASP To set JavaScript as the default scripting language for a particular page you must insert a language specification at the top of the page: <%@ language="javascript"%> <% Response.Write("Hello World!") %> Note: JavaScript is case sensitive! You will have to write your ASP code with uppercase letters and lowercase letters when the language requires it. Other Scripting Languages ASP is shipped with VBScript and JScript (Microsoft's implementation of JavaScript). If you want to script in another language, like PERL, REXX, or Python, you will have to install script engines for them. ASP Variables A variable is used to store information. Declaring a variable: Variables are used to store information. The following example demonstrates how to declare a variable, assign a value to it, and use the value in a text. Declare an array Arrays are used to store a series of related data items. The following example demonstrates how to declare an array that stores names. Loop through the HTML headings How to loop through the six headings in HTML. Time-based greeting using VBScript This example will display a different message to the user depending on the time on the server. Time-based greeting using JavaScript This example is the same as the one above, but the syntax is different. Lifetime of Variables A variable declared outside a procedure can be accessed and changed by any script in the ASP file. A variable declared inside a procedure is created and destroyed every time the procedure is executed. No scripts outside the procedure can access or change the variable. To declare variables accessible to more than one ASP file, declare them as session variables or application variables. Session Variables Session variables are used to store information about ONE single user, and are available to all pages in one application. Typically information stored in session variables are name, id, and preferences. Application Variables Application variables are also available to all pages in one application. Application variables are used to store information about ALL users in one specific application. ASP Procedures In ASP you can call a JavaScript procedure from a VBScript and vice versa. Procedures The ASP source code can contain procedures and functions: Example <% sub vbproc(num1,num2) response.write(num1num2) end sub %> You can call a procedure like this: Result: <%call vbproc(3,4)%> Or, like this: Result: <%vbproc 3,4%> Insert the <%@ language="language" %> line above the tag to write the procedure/function in another scripting language: Example <%@ language="javascript" %> <% function jsproc(num1,num2) { Response.Write(num1num2) } %> Result: <%jsproc(3,4)%> Differences between VBScript and JavaScript When calling a VBScript or a JavaScript procedure from an ASP file written in VBScript, you can use the "call" keyword followed by the procedure name. If a procedure requires parameters, the parameter list must be enclosed in parentheses when using the "call" keyword. If you omit the "call" keyword, the parameter list must not be enclosed in parentheses. If the procedure has no parameters, the parentheses are optional. When calling a JavaScript or a VBScript procedure from an ASP file written in JavaScript, always use parentheses after the procedure name. ASP Forms and User Input The Request.QueryString and Request.Form commands are used to retrieve user input from forms. User Input The Request object can be used to retrieve user information from forms. Example HTML form <form action="simpleform.asp" method="get"> First Name: <input name="fname" type="text" /> Last Name: <input name="lname" type="text" /> <input type="submit" value="Submit" /> </form> User input can be retrieved with the Request.QueryString or Request.Form command. Request.QueryString The Request.QueryString command is used to collect values in a form with method="get". Information sent from a form with the GET method is visible to everyone (it will be displayed in the browser's address bar) and has limits on the amount of information to send. If a user typed "Bill" and "Gates" in the HTML form above, the URL sent to the server would look like this: http://www.w3schools.com/simpleform.asp?fname=Bill&lname=Gates Assume that "simpleform.asp" contains the following ASP script: Welcome <% response.write(request.querystring("fname")) response.write(" " & request.querystring("lname")) %> The browser will display the following in the body of the document: Welcome Bill Gates Examples A form with method="get" How to interact with the user, with the Request.QueryString command. <form action="demo_reqquery.asp" method="get"> Your name: <input name="fname" size="20" type="text" /> <input type="submit" value="Submit" /> </form> <% dim fname fname=Request.QueryString("fname") If fname<>"" Then Response.Write("Hello " & fname & "! ") Response.Write("How are you today?") End If %> ________________________________________ Request.Form The Request.Form command is used to collect values in a form with method="post". Information sent from a form with the POST method is invisible to others and has no limits on the amount of information to send. If a user typed "Bill" and "Gates" in the HTML form above, the URL sent to the server would look like this: http://www.w3schools.com/simpleform.asp Assume that "simpleform.asp" contains the following ASP script: Welcome <% response.write(request.form("fname")) response.write(" " & request.form("lname")) %> The browser will display the following in the body of the document: Welcome Bill Gates Example: A form with method="post" How to interact with the user, with the Request.Form command. <form action="demo_simpleform.asp" method="post"> Your name: <input name="fname" size="20" type="text" /> <input type="submit" value="Submit" /> </form> <% dim fname fname=Request.Form("fname") If fname<>"" Then Response.Write("Hello " & fname & "! ") Response.Write("How are you today?") End If %> A form with radio buttons How to interact with the user, through radio buttons, with the Request.Form command. <% dim cars cars=Request.Form("cars") %> <form action="demo_radiob.asp" method="post"> Please select your favorite car: <input <%if="" cars="Volvo" name="cars" response.write("checked")%="" then="" type="radio" /> value="Volvo">Volvo <input <%if="" cars="Saab" name="cars" response.write("checked")%="" then="" type="radio" /> value="Saab">Saab <input <%if="" cars="BMW" name="cars" response.write("checked")%="" then="" type="radio" /> value="BMW">BMW <input type="submit" value="Submit" /> </form> <% if cars<>"" then Response.Write("Your favorite car is: " & cars & " ") end if %> Form Validation User input should be validated on the browser whenever possible (by client scripts). Browser validation is faster and reduces the server load. You should consider server validation if the user input will be inserted into a database. A good way to validate a form on the server is to post the form to itself, instead of jumping to a different page. The user will then get the error messages on the same page as the form. This makes it easier to discover the error. 7 ASP Cookies What is a Cookie? A cookie is often used to identify a user. A cookie is a small file that the server embeds on the user's computer. Each time the same computer requests a page with a browser, it will send the cookie too. With ASP, you can both create and retrieve cookie values. How to Create a Cookie? The "Response.Cookies" command is used to create cookies. Note: The Response.Cookies command must appear BEFORE the tag. In the example below, we will create a cookie named "firstname" and assign the value "Alex" to it: <% Response.Cookies("firstname")="Alex" %> It is also possible to assign properties to a cookie, like setting a date when the cookie should expire: <% Response.Cookies("firstname")="Alex" Response.Cookies("firstname").Expires=#May 10,2012# %> How to Retrieve a Cookie Value? The "Request.Cookies" command is used to retrieve a cookie value. In the example below, we retrieve the value of the cookie named "firstname" and display it on a page: <% fname=Request.Cookies("firstname") response.write("Firstname=" & fname) %> Output: Firstname=Alex A Cookie with Keys If a cookie contains a collection of multiple values, we say that the cookie has Keys. In the example below, we will create a cookie collection named "user". The "user" cookie has Keys that contains information about a user: <% Response.Cookies("user")("firstname")="John" Response.Cookies("user")("lastname")="Smith" Response.Cookies("user")("country")="Norway" Response.Cookies("user")("age")="25" %> Read all Cookies Look at the following code: <% Response.Cookies("firstname")="Alex" Response.Cookies("user")("firstname")="John" Response.Cookies("user")("lastname")="Smith" Response.Cookies("user")("country")="Norway" Response.Cookies("user")("age")="25" %> Assume that your server has sent all the cookies above to a user. Now we want to read all the cookies sent to a user. The example below shows how to do it (note that the code below checks if a cookie has Keys with the HasKeys property): <% dim x,y for each x in Request.Cookies response.write(" ") if Request.Cookies(x).HasKeys then for each y in Request.Cookies(x) response.write(x & ":" & y & "=" & Request.Cookies(x)(y)) response.write(" ") next else Response.Write(x & "=" & Request.Cookies(x) & " ") end if response.write " " next %> Output: firstname=Alex user:firstname=John user:lastname=Smith user:country=Norway user:age=25 What if a Browser Does NOT Support Cookies? If your application deals with browsers that do not support cookies, you will have to use other methods to pass information from one page to another in your application. There are two ways of doing this: 1. Add parameters to a URL You can add parameters to a URL: <a href="http://www.blogger.com/welcome.asp?fname=John&lname=Smith">Go to Welcome Page</a> And retrieve the values in the "welcome.asp" file like this: <% fname=Request.querystring("fname") lname=Request.querystring("lname") response.write(" Hello " & fname & " " & lname & "! ") response.write("Welcome to my Web site! ") %> 2. Use a form You can use a form. The form passes the user input to "welcome.asp" when the user clicks on the Submit button: <form action="welcome.asp" method="post"> First Name: <input name="fname" type="text" value="" /> Last Name: <input name="lname" type="text" value="" /> <input type="submit" value="Submit" /> </form> Retrieve the values in the "welcome.asp" file like this: <% fname=Request.form("fname") lname=Request.form("lname") response.write(" Hello " & fname & " " & lname & "! ") response.write("Welcome to my Web site! ") %> 8.ASP Session Object A Session object stores information about, or change settings for a user session. The Session object When you are working with an application on your computer, you open it, do some changes and then you close it. This is much like a Session. The computer knows who you are. It knows when you open the application and when you close it. However, on the internet there is one problem: the web server does not know who you are and what you do, because the HTTP address doesn't maintain state. ASP solves this problem by creating a unique cookie for each user. The cookie is sent to the user's computer and it contains information that identifies the user. This interface is called the Session object. The Session object stores information about, or change settings for a user session. Variables stored in a Session object hold information about one single user, and are available to all pages in one application. Common information stored in session variables are name, id, and preferences. The server creates a new Session object for each new user, and destroys the Session object when the session expires. When does a Session Start? A session starts when: • A new user requests an ASP file, and the Global.asa file includes a Session_OnStart procedure • A value is stored in a Session variable • A user requests an ASP file, and the Global.asa file uses the tag to instantiate an object with session scope When does a Session End? A session ends if a user has not requested or refreshed a page in the application for a specified period. By default, this is 20 minutes. If you want to set a timeout interval that is shorter or longer than the default, use the Timeout property. The example below sets a timeout interval of 5 minutes: <% Session.Timeout=5 %> Use the Abandon method to end a session immediately: <% Session.Abandon %> Note: The main problem with sessions is WHEN they should end. We do not know if the user's last request was the final one or not. So we do not know how long we should keep the session "alive". Waiting too long for an idle session uses up resources on the server, but if the session is deleted too soon the user has to start all over again because the server has deleted all the information. Finding the right timeout interval can be difficult! Tip: Only store SMALL amounts of data in session variables! Store and Retrieve Session Variables The most important thing about the Session object is that you can store variables in it. The example below will set the Session variable username to "Donald Duck" and the Session variable age to "50": <% Session("username")="Donald Duck" Session("age")=50 %> When the value is stored in a session variable it can be reached from ANY page in the ASP application: Welcome <%Response.Write(Session("username"))%> The line above returns: "Welcome Donald Duck". You can also store user preferences in the Session object, and then access that preference to choose what page to return to the user. The example below specifies a text-only version of the page if the user has a low screen resolution: <%If Session("screenres")="low" Then%> This is the text version of the page <%Else%> This is the multimedia version of the page <%End If%> Remove Session Variables The Contents collection contains all session variables. It is possible to remove a session variable with the Remove method. The example below removes the session variable "sale" if the value of the session variable "age" is lower than 18: <% If Session.Contents("age")<18 then Session.Contents.Remove("sale") End If %> To remove all variables in a session, use the RemoveAll method: <% Session.Contents.RemoveAll() %> Loop Through the Contents Collection The Contents collection contains all session variables. You can loop through the Contents collection, to see what's stored in it: <% Session("username")="Donald Duck" Session("age")=50 dim i For Each i in Session.Contents Response.Write(i & " ") Next %> Result: username age If you do not know the number of items in the Contents collection, you can use the Count property: <% dim i dim j j=Session.Contents.Count Response.Write("Session variables: " & j) For i=1 to j Response.Write(Session.Contents(i) & " ") Next %> Result: Session variables: 2 Donald Duck 50 Loop Through the StaticObjects Collection You can loop through the StaticObjects collection, to see the values of all objects stored in the Session object: <% dim i For Each i in Session.StaticObjects Response.Write(i & " ") Next %> 9. ASP Application Object A group of ASP files that work together to perform some purpose is called an application. Application Object An application on the Web may consists of several ASP files that work together to perform some purpose. The Application object is used to tie these files together. The Application object is used to store and access variables from any page, just like the Session object. The difference is that ALL users share ONE Application object (with Sessions there is ONE Session object for EACH user). The Application object holds information that will be used by many pages in the application (like database connection information). The information can be accessed from any page. The information can also be changed in one place, and the changes will automatically be reflected on all pages. Store and Retrieve Application Variables Application variables can be accessed and changed by any page in an application. You can create Application variables in "Global.asa" like this: <script language="vbscript" runat="server"> Sub Application_OnStart application("vartime")="" application("users")=1 End Sub </script> In the example above we have created two Application variables: "vartime" and "users". You can access the value of an Application variable like this: There are <% Response.Write(Application("users")) %> active connections. Loop Through the Contents Collection The Contents collection contains all application variables. You can loop through the Contents collection, to see what's stored in it: <% dim i For Each i in Application.Contents Response.Write(i & " ") Next %> If you do not know the number of items in the Contents collection, you can use the Count property: <% dim i dim j j=Application.Contents.Count For i=1 to j Response.Write(Application.Contents(i) & " ") Next %> Loop Through the StaticObjects Collection You can loop through the StaticObjects collection, to see the values of all objects stored in the Application object: <% dim i For Each i in Application.StaticObjects Response.Write(i & " ") Next %> Lock and Unlock You can lock an application with the "Lock" method. When an application is locked, the users cannot change the Application variables (other than the one currently accessing it). You can unlock an application with the "Unlock" method. This method removes the lock from the Application variable: <% Application.Lock 'do some application object operations Application.Unlock %> 10.ASP Including Files The #include Directive You can insert the content of one ASP file into another ASP file before the server executes it, with the #include directive. The #include directive is used to create functions, headers, footers, or elements that will be reused on multiple pages. How to Use the #include Directive Here is a file called "mypage.asp": <h3>Words of Wisdom:</h3><h3>The time is:</h3>Here is the "wisdom.inc" file: "One should never increase, beyond what is necessary, the number of entities required to explain anything." Here is the "time.inc" file: <% Response.Write(Time) %> If you look at the source code in a browser, it will look something like this: <h3>Words of Wisdom:</h3>"One should never increase, beyond what is necessary, the number of entities required to explain anything." <h3>The time is:</h3>11:33:42 AM Syntax for Including Files To include a file in an ASP page, place the #include directive inside comment tags: or The Virtual Keyword Use the virtual keyword to indicate a path beginning with a virtual directory. If a file named "header.inc" resides in a virtual directory named /html, the following line would insert the contents of "header.inc": The File Keyword Use the file keyword to indicate a relative path. A relative path begins with the directory that contains the including file. If you have a file in the html directory, and the file "header.inc" resides in html\headers, the following line would insert "header.inc" in your file: Note that the path to the included file (headers\header.inc) is relative to the including file. If the file containing this #include statement is not in the html directory, the statement will not work. Tips and Notes In the sections above we have used the file extension ".inc" for included files. Notice that if a user tries to browse an INC file directly, its content will be displayed. If your included file contains confidential information or information you do not want any users to see, it is better to use an ASP extension. The source code in an ASP file will not be visible after the interpretation. An included file can also include other files, and one ASP file can include the same file more than once. Important: Included files are processed and inserted before the scripts are executed. The following script will NOT work because ASP executes the #include directive before it assigns a value to the variable: <% fname="header.inc" %> You cannot open or close a script delimiter in an INC file. The following script will NOT work: <% For i = 1 To n Next %> But this script will work: <% For i = 1 to n %> <% Next %> 11.ASP The Global.asa file The Global.asa file The Global.asa file is an optional file that can contain declarations of objects, variables, and methods that can be accessed by every page in an ASP application. All valid browser scripts (JavaScript, VBScript, JScript, PerlScript, etc.) can be used within Global.asa. The Global.asa file can contain only the following: • Application events • Session events • declarations • TypeLibrary declarations • the #include directive Note: The Global.asa file must be stored in the root directory of the ASP application, and each application can only have one Global.asa file. Events in Global.asa In Global.asa you can tell the application and session objects what to do when the application/session starts and what to do when the application/session ends. The code for this is placed in event handlers. The Global.asa file can contain four types of events: Application_OnStart - Occurs when the FIRST user calls the first page in an ASP application. This event occurs after the Web server is restarted or after the Global.asa file is edited. The "Session_OnStart" event occurs immediately after this event. Session_OnStart - This event occurs EVERY time a NEW user requests his or her first page in the ASP application. Session_OnEnd - This event occurs EVERY time a user ends a session. A user-session ends after a page has not been requested by the user for a specified time (by default this is 20 minutes). Application_OnEnd - This event occurs after the LAST user has ended the session. Typically, this event occurs when a Web server stops. This procedure is used to clean up settings after the Application stops, like delete records or write information to text files. A Global.asa file could look something like this: <script language="vbscript" runat="server"> sub Application_OnStart 'some code end sub sub Application_OnEnd 'some code end sub sub Session_OnStart 'some code end sub sub Session_OnEnd 'some code end sub </script> Note: Because we cannot use the ASP script delimiters (<% and %>) to insert scripts in the Global.asa file, we put subroutines inside an HTML <script> element. Declarations It is possible to create objects with session or application scope in Global.asa by using the tag. Note: The tag should be outside the <script> tag! Syntax .... </object> Parameter Description scope Sets the scope of the object (either Session or Application) id Specifies a unique id for the object ProgID An id associated with a class id. The format for ProgID is [Vendor.]Component[.Version] Either ProgID or ClassID must be specified. ClassID Specifies a unique id for a COM class object. Either ProgID or ClassID must be specified. Examples The first example creates an object of session scope named "MyAd" by using the ProgID parameter: </object> The second example creates an object of application scope named "MyConnection" by using the ClassID parameter: </object> The objects declared in the Global.asa file can be used by any script in the application: GLOBAL.ASA: </object> You could reference the object "MyAd" from any page in the ASP application: SOME .ASP FILE: <%=MyAd.GetAdvertisement("/banners/adrot.txt")%> TypeLibrary Declarations A TypeLibrary is a container for the contents of a DLL file corresponding to a COM object. By including a call to the TypeLibrary in the Global.asa file, the constants of the COM object can be accessed, and errors can be better reported by the ASP code. If your Web application relies on COM objects that have declared data types in type libraries, you can declare the type libraries in Global.asa. Syntax  Parameter Description file Specifies an absolute path to a type library. Either the file parameter or the uuid parameter is required uuid Specifies a unique identifier for the type library. Either the file parameter or the uuid parameter is required version Optional. Used for selecting version. If the requested version is not found, then the most recent version is used lcid Optional. The locale identifier to be used for the type library Error Values The server can return one of the following error messages: Error Code Description ASP 0222 Invalid type library specification ASP 0223 Type library not found ASP 0224 Type library cannot be loaded ASP 0225 Type library cannot be wrapped Note: METADATA tags can appear anywhere in the Global.asa file (both inside and outside <script> tags). However, it is recommended that METADATA tags appear near the top of the Global.asa file. Restrictions Restrictions on what you can include in the Global.asa file: • You cannot display text written in the Global.asa file. This file can't display information • You can only use Server and Application objects in the Application_OnStart and Application_OnEnd subroutines. In the Session_OnEnd subroutine, you can use Server, Application, and Session objects. In the Session_OnStart subroutine you can use any built-in object ________________________________________ How to use the Subroutines Global.asa is often used to initialize variables. The example below shows how to detect the exact time a visitor first arrives on a Web site. The time is stored in a Session variable named "started", and the value of the "started" variable can be accessed from any ASP page in the application: <script language="vbscript" runat="server"> sub Session_OnStart Session("started")=now() end sub </script> Global.asa can also be used to control page access. The example below shows how to redirect every new visitor to another page, in this case to a page called "newpage.asp": <script language="vbscript" runat="server"> sub Session_OnStart Response.Redirect("newpage.asp") end sub </script> And you can include functions in the Global.asa file. In the example below the Application_OnStart subroutine occurs when the Web server starts. Then the Application_OnStart subroutine calls another subroutine named "getcustomers". The "getcustomers" subroutine opens a database and retrieves a record set from the "customers" table. The record set is assigned to an array, where it can be accessed from any ASP page without querying the database: <script language="vbscript" runat="server"> sub Application_OnStart getcustomers end sub sub getcustomers set conn=Server.CreateObject("ADODB.Connection") conn.Provider="Microsoft.Jet.OLEDB.4.0" conn.Open "c:/webdata/northwind.mdb" set rs=conn.execute("select name from customers") Application("customers")=rs.GetRows rs.Close conn.Close end sub </script> ________________________________________ Global.asa Example In this example we will create a Global.asa file that counts the number of current visitors. • The Application_OnStart sets the Application variable "visitors" to 0 when the server starts • The Session_OnStart subroutine adds one to the variable "visitors" every time a new visitor arrives • The Session_OnEnd subroutine subtracts one from "visitors" each time this subroutine is triggered The Global.asa file: <script language="vbscript" runat="server"> Sub Application_OnStart Application("visitors")=0 End Sub Sub Session_OnStart Application.Lock Application("visitors")=Application("visitors")+1 Application.UnLock End Sub Sub Session_OnEnd Application.Lock Application("visitors")=Application("visitors")-1 Application.UnLock End Sub </script> To display the number of current visitors in an ASP file: There are <%response.write(Application("visitors"))%> online now! 12.ASP Sending e-mail with CDOSYS CDOSYS is a built-in component in ASP. This component is used to send e-mails with ASP. ________________________________________ Sending e-mail with CDOSYS CDO (Collaboration Data Objects) is a Microsoft technology that is designed to simplify the creation of messaging applications. CDOSYS is a built-in component in ASP. We will show you how to use this component to send e-mail with ASP. How about CDONTs? Microsoft has discontinued the use of CDONTs on Windows 2000, Windows XP and Windows 2003. If you have used CDONTs in your ASP applications, you should update the code and use the new CDO technology. Examples using CDOSYS Sending a text e-mail: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.TextBody="This is a message." myMail.Send set myMail=nothing %> Sending a text e-mail with Bcc and CC fields: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.Bcc="someoneelse@somedomain.com" myMail.Cc="someoneelse2@somedomain.com" myMail.TextBody="This is a message." myMail.Send set myMail=nothing %> Sending an HTML e-mail: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.HTMLBody = " <h1> This is a message.</h1>" myMail.Send set myMail=nothing %> Sending an HTML e-mail that sends a webpage from a website: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.CreateMHTMLBody "http://www.w3schools.com/asp/" myMail.Send set myMail=nothing %> Sending an HTML e-mail that sends a webpage from a file on your computer: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.CreateMHTMLBody "file://c:/mydocuments/test.htm" myMail.Send set myMail=nothing %> Sending a text e-mail with an Attachment: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.TextBody="This is a message." myMail.AddAttachment "c:\mydocuments\test.txt" myMail.Send set myMail=nothing %> Sending a text e-mail using a remote server: <% Set myMail=CreateObject("CDO.Message") myMail.Subject="Sending email with CDO" myMail.From="mymail@mydomain.com" myMail.To="someone@somedomain.com" myMail.TextBody="This is a message." myMail.Configuration.Fields.Item _ ("http://schemas.microsoft.com/cdo/configuration/sendusing")=2 'Name or IP of remote SMTP server myMail.Configuration.Fields.Item _ ("http://schemas.microsoft.com/cdo/configuration/smtpserver")="smtp.server.com" 'Server port myMail.Configuration.Fields.Item _ ("http://schemas.microsoft.com/cdo/configuration/smtpserverport")=25 myMail.Configuration.Fields.Update myMail.Send set myMail=nothing %> II ASP Objects 1)ASP Response Object The ASP Response object is used to send output to the user from the server. Response Object The ASP Response object is used to send output to the user from the server. Its collections, properties, and methods are described below: Collections Collection Description Cookies Sets a cookie value. If the cookie does not exist, it will be created, and take the value that is specified Properties Property Description Buffer Specifies whether to buffer the page output or not CacheControl Sets whether a proxy server can cache the output generated by ASP or not Charset Appends the name of a character-set to the content-type header in the Response object ContentType Sets the HTTP content type for the Response object Expires Sets how long (in minutes) a page will be cached on a browser before it expires ExpiresAbsolute Sets a date and time when a page cached on a browser will expire IsClientConnected Indicates if the client has disconnected from the server Pics Appends a value to the PICS label response header Status Specifies the value of the status line returned by the server Methods Method Description AddHeader Adds a new HTTP header and a value to the HTTP response AppendToLog Adds a string to the end of the server log entry BinaryWrite Writes data directly to the output without any character conversion Clear Clears any buffered HTML output End Stops processing a script, and returns the current result Flush Sends buffered HTML output immediately Redirect Redirects the user to a different URL Write Writes a specified string to the output ASP Cookies Collection The Cookies collection is used to set or get cookie values. If the cookie does not exist, it will be created, and take the value that is specified. Note: The Response.Cookies command must appear before the tag. Syntax Response.Cookies(name)[(key)|.attribute]=value variablename=Request.Cookies(name)[(key)|.attribute] Parameter Description name Required. The name of the cookie value Required for the Response.Cookies command. The value of the cookie attribute Optional. Specifies information about the cookie. Can be one of the following parameters: • Domain - Write-only. The cookie is sent only to requests to this domain • Expires - Write-only. The date when the cookie expires. If no date is specified, the cookie will expire when the session ends • HasKeys - Read-only. Specifies whether the cookie has keys (This is the only attribute that can be used with the Request.Cookies command) • Path - Write-only. If set, the cookie is sent only to requests to this path. If not set, the application path is used • Secure - Write-only. Indicates if the cookie is secure key Optional. Specifies the key to where the value is assigned Examples The "Response.Cookies" command is used to create a cookie or to set a cookie value: <% Response.Cookies("firstname")="Alex" %> In the code above, we have created a cookie named "firstname" and assigned the value "Alex" to it. It is also possible to assign some attributes to a cookie, like setting a date when a cookie should expire: <% Response.Cookies("firstname")="Alex" Response.Cookies("firstname").Expires=#May 10,2002# %> Now the cookie named "firstname" has the value of "Alex", and it will expire from the user's computer at May 10, 2002. The "Request.Cookies" command is used to get a cookie value. In the example below, we retrieve the value of the cookie "firstname" and display it on a page: <% fname=Request.Cookies("firstname") response.write("Firstname=" & fname) %> Output: Firstname=Alex A cookie can also contain a collection of multiple values. We say that the cookie has Keys. In the example below, we will create a cookie-collection named "user". The "user" cookie has Keys that contains information about a user: <% Response.Cookies("user")("firstname")="John" Response.Cookies("user")("lastname")="Smith" Response.Cookies("user")("country")="Norway" Response.Cookies("user")("age")="25" %> The code below reads all the cookies your server has sent to a user. Note that the code checks if a cookie has Keys with the HasKeys property: <% dim x,y for each x in Request.Cookies response.write(" ") if Request.Cookies(x).HasKeys then for each y in Request.Cookies(x) response.write(x & ":" & y & "=" & Request.Cookies(x)(y)) response.write(" " next %> %> Output: firstname=Alex user:firstname=John user:lastname=Smith user: country=Norway user: age=25 Properties: ASP Buffer Property The Buffer property specifies whether to buffer the output or not. When the output is buffered, the server will hold back the response to the browser until all of the server scripts have been processed, or until the script calls the Flush or End method. Note: If this property is set, it should be before the tag in the .asp file Syntax response.Buffer[=flag] Parameter Description flag A boolean value that specifies whether to buffer the page output or not. False indicates no buffering. The server will send the output as it is processed. False is default for IIS version 4.0 (and earlier). Default for IIS version 5.0 (and later) is true. True indicates buffering. The server will not send output until all of the scripts on the page have been processed, or until the Flush or End method has been called. Examples Example 1 In this example, there will be no output sent to the browser before the loop is finished. If buffer was set to False, then it would write a line to the browser every time it went through the loop. <%response.Buffer=true%> <% for i=1 to 100 response.write(i & " ") next %> Example 2 <%response.Buffer=true%> I write some text, but I will control when the text will be sent to the browser. The text is not sent yet. I hold it back! OK, let it go! <%response.Flush%> Example 3 <%response.Buffer=true%> This is some text I want to send to the user. No, I changed my mind. I want to clear the text. <%response.Clear%> ASP CacheControl Property The CacheControl property sets whether a proxy server can cache the output generated by ASP or not. By default, a proxy server will not keep a cache copy. Syntax response.CacheControl[=control_header] Parameter Description control_header A cache control header that can be set to "Public" or "Private". Private is default and indicates that only private caches may cache this page. Proxy servers will not cache pages with this setting. Public indicates public caches. Proxy servers will cache pages with this setting. Examples <%response.CacheControl="Public"%> or <%response.CacheControl="Private"%> ASP Charset Property The Charset property appends the name of a character-set to the content-type header in the Response object. Default character set is ISO-LATIN-1. Note: This property will accept any string, regardless of whether it is a valid character set or not, for the name. Syntax response.Charset(charsetname) Parameter Description charsetname A string that specifies a character set for the page Examples If an ASP page has no Charset property set, the content-type header would be: content-type:text/html If we included the Charset property: <%response.Charset="ISO-8859-1"%> the content-type header would be: content-type:text/html; charset=ISO-8859-1 ASP ContentType Property The ContentType property sets the HTTP content type for the response object. Syntax response.ContentType[=contenttype] Parameter Description contenttype A string describing the content type. For a full list of content types, see your browser documentation or the HTTP specification. Examples If an ASP page has no ContentType property set, the default content-type header would be: content-type:text/html Some other common ContentType values: <%response.ContentType="text/HTML"%> <%response.ContentType="image/GIF"%> <%response.ContentType="image/JPEG"%> <%response.ContentType="text/plain"%> <%response.ContentType="image/JPEG"%> This example will open an Excel spreadsheet in a browser (if the user has Excel installed): <%response.ContentType="application/vnd.ms-excel"%> <table><tbody> <tr> <td>1</td> <td>2</td> <td>3</td> <td>4</td> </tr> <tr> <td>5</td> <td>6</td> <td>7</td> <td>8</td> </tr> </tbody></table>ASP Expires Property The Expires property sets how long (in minutes) a page will be cached on a browser before it expires. If a user returns to the same page before it expires, the cached version is displayed. Syntax response.Expires[=number] Parameter Description number The time in minutes before the page expires Examples Example 1 The following code indicates that the page will never be cached: <%response.Expires=-1%> Example 2 The following code indicates that the page will expire after 1440 minutes (24 hours): <%response.Expires=1440%> ASP ExpiresAbsolute Property The ExpiresAbsolute property sets a date and time when a cached page on a browser will expire. If a user returns to the same page before this date/time, the cached version is displayed. Syntax response.ExpiresAbsolute[=[date][time]] Parameter Description date Specifies the date on which the page will expire. If this parameter is not specified, the page will expire at the specified time on the day that the script is run. time Specifies the time at which the page will expire. If this parameter is not specified, the page will expire at midnight of the specified day. Examples The following code indicates that the page will expire at 4:00 PM on October 11, 2009: <%response.ExpiresAbsolute=#October 11,2009 16:00:00#%> ASP IsClientConnected Property The IsClientConnected property indicates if the client has disconnected from the server. Syntax response.IsClientConnected Examples <% If response.IsClientConnected=true then response.write("The user is still connected!") else response.write("The user is not connected!") end if %> ASP PICS Property The PICS property appends a value to the PICS label response header. Note: This property will accept any string value, regardless of whether it is a valid PICS label or not. What is PICS? The PICS (Platform for Internet Content Selection) rating system is used to rate the content in a web site. It looks something like this: PICS-1.1 "http://www.rsac.org/ratingsv01.html" by "your@name.com" for "http://www.somesite.com" on "2002.10.05T02:15-0800" r (n 0 s 0 v 0 l 0) Part Description PICS-1.1 PICS version number "http://www.rsac.org/ratingsv01.html" Rating organization by "your@name.com" Author of the label for "http://www.somesite.com" The URL or the document that has been rated on "2002.10.05T02:15-0800" Expiration date r (n 0 s 0 v 0 l 0) Rating One of the most popular rating system is RSACi (Recreational Software Advisory Council on the Internet). RSACi rating system uses four categories: violence, nudity, sex, and language. A number between 0 to 4 is assigned to each category. 0 means that the page does not contain any potentially offensive content and 4 means that the page contains the highest levels of potentially offensive content. Level Violence Rating Nudity Rating Sex Rating Language Rating 0 None of the below or sports related None of the below None of the below or innocent kissing; romance None of the below 1 Injury to human being Revealing attire Passionate kissing Mild expletives 2 Destruction of realistic objects Partial nudity Clothed sexual touching Moderate expletives or profanity 3 Aggressive violence or death to humans Frontal nudity Non-explicit sexual acts Strong language or hate speech 4 Rape or wanton, gratuitous violence Frontal nudity (qualifying as provocative display) Explicit sexual acts or sex crimes Crude, vulgar language or extreme hate speech There are two ways you can obtain rating for your site. You can either rate your site yourself or use a rating provider, like RSACi. They'll ask you fill out some questions. After filling out the questions, you will get the rating label for your site. Microsoft IE 3.0 and above and Netscape 4.5 and above support the content ratings. You can set the ratings in IE 5, by selecting Tools and Internet Options. Select the Content tab and click the Enable. When the rating exceeds the defined levels the Content Advisor will block the site. You can set the ratings in Netscape 4.7, by selecting Help and NetWatch. We can use the META tag or the response.PICS property to add a rating to our site. Syntax response.PICS(picslabel) Parameter Description picslabel A properly formatted PICS label Examples For an ASP file that includes: Note: Because PICS labels contain quotes, you must replace quotes with " & chr(34) & ". <% response.PICS("(PICS-1.1 <http: ratingv01.html="" www.rsac.org=""> by " & chr(34) & "your@name.com" & chr(34) & " for " & chr(34) & "http://www.somesite.com" & chr(34) & " on " & chr(34) & "2002.10.05T02:15-0800" & chr(34) & " r (n 2 s 0 v 1 l 2))") %> the following header is added: PICS-label:(PICS-1.1 <http: ratingv01.html="" www.rsac.org=""> by "your@name.com" for "http://www.somesite.com" on "2002.10.05T02:15-0800" r (n 2 s 0 v 1 l 2)) ASP Status Property The Status property specifies the value of the status line returned by the server. Tip: Use this property to modify the status line returned by the server. Syntax response.Status=statusdescription Parameter Description statusdescription A three-digit number and a description of that code, like 404 Not Found. Note: Status values are defined in the HTTP specification. Examples <% ip=request.ServerVariables("REMOTE_ADDR") if ip<>"194.248.333.500" then response.Status="401 Unauthorized" response.Write(response.Status) response.End end if %> Methods: ASP AddHeader Method The AddHeader method adds a new HTTP header and a value to the HTTP response. Note: Once a header has been added, it cannot be removed. Note: In IIS 4.0 you have to call this method before any output is sent to the browser. In IIS 5.0 you can call the AddHeader method at any point in the script, as long as it precedes any calls to the response.Flush method. Syntax response.AddHeader name,value Parameter Description name Required. The name of the new header variable (cannot contain underscores) value Required. The initial value of the new header variable Examples <%Response.AddHeader "WARNING","Error message text"%> ASP AppendToLog Method The AppendToLog method adds a string to the end of server log entry for this request. You can call this method multiple times in a script. Each time it is called it will append the specified string to the log entry. Syntax response.AppendToLog string Parameter Description string Required. The text to append to the log file (cannot contain any comma characters) Examples <%Response.AppendToLog "My log message"%> ASP BinaryWrite Method The BinaryWrite method writes data directly to the output without any character conversion. Tip: This method is used to write image data (BLOB) from a database to a browser. Syntax response.BinaryWrite data Parameter Description data Required. The binary information to be sent Example If you have an object that generates an array of bytes, you can use BinaryWrite to send the bytes to an application: <% Set objBinaryGen=Server.CreateObject("MyComponents.BinaryGenerator") pic=objBinaryGen.MakePicture response.BinaryWrite pic %> ASP Clear Method The Clear method clears any buffered HTML output. Note: This method does not clear the response headers, only the response body. Note: If response.Buffer is false, this method will cause a run-time error. Syntax response.Clear Examples <% response.Buffer=true %> </http:></http:> This is some text I want to send to the user. No, I changed my mind. I want to clear the text. <% response.Clear %> Output: (nothing) ASP End Method The End method stops processing a script, and returns the current result. Note: This method will flush the buffer if Response.Buffer has been set to true. If you do not want to return any output to the user, you should call Response.Clear first. Syntax Response.End Examples I am writing some text. This text will never be <% Response.End %> finished! It's too late to write more! Output: I am writing some text. This text will never be ASP Flush Method The Flush method sends buffered HTML output immediately. Note: If response.Buffer is false, this method will cause a run-time error. Syntax Response.Flush Example <% Response.Buffer=true %> I write some text, but I will control when the text will be sent to the browser. The text is not sent yet. I hold it back! OK, let it go! <% Response.Flush %> Output: I write some text, but I will control when the text will be sent to the browser. The text is not sent yet. I hold it back! OK, let it go! ASP Redirect Method The Redirect method redirects the user to a different URL. Syntax Response.Redirect URL Parameter Description URL Required. The URL that the user (browser) is redirected to Examples <% Response.Redirect "http://www.w3schools.com" %> ASP Write Method The Write method writes a specified string to the output. Syntax Response.Write variant Parameter Description variant Required. The data to write Examples Example 1 <% Response.Write "Hello World" %> Output: Hello World Example 2 <% name="John" Response.Write(name) %> Output: John Example 3 <% Response.Write("Hello World") %> Output: Hello World Try it Yourself – Examples 1)Write text with ASP- How to write text with ASP. <% response.write("Hello World!") %> 2) Format text with HTML tags in ASP- How to combine text and HTML tags with ASP. <% response.write(" <h2> You can use HTML tags to format the text!</h2>") %> <% response.write(" <div style="color: blue;">This text is styled with the style attribute!</div>") %> 3) Redirect the user to a different URL -How to redirect the user to a different URL. <% if Request.Form("select")<>"" then Response.Redirect(Request.Form("select")) end if %> <form action="demo_redirect.asp" method="post"><input name="select" type="radio" value="demo_server.asp" /> Server Example <input name="select" type="radio" value="demo_text.asp" /> Text Example <input type="submit" value="Go!" /> </form>4)Show a random link-How to create a random link. <% randomize() r=rnd() if r>0.5 then response.write("<a href="http://www.w3schools.com/">W3Schools.com!</a>") else response.write("<a href="http://www.refsnesdata.no/">Refsnesdata.no!</a>") end if %> This example demonstrates a link, each time you load the page, it will display one of two links: W3Schools.com! OR Refsnesdata.no! There is a 50% chance for each of them. 5)Controlling the buffer-How to control the buffer. <% Response.Buffer=true %> This text will be sent to your browser when my response buffer is flushed. <% Response.Flush %> 6) Clear the buffer-How to clear the buffer. <% Response.Buffer=true %> This is some text I want to send to the user. No, I changed my mind. I want to clear the text. <% Response.Clear %> 7) End a script in the middle of processing and return the result-How to end a script in the middle of processing. I am writing some text. This text will never be <% Response.End %> finished! It's too late to write more! 8) Set how many minutes a page will be cached in a browser before it expires -How to specify how many minutes a page will be cached in a browser before it expires. <%Response.Expires=-1%> This page will be refreshed with each access! 9)Set a date/time when a page cached in a browser will expire-How to specify a date/time a page cached in a browser will expire. <% Response.ExpiresAbsolute=#May 05,2001 05:30:30# %> This page will expire on May 05, 2001 05:30:30! 10) Check if the user is still connected to the server-How to check if a user is disconnected from the server. <% If Response.IsClientConnected=true then Response.Write("The user is still connected!") else Response.Write("The user is not connected!") end if %> 11) Set the type of content-How to specify the type of content. <% Response.ContentType="text/html" %> This is some text 12) Set the name of the character set-How to specify the name of the character set. <% Response.Charset="ISO8859-1" %> This is some text 2.ASP Request Object The Request object is used to get information from a visitor. Request Object When a browser asks for a page from a server, it is called a request. The Request object is used to get information from a visitor. Its collections, properties, and methods are described below: Collections Collection Description ClientCertificate Contains all the field values stored in the client certificate Cookies Contains all the cookie values sent in a HTTP request Form Contains all the form (input) values from a form that uses the post method QueryString Contains all the variable values in a HTTP query string ServerVariables Contains all the server variable values Properties Property Description TotalBytes Returns the total number of bytes the client sent in the body of the request Methods Method Description BinaryRead Retrieves the data sent to the server from the client as part of a post request and stores it in a safe array Collections: ASP Cookies Collection The Cookies collection is used to set or get cookie values. If the cookie does not exist, it will be created, and take the value that is specified. Note: The Response.Cookies command must appear before the tag. Syntax Response.Cookies(name)[(key)|.attribute]=value variablename=Request.Cookies(name)[(key)|.attribute] Parameter Description name Required. The name of the cookie value Required for the Response.Cookies command. The value of the cookie attribute Optional. Specifies information about the cookie. Can be one of the following parameters: • Domain - Write-only. The cookie is sent only to requests to this domain • Expires - Write-only. The date when the cookie expires. If no date is specified, the cookie will expire when the session ends • HasKeys - Read-only. Specifies whether the cookie has keys (This is the only attribute that can be used with the Request.Cookies command) • Path - Write-only. If set, the cookie is sent only to requests to this path. If not set, the application path is used • Secure - Write-only. Indicates if the cookie is secure key Optional. Specifies the key to where the value is assigned Examples The "Response.Cookies" command is used to create a cookie or to set a cookie value: <% Response.Cookies("firstname")="Alex" %> In the code above, we have created a cookie named "firstname" and assigned the value "Alex" to it. It is also possible to assign some attributes to a cookie, like setting a date when a cookie should expire: <% Response.Cookies("firstname")="Alex" Response.Cookies("firstname").Expires=#May 10,2002# %> Now the cookie named "firstname" has the value of "Alex", and it will expire from the user's computer at May 10, 2002. The "Request.Cookies" command is used to get a cookie value. In the example below, we retrieve the value of the cookie "firstname" and display it on a page: <% fname=Request.Cookies("firstname") response.write("Firstname=" & fname) %> Output: Firstname=Alex A cookie can also contain a collection of multiple values. We say that the cookie has Keys. In the example below, we will create a cookie-collection named "user". The "user" cookie has Keys that contains information about a user: <% Response.Cookies("user")("firstname")="John" Response.Cookies("user")("lastname")="Smith" Response.Cookies("user")("country")="Norway" Response.Cookies("user")("age")="25" %> The code below reads all the cookies your server has sent to a user. Note that the code checks if a cookie has Keys with the HasKeys property: <% dim x,y for each x in Request.Cookies response.write("") if Request.Cookies(x).HasKeys then for each y in Request.Cookies(x) response.write(x & ":" & y & "=" & Request.Cookies(x)(y)) response.write(" " next %> %> Output: firstname=Alex user:firstname=John user:lastname=Smith user: country=Norway user: age=25 ASP Form Collection The Form collection is used to retrieve the values of form elements from a form that uses the POST method. Syntax Request.Form(element)[(index)|.Count] Parameter Description element Required. The name of the form element from which the collection is to retrieve values index Optional. Specifies one of multiple values for a parameter. From 1 to Request.Form(parameter).Count. Examples Example 1 You can loop through all the values in a form request. If a user filled out a form by specifying two values - Blue and Green - for the color element, you could retrieve those values like this: <% for i=1 to Request.Form("color").Count Response.Write(Request.Form("color")(i) & " ") next %> Output: Blue Green Example 2 Consider the following form: <form action="submit.asp" method="post">First name: <input name="firstname" /> Last name: <input name="lastname" /> Your favorite color: <select name="color"> <option>Blue</option> <option>Green</option> <option>Red</option> <option>Yellow</option> <option>Pink</option> </select> <input type="submit" /></form>The following request might be sent: firstname=John&lastname=Dove&color=Red Now we can use the information from the form in a script: Hi, <%=Request.Form("firstname")%>. Your favorite color is <%=Request.Form("color")%>. Output: Hi, John. Your favorite color is Red. If you do not specify any element to display, like this: Form data is: <%=Request.Form%> the output would look like this: Form data is: firstname=John&lastname=Dove&color=Red ASP QueryString Collection The QueryString collection is used to retrieve the variable values in the HTTP query string. The HTTP query string is specified by the values following the question mark (?), like this: <a href="http://www.blogger.com/test.asp?txt=this%20is%20a%20query%20string%20test">Link with a query string</a> The line above generates a variable named txt with the value "this is a query string test". Query strings are also generated by form submission, or by a user typing a query into the address bar of the browser. Note: If you want to send large amounts of data (beyond 100 kb) the Request.QueryString cannot be used. Syntax Request.QueryString(variable)[(index)|.Count] Parameter Description variable Required. The name of the variable in the HTTP query string to retrieve index Optional. Specifies one of multiple values for a variable. From 1 to Request.QueryString(variable).Count Examples Example 1 To loop through all the n variable values in a Query String: The following request is sent: http://www.w3schools.com/test/names.asp?n=John&n=Susan and names.asp contains the following script: <% for i=1 to Request.QueryString("n").Count Response.Write(Request.QueryString("n")(i) & " ") next %> The file names.asp would display the following: John Susan Example 2 The following string might be sent: http://www.w3schools.com/test/names.asp?name=John&age=30 this results in the following QUERY_STRING value: name=John&age=30 Now we can use the information in a script: Hi, <%=Request.QueryString("name")%>. Your age is <%= Request.QueryString("age")%>. Output: Hi, John. Your age is 30. If you do not specify any variable values to display, like this: Query string is: <%=Request.QueryString%> the output would look like this: Query string is: name=John&age=30 ASP ServerVariables Collection ________________________________________ The ServerVariables collection is used to retrieve the server variable values. Syntax Request.ServerVariables (server_variable) Parameter Description server_variable Required. The name of the server variable to retrieve Server Variables Variable Description ALL_HTTP Returns all HTTP headers sent by the client. Always prefixed with HTTP_ and capitalized ALL_RAW Returns all headers in raw form APPL_MD_PATH Returns the meta base path for the application for the ISAPI DLL APPL_PHYSICAL_PATH Returns the physical path corresponding to the meta base path AUTH_PASSWORD Returns the value entered in the client's authentication dialog AUTH_TYPE The authentication method that the server uses to validate users AUTH_USER Returns the raw authenticated user name CERT_COOKIE Returns the unique ID for client certificate as a string CERT_FLAGS bit0 is set to 1 if the client certificate is present and bit1 is set to 1 if the cCertification authority of the client certificate is not valid CERT_ISSUER Returns the issuer field of the client certificate CERT_KEYSIZE Returns the number of bits in Secure Sockets Layer connection key size CERT_SECRETKEYSIZE Returns the number of bits in server certificate private key CERT_SERIALNUMBER Returns the serial number field of the client certificate CERT_SERVER_ISSUER Returns the issuer field of the server certificate CERT_SERVER_SUBJECT Returns the subject field of the server certificate CERT_SUBJECT Returns the subject field of the client certificate CONTENT_LENGTH Returns the length of the content as sent by the client CONTENT_TYPE Returns the data type of the content GATEWAY_INTERFACE Returns the revision of the CGI specification used by the server HTTP_<headername> Returns the value stored in the header HeaderName HTTP_ACCEPT Returns the value of the Accept header HTTP_ACCEPT_LANGUAGE Returns a string describing the language to use for displaying content HTTP_COOKIE Returns the cookie string included with the request HTTP_REFERER Returns a string containing the URL of the page that referred the request to the current page using an <a href="http://www.blogger.com/post-edit.do"> tag. If the page is redirected, HTTP_REFERER is empty HTTP_USER_AGENT Returns a string describing the browser that sent the request HTTPS Returns ON if the request came in through secure channel or OFF if the request came in through a non-secure channel HTTPS_KEYSIZE Returns the number of bits in Secure Sockets Layer connection key size HTTPS_SECRETKEYSIZE Returns the number of bits in server certificate private key HTTPS_SERVER_ISSUER Returns the issuer field of the server certificate HTTPS_SERVER_SUBJECT Returns the subject field of the server certificate INSTANCE_ID The ID for the IIS instance in text format INSTANCE_META_PATH The meta base path for the instance of IIS that responds to the request LOCAL_ADDR Returns the server address on which the request came in LOGON_USER Returns the Windows account that the user is logged into PATH_INFO Returns extra path information as given by the client PATH_TRANSLATED A translated version of PATH_INFO that takes the path and performs any necessary virtual-to-physical mapping QUERY_STRING Returns the query information stored in the string following the question mark (?) in the HTTP request REMOTE_ADDR Returns the IP address of the remote host making the request REMOTE_HOST Returns the name of the host making the request REMOTE_USER Returns an unmapped user-name string sent in by the user REQUEST_METHOD Returns the method used to make the request SCRIPT_NAME Returns a virtual path to the script being executed SERVER_NAME Returns the server's host name, DNS alias, or IP address as it would appear in self-referencing URLs SERVER_PORT Returns the port number to which the request was sent SERVER_PORT_SECURE Returns a string that contains 0 or 1. If the request is being handled on the secure port, it will be 1. Otherwise, it will be 0 SERVER_PROTOCOL Returns the name and revision of the request information protocol SERVER_SOFTWARE Returns the name and version of the server software that answers the request and runs the gateway URL Returns the base portion of the URL ________________________________________ Examples Example 1 You can loop through all of the server variables like this: <% for each x in Request.ServerVariables response.write(x & " ") next > Example 2 This example demonstrates how to find out the visitor's browser type, IP address, and more: You are browsing this site with: <%Response.Write(Request.ServerVariables("http_user_agent"))%> Your IP address is: <%Response.Write(Request.ServerVariables("remote_addr"))%> The DNS lookup of the IP address is: <%Response.Write(Request.ServerVariables("remote_host"))%> The method used to call the page: <%Response.Write(Request.ServerVariables("request_method"))%> The server's domain name: <%Response.Write(Request.ServerVariables("server_name"))%> The server's port: <%Response.Write(Request.ServerVariables("server_port"))%> The server's software: <%Response.Write(Request.ServerVariables("server_software"))%> Properties ASP TotalBytes Property The TotalBytes property is a read-only property that returns the total number of bytes the client sent in the body of the request. Syntax varbytes=Request.Totalbytes Example The following code sets the variable a equal to the total number of bytes sent in the body of the request: <% dim a a=Request.TotalBytes %> ASP BinaryRead Method The BinaryRead method is used to retrieve the data sent to the server from the client as part of a POST request. It will store the data in a safe array (an array that stores information about the number of dimensions and the bounds of its dimensions). Note: A call to Request.Form after a call to BinaryRead, and vice-versa, will cause an error. Syntax Request.BinaryRead(count) Parameter Description count Required. Specifies how many bytes to read from the client Examples The following example uses the BinaryRead method to place the content of a request into a safe array: <% dim a,b a=Request.TotalBytes b=Request.BinaryRead(a) %> 3) ASP Application Object A group of ASP files that work together to perform some purpose is called an application. The Application object is used to tie these files together. Application Object An application on the Web may consists of several ASP files that work together to perform some purpose. The Application object is used to tie these files together. The Application object is used to store and access variables from any page, just like the Session object. The difference is that ALL users share ONE Application object (with Sessions there is ONE Session object for EACH user). The Application object holds information that will be used by many pages in the application (like database connection information). The information can be accessed from any page. The information can also be changed in one place, and the changes will automatically be reflected on all pages. The Application object's collections, methods, and events are described below: Collections Collection Description Contents Contains all the items appended to the application through a script command StaticObjects Contains all the objects appended to the application with the HTML tag Methods Method Description Contents.Remove Deletes an item from the Contents collection Contents.RemoveAll() Deletes all items from the Contents collection Lock Prevents other users from modifying the variables in the Application object Unlock Enables other users to modify the variables in the Application object (after it has been locked using the Lock method) Events Event Description Application_OnEnd Occurs when all user sessions are over, and the application ends Application_OnStart Occurs before the first new session is created (when the Application object is first referenced) Collections: ASP Contents Collection The Contents collection contains all the items appended to the application/session through a script command. Tip: To remove items from the Contents collection, use the Remove and RemoveAll methods. Syntax Application.Contents(Key) Session.Contents(Key) Parameter Description key Required. The name of the item to retrieve Examples for the Application Object Example 1 Notice that both name and objtest would be appended to the Contents collection: <% Application("name")="W3Schools" Set Application("objtest")=Server.CreateObject("ADODB.Connection") %> Example 2 To loop through the Contents collection: <% for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> or: <% For i=1 to Application.Contents.Count Response.Write(i & "=" & Application.Contents(i) & " ") Next %> Example 3 <% Application("date")="2001/05/05" Application("author")="W3Schools" for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> Output: date=2001/05/05 author=W3Schools Examples for the Session Object Example 1 Notice that both name and objtest would be appended to the Contents collection: <% Session("name")="Hege" Set Session("objtest")=Server.CreateObject("ADODB.Connection") %> Example 2 To loop through the Contents collection: <% for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> or: <% For i=1 to Session.Contents.Count Response.Write(i & "=" & Session.Contents(i) & " ") Next %> Example 3 <% Session("name")="Hege" Session("date")="2001/05/05" for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> Output: name=Hege date=2001/05/05 ASP StaticObjects Collection The StaticObjects collection contains all the objects appended to the application/session with the HTML tag. Syntax Application.StaticObjects(Key) Session.StaticObjects(Key) Parameter Description key Required. The name of the item to retrieve Examples for the Application Object Example 1 To loop through the StaticObjects collection: <% for each x in Application.StaticObjects Response.Write(x & " ") next %> Example 2 In Global.asa: In an ASP file: <% for each x in Application.StaticObjects Response.Write(x & " ") next %> Output: MsgBoard AdRot Examples for the Session Object Example 1 To loop through the StaticObjects collection: <% for each x in Session.StaticObjects Response.Write(x & " ") next %> Example 2 In Global.asa: In an ASP file: <% for each x in Session.StaticObjects Response.Write(x & " ") next %> Output: MsgBoard AdRot Methods: ASP Contents.Remove Method The Contents.Remove method deletes an item from the Contents collection. Syntax Application.Contents.Remove(name|index) Session.Contents.Remove(name|index) Parameter Description name The name of the item to remove index The index of the item to remove Examples for the Application Object Example 1 <% Application("test1")=("First test") Application("test2")=("Second test") Application("test3")=("Third test") Application.Contents.Remove("test2") for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> Output: test1=First test test3=Third test Example 2 <% Application("test1")=("First test") Application("test2")=("Second test") Application("test3")=("Third test") Application.Contents.Remove(2) for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> Output: test1=First test test3=Third test Examples for the Session Object Example 1 <% Session("test1")=("First test") Session("test2")=("Second test") Session("test3")=("Third test") Session.Contents.Remove("test2") for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> Output: test1=First test test3=Third test Example 2 <% Session("test1")=("First test") Session("test2")=("Second test") Session("test3")=("Third test") Session.Contents.Remove(2) for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> Output: test1=First test test3=Third test ASP Contents.RemoveAll Method The Contents.RemoveAll method deletes all items from the Contents collection. Syntax Application.Contents.RemoveAll() Session.Contents.RemoveAll() Example for the Application Object <% Application.Contents.RemoveAll() %> Example for the Session Object <% Session.Contents.RemoveAll() %> ASP Lock and Unlock Methods Lock Method The Lock method prevents other users from modifying the variables in the Application object (used to ensure that only one client at a time can modify the Application variables). Unlock Method The Unlock method enables other users to modify the variables stored in the Application object (after it has been locked using the Lock method). Syntax Application.Lock Application.Unlock Example The example below uses the Lock method to prevent more than one user from accessing the variable visits at a time, and the Unlock method to unlock the locked object so that the next client can increment the variable visits: <% Application.Lock Application("visits")=Application("visits")+1 Application.Unlock %> This page has been visited <%=Application("visits")%> times! Events: ASP Application_OnStart and Application_OnEnd Events ________________________________________ Application_OnStart Event The Application_OnStart event occurs before the first new session is created (when the Application object is first referenced). This event is placed in the Global.asa file. Note: Referencing to a Session, Request, or Response objects in the Application_OnStart event script will cause an error. Application_OnEnd Event The Application_OnEnd event occurs when the application ends (when the web server stops). This event is placed in the Global.asa file. Note: The MapPath method cannot be used in the Application_OnEnd code. Syntax <script language="vbscript" runat="server"> Sub Application_OnStart . . . End Sub Sub Application_OnEnd . . . End Sub </script> ________________________________________ Examples Global.asa: <script language="vbscript" runat="server"> Sub Application_OnEnd() Application("totvisitors")=Application("visitors") End Sub Sub Application_OnStart Application("visitors")=0 End Sub Sub Session_OnStart Application.Lock Application("visitors")=Application("visitors")+1 Application.UnLock End Sub Sub Session_OnEnd Application.Lock Application("visitors")=Application("visitors")-1 Application.UnLock End Sub </script> To display the number of current visitors in an ASP file: There are <%response.write(Application("visitors"))%> online now! 4)ASP Session Object A Session object stores information about, or change settings for a user session. ________________________________________ Session Object When you are working with an application on your computer, you open it, do some changes and then you close it. This is much like a Session. The computer knows who you are. It knows when you open the application and when you close it. However, on the internet there is one problem: the web server does not know who you are and what you do, because the HTTP address doesn't maintain state. ASP solves this problem by creating a unique cookie for each user. The cookie is sent to the user's computer and it contains information that identifies the user. This interface is called the Session object. The Session object stores information about, or change settings for a user session. Variables stored in a Session object hold information about one single user, and are available to all pages in one application. Common information stored in session variables are name, id, and preferences. The server creates a new Session object for each new user, and destroys the Session object when the session expires. The Session object's collections, properties, methods, and events are described below: Collections Collection Description Contents Contains all the items appended to the session through a script command StaticObjects Contains all the objects appended to the session with the HTML tag Properties Property Description CodePage Specifies the character set that will be used when displaying dynamic content LCID Sets or returns an integer that specifies a location or region. Contents like date, time, and currency will be displayed according to that location or region SessionID Returns a unique id for each user. The unique id is generated by the server Timeout Sets or returns the timeout period (in minutes) for the Session object in this application Methods Method Description Abandon Destroys a user session Contents.Remove Deletes an item from the Contents collection Contents.RemoveAll() Deletes all items from the Contents collection Events Event Description Session_OnEnd Occurs when a session ends Session_OnStart Occurs when a session starts Collections: ASP Contents Collection The Contents collection contains all the items appended to the application/session through a script command. Tip: To remove items from the Contents collection, use the Remove and RemoveAll methods. Syntax Application.Contents(Key) Session.Contents(Key) Parameter Description key Required. The name of the item to retrieve Examples for the Application Object Example 1 Notice that both name and objtest would be appended to the Contents collection: <% Application("name")="W3Schools" Set Application("objtest")=Server.CreateObject("ADODB.Connection") %> Example 2 To loop through the Contents collection: <% for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> or: <% For i=1 to Application.Contents.Count Response.Write(i & "=" & Application.Contents(i) & " ") Next %> Example 3 <% Application("date")="2001/05/05" Application("author")="W3Schools" for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> Output: date=2001/05/05 author=W3Schools Examples for the Session Object Example 1 Notice that both name and objtest would be appended to the Contents collection: <% Session("name")="Hege" Set Session("objtest")=Server.CreateObject("ADODB.Connection") %> Example 2 To loop through the Contents collection: <% for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> or: <% For i=1 to Session.Contents.Count Response.Write(i & "=" & Session.Contents(i) & " ") Next %> Example 3 <% Session("name")="Hege" Session("date")="2001/05/05" for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> Output: name=Hege date=2001/05/05 ASP StaticObjects Collection The StaticObjects collection contains all the objects appended to the application/session with the HTML tag. Syntax Application.StaticObjects(Key) Session.StaticObjects(Key) Parameter Description key Required. The name of the item to retrieve Examples for the Application Object Example 1 To loop through the StaticObjects collection: <% for each x in Application.StaticObjects Response.Write(x & " ") next %> Example 2 In Global.asa: In an ASP file: <% for each x in Application.StaticObjects Response.Write(x & " ") next %> Output: MsgBoard AdRot Examples for the Session Object Example 1 To loop through the StaticObjects collection: <% for each x in Session.StaticObjects Response.Write(x & " ") next %> Example 2 In Global.asa: In an ASP file: <% for each x in Session.StaticObjects Response.Write(x & " ") next %> Output: MsgBoard AdRot Properties: ASP CodePage Property The CodePage property specifies the character set that will be used when displaying dynamic content. Example of some code pages: • 1252 - American English and most European languages • 932 - Japanese Kanji Syntax Session.CodePage(=Codepage) Parameter Description codepage Defines a code page (character set) for the system running the script engine Examples <% Response.Write(Session.CodePage) %> Output: 1252 ASP LCID Property The LCID property sets or returns an integer that specifies a location or region. Contents like date, time, and currency will be displayed according to that location or region. Syntax Session.LCID(=LCID) Parameter Description LCID A locale identifier Examples <% response.write(" ") response.write("Default LCID is: " & Session.LCID & " ") response.write("Date format is: " & date() & " ") response.write("Currency format is: " & FormatCurrency(350)) response.write(" ") Session.LCID=1036 response.write(" ") response.write("LCID is now: " & Session.LCID & " ") response.write("Date format is: " & date() & " ") response.write("Currency format is: " & FormatCurrency(350)) response.write(" ") Session.LCID=3079 response.write(" ") response.write("LCID is now: " & Session.LCID & " ") response.write("Date format is: " & date() & " ") response.write("Currency format is: " & FormatCurrency(350)) response.write(" ") Session.LCID=2057 response.write(" ") response.write("LCID is now: " & Session.LCID & " ") response.write("Date format is: " & date() & " ") response.write("Currency format is: " & FormatCurrency(350)) response.write(" ") %> Output: Default LCID is: 2048 Date format is: 12/11/2001 Currency format is: $350.00 LCID is now: 1036 Date format is: 11/12/2001 Currency format is: 350,00 F LCID is now: 3079 Date format is: 11.12.2001 Currency format is: öS 350,00 LCID is now: 2057 Date format is: 11/12/2001 Currency format is: £350.00 ASP SessionID Property The SessionID property returns a unique id for each user. The unique id is generated by the server. Syntax Session.SessionID Examples <% Response.Write(Session.SessionID) %> Output: 772766038 ASP Timeout Property The Timeout property sets or returns the timeout period for the Session object for this application, in minutes. If the user does not refresh or request a page within the timeout period, the session will end. Syntax Session.Timeout[=nMinutes] Parameter Description nMinutes The number of minutes a session can remain idle before the server terminates it. Default is 20 minutes Examples <% response.write(" ") response.write("Default Timeout is: " & Session.Timeout) response.write(" ") Session.Timeout=30 response.write(" ") response.write("Timeout is now: " & Session.Timeout) response.write(" ") %> Output: Default Timeout is: 20 Timeout is now: 30 Methods: ASP Abandon Method The Abandon method destroys a user session. Note: When this method is called, the current Session object is not deleted until all of the script on the current page have been processed. This means that it is possible to access session variables on the same page as the call to Abandon, but not from another Web page. Syntax Session.Abandon Examples File1.asp: <% Session("name")="Hege" Session.Abandon Response.Write(Session("name")) %> Output: Hege File2.asp: <% Response.Write(Session("name")) %> Output: (none) ASP Contents.Remove Method The Contents.Remove method deletes an item from the Contents collection. Syntax Application.Contents.Remove(name|index) Session.Contents.Remove(name|index) Parameter Description name The name of the item to remove index The index of the item to remove Examples for the Application Object Example 1 <% Application("test1")=("First test") Application("test2")=("Second test") Application("test3")=("Third test") Application.Contents.Remove("test2") for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> Output: test1=First test test3=Third test Example 2 <% Application("test1")=("First test") Application("test2")=("Second test") Application("test3")=("Third test") Application.Contents.Remove(2) for each x in Application.Contents Response.Write(x & "=" & Application.Contents(x) & " ") next %> Output: test1=First test test3=Third test Examples for the Session Object Example 1 <% Session("test1")=("First test") Session("test2")=("Second test") Session("test3")=("Third test") Session.Contents.Remove("test2") for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> Output: test1=First test test3=Third test Example 2 <% Session("test1")=("First test") Session("test2")=("Second test") Session("test3")=("Third test") Session.Contents.Remove(2) for each x in Session.Contents Response.Write(x & "=" & Session.Contents(x) & " ") next %> Output: test1=First test test3=Third test ASP Contents.RemoveAll Method The Contents.RemoveAll method deletes all items from the Contents collection. Syntax Application.Contents.RemoveAll() Session.Contents.RemoveAll() Example for the Application Object <% Application.Contents.RemoveAll() %> Example for the Session Object <% Session.Contents.RemoveAll() %> Events: ASP Session_OnStart and Session_OnEnd Events ________________________________________ Session_OnStart Event The Session_OnStart event occurs when the server creates a session. This event is placed in the Global.asa file. Session_OnEnd Event The Session_OnEnd event occurs when the session ends (abandoned or times out). This event is placed in the Global.asa file. Note: The MapPath method cannot be used in the Session_OnEnd code. Syntax <script language="vbscript" runat="server"> Sub Session_OnStart . . . End Sub Sub Session_OnEnd . . . End Sub </script> ________________________________________ Examples Global.asa: <script language="vbscript" runat="server"> Sub Application_OnEnd() Application("totvisitors")=Application("visitors") End Sub Sub Application_OnStart Application("visitors")=0 End Sub Sub Session_OnStart Application.Lock Application("visitors")=Application("visitors")+1 Application.UnLock End Sub Sub Session_OnEnd Application.Lock Application("visitors")=Application("visitors")-1 Application.UnLock End Sub </script> To display the number of current visitors in an ASP file: There are <%response.write(Application("visitors"))%> online now! 5) ASP Server Object The Server object is used to access properties and methods on the server. Server Object The ASP Server object is used to access properties and methods on the server. Its properties and methods are described below: Properties Property Description ScriptTimeout Sets or returns the maximum number of seconds a script can run before it is terminated Methods Method Description CreateObject Creates an instance of an object Execute Executes an ASP file from inside another ASP file GetLastError() Returns an ASPError object that describes the error condition that occurred HTMLEncode Applies HTML encoding to a specified string MapPath Maps a specified path to a physical path Transfer Sends (transfers) all the information created in one ASP file to a second ASP file URLEncode Applies URL encoding rules to a specified string Properties: ASP ScriptTimeout Property The ScriptTimeout property sets or returns the maximum number of seconds a script can run before it is terminated. Syntax Server.ScriptTimeout[=NumSeconds] Parameter Description NumSeconds The maximum number of seconds a script can run before the server terminates it. Default is 90 seconds Examples Example 1 Set the script timeout: <% Server.ScriptTimeout=200 %> Example 2 Retrieve the current value of the ScriptTimeout property: <% response.write(Server.ScriptTimeout) %> Methods: ASP CreateObject Method The CreateObject method creates an instance of an object. Note: Objects created with this method have page scope. They are destroyed when the server are finished processing the current ASP page. To create an object with session or application scope, you can either use the tag in the Global.asa file, or store the object in a session or application variable. Syntax Server.CreateObject(progID) Part Description progID Required. The type of object to create Example 1 This example creates an instance of the server component MSWC.AdRotator: <% Set adrot=Server.CreateObject("MSWC.AdRotator") %> Example 2 An object stored in a session variable is destroyed when the session ends. However, you can also destroy the object by setting the variable to Nothing or to a new value: <% Session("ad")=Nothing %> or <% Session("ad")="a new value" %> Example 3 You cannot create an instance of an object with the same name as a built-in object: <% Set Application=Server.CreateObject("Application") %> ASP Execute Method The Execute method executes an ASP file from inside another ASP file. After executing the called .asp file, the control is returned to the original .asp file. Syntax Server.Execute(path) Parameter Description path Required. The location of the ASP file to execute Example File1.asp: <% response.write("I am in File 1! ") Server.Execute("file2.asp") response.write("I am back in File 1!") %> File2.asp: <% response.write("I am in File 2! ") %> Output: I am in File 1! I am in File 2! I am back in File 1! Also look at the Server.Transfer method to see the difference between the Server.Execute and Server.Transfer methods. ASP GetLastError() Method (ASP 3.0) The GetLastError method returns an ASPError object that describes the error condition that occurred. By default, a Web site uses the file \iishelp\common\500-100.asp for processing ASP errors. You can either use this file, or create your own. If you want to change the ASP file for processing the 500;100 custom errors you can use the IIS snap-in. Note: A 500;100 custom error will be generated if IIS encounters an error while processing either an ASP file or the application's Global.asa file. Note: This method is available only before the ASP file has sent any content to the browser. Syntax Server.GetLastError() Examples Example 1 In the example an error will occur when IIS tries to include the file, because the include statement is missing the file parameter: <% response.write("sometext") %> Example 2 In this example an error will occur when compiling the script, because the "next" keyword is missing: <% dim i for i=1 to 10 ........ nxt %> Example 3 In this example an error will occur because the script attempts to divide by 0: <% dim i,tot,j i=0 tot=0 j=0 for i=1 to 10 tot=tot+1 next tot=tot/j %> ASP HTMLEncode Method The HTMLEncode method applies HTML encoding to a specified string. Syntax Server.HTMLEncode(string) Parameter Description string Required. The string to encode Example The following script: <% response.write(Server.HTMLEncode("The image tag: ")) %> Output: The image tag: <img> Web browser output: The image tag: ASP MapPath Method The MapPath method maps a specified path to a physical path. Note: This method cannot be used in Session.OnEnd and Application.OnEnd. Syntax Server.MapPath(path) Parameter Description path Required. A relative or virtual path to map to a physical path. If this parameter starts with / or \, it returns a path as if this parameter is a full virtual path. If this parameter doesn't start with / or \, it returns a path relative to the directory of the .asp file being processed Examples Example 1 For the example below, the file test.asp is located in C:\Inetpub\Wwwroot\Script. The file Test.asp (located in C:\Inetpub\Wwwroot\Script) contains the following code: <% response.write(Server.MapPath("test.asp") & " ") response.write(Server.MapPath("script/test.asp") & " ") response.write(Server.MapPath("/script/test.asp") & " ") response.write(Server.MapPath("\script") & " ") response.write(Server.MapPath("/") & " ") response.write(Server.MapPath("\") & " ") %> Output: c:\inetpub\wwwroot\script\test.asp c:\inetpub\wwwroot\script\script\test.asp c:\inetpub\wwwroot\script\test.asp c:\inetpub\wwwroot\script c:\inetpub\wwwroot c:\inetpub\wwwroot Example 2 How to use a relative path to return the relative physical path to the page that is being viewed in the browser: <% response.write(Server.MapPath("../")) %> or <% response.write(Server.MapPath("..\")) %> ASP Transfer Method The Transfer method sends (transfers) all the state information (all application/session variables and all items in the request collections) created in one ASP file to a second ASP file. When the second ASP page completes its tasks, it will NOT return to the first ASP page (like the Execute method). Note: The Transfer method is an efficient alternate for the Response.Redirect. A redirect forces the Web server to handle an extra request while the Server.Transfer method transfers execution to a different ASP page on the server, and avoids the extra round trip. Syntax Server.Transfer(path) Parameter Description path Required. The location of the ASP file to which control should be transferred Example File1.asp: <% response.write("Line 1 in File 1 ") Server.Transfer("file2.asp") response.write("Line 2 in File 1 ") %> File2.asp: <% response.write("Line 1 in File 2 ") response.write("Line 2 in File 2 ") %> Output: Line 1 in File 1 Line 1 in File 2 Line 2 in File 2 Also look at the Server.Execute method to see the difference between the Server.Transfer and Server.Execute methods. ASP URLEncode Method The URLEncode method applies URL encoding rules to a specified string. Syntax Server.URLEncode(string) Parameter Description string Required. The string to encode Example <% response.write(Server.URLEncode("http://www.w3schools.com")) %> Output: http%3A%2F%2Fwww%2Ew3schools%2Ecom 6) ASP ASPError Object The ASPError object displays information about errors in scripts. The ASPError Object The ASPError object was implemented in ASP 3.0 and is available in IIS5 and later. The ASPError object is used to display detailed information of any error that occurs in scripts in an ASP page. Note: The ASPError object is created when Server.GetLastError is called, so the error information can only be accessed by using the Server.GetLastError method. The ASPError object's properties are described below (all properties are read-only): Properties Property Description ASPCode Returns an error code generated by IIS ASPDescription Returns a detailed description of the error (if the error is ASP-related) Category Returns the source of the error (was the error generated by ASP? By a scripting language? By an object?) Column Returns the column position within the file that generated the error Description Returns a short description of the error File Returns the name of the ASP file that generated the error Line Returns the line number where the error was detected Number Returns the standard COM error code for the error Source Returns the actual source code of the line where the error occurred ASP ASPError Object Properties ASPCode The ASPCode property returns an error code generated by IIS. ASPDescription The ASPDescription property returns a detailed description of the error. Category The Category property returns the source of the error (Was the error generated by IIS? A scripting language? Or a component?). Column The Column property returns the column position within the ASP file that generated the error. Description The Description property returns a short description of the error. File The File property returns the name of the ASP file that generated the error. Line The Line property returns the number of the line within the ASP file that generated the error. Number The Number property returns the standard COM error code for the error. Source The Source property returns the actual source code of the line where the error occurred. Syntax ASPError.ASPCode() ASPError.ASPDescription() ASPError.Category() ASPError.Column() ASPError.Description() ASPError.File() ASPError.Line() ASPError.Number() ASPError.Source() Example <% dim objErr set objErr=Server.GetLastError() response.write("ASPCode=" & objErr.ASPCode) response.write(" ") response.write("ASPDescription=" & objErr.ASPDescription) response.write(" ") response.write("Category=" & objErr.Category) response.write(" ") response.write("Column=" & objErr.Column) response.write(" ") response.write("Description=" & objErr.Description) response.write(" ") response.write("File=" & objErr.File) response.write(" ") response.write("Line=" & objErr.Line) response.write(" ") response.write("Number=" & objErr.Number) response.write(" ") response.write("Source=" & objErr.Source) %> 7) ASP FileSystemObject Object The FileSystemObject object is used to access the file system on a server. The FileSystemObject Object The FileSystemObject object is used to access the file system on a server. This object can manipulate files, folders, and directory paths. It is also possible to retrieve file system information with this object. The following code creates a text file (c:\test.txt) and then writes some text to the file: <% dim fs,fname set fs=Server.CreateObject("Scripting.FileSystemObject") set fname=fs.CreateTextFile("c:\test.txt",true) fname.WriteLine("Hello World!") fname.Close set fname=nothing set fs=nothing %> The FileSystemObject object's properties and methods are described below: Properties Property Description Drives Returns a collection of all Drive objects on the computer Methods Method Description BuildPath Appends a name to an existing path CopyFile Copies one or more files from one location to another CopyFolder Copies one or more folders from one location to another CreateFolder Creates a new folder CreateTextFile Creates a text file and returns a TextStream object that can be used to read from, or write to the file DeleteFile Deletes one or more specified files DeleteFolder Deletes one or more specified folders DriveExists Checks if a specified drive exists FileExists Checks if a specified file exists FolderExists Checks if a specified folder exists GetAbsolutePathName Returns the complete path from the root of the drive for the specified path GetBaseName Returns the base name of a specified file or folder GetDrive Returns a Drive object corresponding to the drive in a specified path GetDriveName Returns the drive name of a specified path GetExtensionName Returns the file extension name for the last component in a specified path GetFile Returns a File object for a specified path GetFileName Returns the file name or folder name for the last component in a specified path GetFolder Returns a Folder object for a specified path GetParentFolderName Returns the name of the parent folder of the last component in a specified path GetSpecialFolder Returns the path to some of Windows' special folders GetTempName Returns a randomly generated temporary file or folder MoveFile Moves one or more files from one location to another MoveFolder Moves one or more folders from one location to another OpenTextFile Opens a file and returns a TextStream object that can be used to access the file Properties: ASP Drives Property The Drives property returns a collection of all Drive objects on the computer. Syntax [drivecoll=]FileSystemObject.Drives Methods: ASP BuildPath Method The BuildPath method appends a name to an existing path. Syntax [newpath=]FileSystemObject.BuildPath(path,name) Parameter Description path Required. The path to append a name to name Required. The name to append to the path Example <% dim fs,path set fs=Server.CreateObject("Scripting.FileSystemObject") path=fs.BuildPath("c:\mydocuments","test") response.write(path) set fs=nothing %> Output: c:\mydocuments\test ASP CopyFile Method The CopyFile method copies one or more files from one location to another. Syntax FileSystemObject.CopyFile source,destination[,overwrite] Parameter Description source Required. The file or files to copy (wildcards can be used} destination Required. Where to copy the file or files (wildcards cannot be used} overwrite Optional. A Boolean value that specifies whether an existing file can be overwritten. True allows existing files to be overwritten and False prevents existing files from being overwritten. Default is True Example <% dim fs set fs=Server.CreateObject("Scripting.FileSystemObject") fs.CopyFile "c:\mydocuments\web\.htm","c:\webpages\" set fs=nothing %> ASP CopyFolder Method The CopyFolder method copies one or more folders from one location to another. Syntax FileSystemObject.CopyFolder source,destination[,overwrite] Parameter Description source Required. The folder or folders to copy (wildcards can be used) destination Required. Where to copy the folder or folders (wildcards cannot be used) overwrite Optional. A Boolean value that indicates whether an existing folder can be overwritten. True allows existing folders to be overwritten and False prevents existing folders from being overwritten. Default is True Examples <% 'copy all the folders in c:\mydocuments\web 'to the folder c:\webpages dim fs set fs=Server.CreateObject("Scripting.FileSystemObject") fs.CopyFolder "c:\mydocuments\web\","c:\webpages\" set fs=nothing %> <% 'copy only the folder test from c:\mydocuments\web 'to the folder c:\webpages dim fs set fs=Server.CreateObject("Scripting.FileSystemObject") fs.CopyFolder "c:\mydocuments\web\test","c:\webpages\" set fs=nothing %> ASP CreateFolder Method The CreateFolder method creates a new folder. Syntax FileSystemObject.CreateFolder(name) Parameter Description name Required. The name of the folder to create Example <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateFolder("c:\asp") set f=nothing set fs=nothing %> ASP CreateTextFile Method The CreateTextFile method creates a new text file in the current folder and returns a TextStream object that can be used to read from, or write to the file. Syntax FileSystemObject.CreateTextFile(filename[,overwrite[,unicode]]) FolderObject.CreateTextFile(filename[,overwrite[,unicode]]) Parameter Description filename Required. The name of the file to create overwrite Optional. A Boolean value that indicates whether an existing file can be overwritten. True indicates that the file can be overwritten and False indicates that the file can not be overwritten. Default is True unicode Optional. A Boolean value that indicates whether the file is created as a Unicode or an ASCII file. True indicates that the file is created as a Unicode file, False indicates that the file is created as an ASCII file. Default is False Example for the FileSystemObject object <% dim fs,tfile set fs=Server.CreateObject("Scripting.FileSystemObject") set tfile=fs.CreateTextFile("c:\somefile.txt") tfile.WriteLine("Hello World!") tfile.close set tfile=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo,tfile Set fs=Server.CreateObject("Scripting.FileSystemObject") Set fo=fs.GetFolder("c:\test") Set tfile=fo.CreateTextFile("test.txt",false) tfile.WriteLine("Hello World!") tfile.Close set tfile=nothing set fo=nothing set fs=nothing %> ASP DeleteFile Method The DeleteFile method deletes one or more specified files. Note: An error will occur if you try to delete a file that doesn't exist. Syntax FileSystemObject.DeleteFile(filename[,force]) Parameter Description filename Required. The name of the file or files to delete (Wildcards are allowed) force Optional. A Boolean value that indicates whether read-only files will be deleted. True indicates that the read-only files will be deleted, False indicates that they will not be deleted. Default is False Example <% dim fs Set fs=Server.CreateObject("Scripting.FileSystemObject") fs.CreateTextFile("c:\test.txt",True) if fs.FileExists("c:\test.txt") then fs.DeleteFile("c:\test.txt") end if set fs=nothing %> ASP DeleteFolder Method The DeleteFolder method deletes one or more specified folders. Note: An error will occur if you try to delete a folder that does not exist. Syntax FileSystemObject.DeleteFolder(foldername[,force]) Parameter Description foldername Required. The name of the folder or folders to delete (Wildcards are allowed) force Optional. A Boolean value that indicates whether read-only folders will be deleted. True indicates that read-only folders will be deleted, False indicates that they will not be deleted. Default is False Example <% dim fs set fs=Server.CreateObject("Scripting.FileSystemObject") if fs.FolderExists("c:\temp") then fs.DeleteFolder("c:\temp") end if set fs=nothing %> ASP DriveExists Method The DriveExists method returns a Boolean value that indicates whether a specified drive exists. It returns True if the drive exists and False if not. Syntax FileSystemObject.DriveExists(drive) Parameter Description drive Required. A drive letter or a complete path specification Example <% dim fs set fs=Server.CreateObject("Scripting.FileSystemObject") if fs.DriveExists("c:")=true then response.write("Drive c: exists!") else response.write("Drive c: does not exist.") end If set fs=nothing %> ASP FileExists Method The FileExists method returns a Boolean value that indicates whether a specified file exists. It returns True if the file exists and False if not. Syntax FileSystemObject.FileExists(filename) Parameter Description filename Required. The name of the file to check if exist Example <% dim fs set fs=Server.CreateObject("Scripting.FileSystemObject") if fs.FileExists("c:\asp\introduction.asp")=true then response.write("File c:\asp\introduction.asp exists!") else response.write("File c:\asp\introduction.asp does not exist!") end if set fs=nothing %> 8.ASP TextStream Object The TextStream Object The TextStream object is used to access the contents of text files. The following code creates a text file (c:\test.txt) and then writes some text to the file (the variable f is an instance of the TextStream object): <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt",true) f.WriteLine("Hello World!") f.Close set f=nothing set fs=nothing %> To create an instance of the TextStream object you can use the CreateTextFile or OpenTextFile methods of the FileSystemObject object, or you can use the OpenAsTextStream method of the File object. The TextStream object's properties and methods are described below: Properties Property Description AtEndOfLine Returns true if the file pointer is positioned immediately before the end-of-line marker in a TextStream file, and false if not AtEndOfStream Returns true if the file pointer is at the end of a TextStream file, and false if not Column Returns the column number of the current character position in an input stream Line Returns the current line number in a TextStream file Methods Method Description Close Closes an open TextStream file Read Reads a specified number of characters from a TextStream file and returns the result ReadAll Reads an entire TextStream file and returns the result ReadLine Reads one line from a TextStream file and returns the result Skip Skips a specified number of characters when reading a TextStream file SkipLine Skips the next line when reading a TextStream file Write Writes a specified text to a TextStream file WriteLine Writes a specified text and a new-line character to a TextStream file WriteBlankLines Writes a specified number of new-line character to a TextStream file Properties ASP AtEndOfLine Property The AtEndOfLine property returns a Boolean value. True indicates that the file pointer is positioned immediately before the end-of-line marker in a TextStream file. Otherwise, it returns False. Note: This property will only work on a TextStream object that are open for reading. Syntax TextStreamObject.AtEndOfLine Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.write("Hello World!") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) do while t.AtEndOfLine<>true x=t.Read(1) loop t.close Response.Write("The last character is: " & x) %> Output: The last character of the first line in the text file is: ! ASP AtEndOfStream Property The AtEndOfStream property returns True if the file pointer is at the end of a TextStream file, and False if not. Note: This property will only work on a TextStream object that are open for reading. Syntax TextStreamObject.AtEndOfStream Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.write("Hello World!") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) do while t.AtEndOfStream<>true x=t.Read(1) loop t.close Response.Write("The last character is: " & x) %> Output: The last character in the text file is: ! ASP Column Property The Column property returns the column number of the current character position in an input stream. Note: This property is 1 after a new line character is written (even before any other character is written). Syntax TextStreamObject.Column Example <% dim fs,f,t,x,y set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.write("Hello World!") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) do while t.AtEndOfStream<>true x=t.Read(1) y=t.Column-1 loop t.close Response.Write("The last character in the text file is: " & x) Response.Write(" at character position: " & y) %> Output: The last character in the text file is: ! at character position: 12 ASP Line Property The Line property returns the current line number in a TextStream file (starting at 1). Syntax TextStreamObject.Line Example <% dim fs,f,t set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt",true) f.WriteLine("Hello World!") f.WriteLine("How are you today?") f.WriteLine("Goodbye!") f.close Set t=fs.OpenTextFile("c:\test.txt",1) do while t.AtEndOfStream=false Response.Write("Line " & t.Line & ": ") Response.Write(t.ReadLine) Response.Write(" ") loop t.Close %> Output: Line 1: Hello World! Line 2: How are you today? Line 3: Goodbye! Methods: ASP Close Method The Close method closes an open TextStream file. Syntax TextStreamObject.Close Example <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt",true) f.WriteLine("Hello World!") f.Close set f=nothing set fs=nothing %> ASP Read Method The Read method reads a specified number of characters from a TextStream file and returns the result as a string. Syntax TextStreamObject.Read(numchar) Parameter Description numchar Required. The number of characters to read from the file Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.write("Hello World!") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) x=t.Read(5) t.close Response.Write("The first five characters are: " & x) %> Output: The first five characters are: Hello ASP ReadAll Method The ReadAll method reads an entire TextStream file and returns the result as a string. Note: This method is not suitable for large files (it wastes memory resources). Syntax TextStreamObject.ReadAll Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.write("Hello World!") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) x=t.ReadAll t.close Response.Write("The text in the file is: " & x) %> Output: The text in the file is: Hello World! ASP ReadLine Method The ReadLine method reads one line from a TextStream file and returns the result as a string. Syntax TextStreamObject.ReadLine Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.writeline("Line 1") f.writeline("Line 2") f.writeline("Line 3") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) x=t.ReadLine t.close Response.Write("The first line in the file ") Response.Write("contains this text: " & x) %> Output: The first line in the file contains this text: Line 1 ASP Skip Method The Skip method skips a specified number of characters when reading a TextStream file. Syntax TextStreamObject.Skip(numchar) Parameter Description numchar Required. The number of characters to skip Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.write("Hello World!") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) t.Skip(7) x=t.ReadAll t.close Response.Write("The output after skipping some characters: " & x) %> Output: The output after skipping some characters: orld! ASP SkipLine Method The SkipLine method skips a line when reading a TextStream file. Syntax TextStreamObject.SkipLine Example <% dim fs,f,t,x set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt") f.writeline("Line 1") f.writeline("Line 2") f.writeline("Line 3") f.close set t=fs.OpenTextFile("c:\test.txt",1,false) t.SkipLine x=t.ReadAll t.close Response.Write("Output after skipping the first ") Response.Write(" line in the file: " & x) %> Output: Output after skipping the first line in the file: Line 2 Line 3 ASP Write Method The Write method writes a specified text to a TextStream file. Note: This method write text to the TextStream file with no spaces or line breaks between each string. Syntax TextStreamObject.Write(text) Parameter Description text Required. The text to write to the file Example <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt",true) f.write("Hello World!") f.write("How are you today?") f.close set f=nothing set fs=nothing %> The file test.txt will look like this after executing the code above: Hello World!How are you today? ASP WriteLine Method The WriteLine method writes a specified text and a new-line character to a TextStream file. Syntax TextStreamObject.WriteLine(text) Parameter Description text Optional. The text to write to the file. If you do not specify this parameter, a new-line character will be written to the file Example <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt",true) f.WriteLine("Hello World!") f.WriteLine("How are you today?") f.WriteLine("Goodbye!") f.close set f=nothing set fs=nothing %> The file test.txt will look like this after executing the code above: Hello World! How are you today? Goodbye! ASP WriteBlankLines Method The WriteBlankLines method writes a specified number of new-line characters to a TextStream file. Syntax TextStreamObject.WriteBlankLines(numlines) Parameter Description numlines Required. The number of new-line characters to write to the file Example <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.CreateTextFile("c:\test.txt",true) f.WriteLine("Hello World!") f.WriteBlankLines(2) f.WriteLine("How are you today?") f.close set f=nothing set fs=nothing %> The file test.txt will look like this after executing the code above: Hello World! How are you today? 9.ASP Drive Object The Drive object is used to get information about a local disk drive or a network share. The Drive Object The Drive object is used to return information about a local disk drive or a network share. The Drive object can return information about a drive's type of file system, free space, serial number, volume name, and more. Note: You cannot return information about a drive's content with the Drive object. For this purpose you will have to use the Folder object. To work with the properties of the Drive object, you will have to create an instance of the Drive object through the FileSystemObject object. First; create a FileSystemObject object and then instantiate the Drive object through the GetDrive method or the Drives property of the FileSystemObject object. The Drive object's properties are described below: Properties Property Description AvailableSpace Returns the amount of available space to a user on a specified drive or network share DriveLetter Returns one uppercase letter that identifies the local drive or a network share DriveType Returns the type of a specified drive FileSystem Returns the file system in use for a specified drive FreeSpace Returns the amount of free space to a user on a specified drive or network share IsReady Returns true if the specified drive is ready and false if not Path Returns an uppercase letter followed by a colon that indicates the path name for a specified drive RootFolder Returns a Folder object that represents the root folder of a specified drive SerialNumber Returns the serial number of a specified drive ShareName Returns the network share name for a specified drive TotalSize Returns the total size of a specified drive or network share VolumeName Sets or returns the volume name of a specified drive ASP AvailableSpace Property The AvailableSpace property returns the amount of available space to a user on the specified drive or network share. Note: The value returned is often equal to the value returned by the FreeSpace property. Syntax DriveObject.AvailableSpace Example <% Dim fs,d Set fs=Server.CreateObject("Scripting.FileSystemObject") Set d=fs.GetDrive("c:") Response.Write("Drive " & d) Response.Write(" Available space in bytes: " & d.AvailableSpace) set d=nothing set fs=nothing %> Output: Drive c: Available space in bytes: 884465152 ASP DriveLetter Property The DriveLetter property returns one uppercase letter that identifies the local drive or a network share. Syntax DriveObject.DriveLetter Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The drive letter is: " & d.driveletter) set d=nothing set fs=nothing %> Output: The drive letter is: C ASP DriveType Property The DriveType property returns a value that indicates the type of a specified drive. This property can return one of the following values: • 0 = unknown • 1 = removable • 2 = fixed • 3 = network • 4 = CD-ROM • 5 = RAM disk Syntax DriveObject.DriveType Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("a:") Response.Write("The drive type is: " & d.DriveType) set d=nothing set fs=nothing %> Output: The drive type is: 1 ASP FileSystem Property The FileSystem property returns the file system in use for a specified drive. This property will return one of the following: • FAT - for removable drives • CDFS - for CD-ROM drives • FAT, FAT32 or NTFS - for hard disks on Windows 2000 or Windows NT • FAT or FAT32 - for hard disks on Windows 9x Syntax DriveObject.FileSystem Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The file system in use is: " & d.FileSystem) set d=nothing set fs=nothing %> Output: The file system in use is: NTFS ASP FreeSpace Property The FreeSpace property returns the amount of free space to a user on the specified drive or network share. Note: The value returned is often equal to the value returned by the AvailableSpace property. Syntax DriveObject.FreeSpace Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("Drive " & d) Response.Write(" Free space in bytes: " & d.FreeSpace) set d=nothing set fs=nothing %> Output: Drive c: Free space in bytes: 884465664 ASP IsReady Property The IsReady property returns true if a specified drive is ready and false if not. Syntax DriveObject.IsReady Example <% dim fs,d,n set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("a:") n = "The " & d.DriveLetter if d.IsReady=true then n=n & " drive is ready!" else n=n & " drive is not ready!" end if Response.Write(n) set d=nothing set fs=nothing %> Output: The A drive is not ready! ASP Path Property The Path property is used to return the path for a specified drive, file, or folder. Syntax DriveObject.Path FileObject.Path FolderObject.Path Example for the Drive object <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The path is " & d.Path) set d=nothing set fs=nothing %> Output: The path is C: Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp\test\test.asp") Response.Write("The path is: " & f.Path) set f=nothing set fs=nothing %> Output: The path is: C:\asp\test\test.asp Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp\test") Response.Write("The path is: " & fo.Path) set fo=nothing set fs=nothing %> Output: The path is: C:\asp\test ASP RootFolder Property The RootFolder property returns a Folder object that represents the root folder of a specified drive. Syntax DriveObject.RootFolder Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The root folder is: " & d.RootFolder) set d=nothing set fs=nothing %> Output: The root folder is: C:\ ASP SerialNumber Property The SerialNumber property returns the serial number of a specified drive. Syntax DriveObject.SerialNumber Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The serial number is: " & d.SerialNumber) set d=nothing set fs=nothing %> Output: The serial number is: 474680516 ASP ShareName Property The ShareName property returns the network share name for a specified drive. Syntax DriveObject.ShareName Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The sharename is: " & d.ShareName) set d=nothing set fs=nothing %> ASP TotalSize Property The TotalSize property returns the total size, in bytes, of a specified drive or network share. Syntax DriveObject.TotalSize Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The total size in bytes is: " & d.TotalSize) set d=nothing set fs=nothing %> Output: The total size in bytes is: 4293563392 ASP VolumeName Property The VolumeName property sets or returns the volume name of a specified drive. Syntax DriveObject.VolumeName[=newname] Parameter Description newname Optional. Sets the new name of the specified drive Example <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The volume name is: " & d.VolumeName) set d=nothing set fs=nothing %> 10.ASP File Object The File object is used to return information about a specified file. The File Object The File object is used to return information about a specified file. To work with the properties and methods of the File object, you will have to create an instance of the File object through the FileSystemObject object. First; create a FileSystemObject object and then instantiate the File object through the GetFile method of the FileSystemObject object or through the Files property of the Folder object. The following code uses the GetFile method of the FileSystemObject object to instantiate the File object and the DateCreated property to return the date when the specified file was created: Example <% Dim fs,f Set fs=Server.CreateObject("Scripting.FileSystemObject") Set f=fs.GetFile("c:\test.txt") Response.Write("File created: " & f.DateCreated) set f=nothing set fs=nothing %> The File object's properties and methods are described below: Properties Property Description Attributes Sets or returns the attributes of a specified file DateCreated Returns the date and time when a specified file was created DateLastAccessed Returns the date and time when a specified file was last accessed DateLastModified Returns the date and time when a specified file was last modified Drive Returns the drive letter of the drive where a specified file or folder resides Name Sets or returns the name of a specified file ParentFolder Returns the folder object for the parent of the specified file Path Returns the path for a specified file ShortName Returns the short name of a specified file (the 8.3 naming convention) ShortPath Returns the short path of a specified file (the 8.3 naming convention) Size Returns the size, in bytes, of a specified file Type Returns the type of a specified file Methods Method Description Copy Copies a specified file from one location to another Delete Deletes a specified file Move Moves a specified file from one location to another OpenAsTextStream Opens a specified file and returns a TextStream object to access the file Properties: ASP Attributes Property The Attributes property is used to set or return the attribute or attributes of a specified file or folder. Syntax FileObject.Attributes[=newattributes] FolderObject.Attributes[=newattributes] Parameter Description newattributes Optional. Specifies the attribute value for the file or folder. Can take any of the following values or a combination of the following values: 0 = Normal file 1 = Read-only file 2 = Hidden file 4 = System file 16 = Folder or directory 32 = File has changed since last backup 1024 = Link or shortcut 2048 = Compressed file Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("The attributes of the file are: ") Response.Write(f.Attributes) set f=nothing set fs=nothing %> Output: The attributes of the file are: 32 Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The attributes of the folder are: ") Response.Write(fo.Attributes) set fo=nothing set fs=nothing %> Output: The attributes of the folder are: 16 ASP DateCreated Property The DateCreated property is used to return the date and time when a specified file or folder was created. Syntax FileObject.DateCreated FolderObject.DateCreated Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File created: ") Response.Write(f.DateCreated) set f=nothing set fs=nothing %> Output: File created: 9/19/2001 10:01:19 AM Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder created: ") Response.Write(fo.DateCreated) set fo=nothing set fs=nothing %> Output: Folder created: 9/19/2001 10:01:19 AM ASP DateLastAccessed Property The DateLastAccessed property is used to return the date and time when a specified file or folder was last accessed. Syntax FileObject.DateLastAccessed FolderObject.DateLastAccessed Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File last accessed on: ") Response.Write(f.DateLastAccessed) set f=nothing set fs=nothing %> Output: File last accessed on: 10/29/2001 10:21:23 AM Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder last accessed on: ") Response.Write(fo.DateLastAccessed) set fo=nothing set fs=nothing %> Output: Folder last accessed on: 9/19/2001 10:01:19 AM ASP DateLastModified Property The DateLastModified property is used to return the date and time when a specified file or folder was last modified. Syntax FileObject.DateLastModified FolderObject.DateLastModified Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File last modified on: ") Response.Write(f.DateLastModified) set f=nothing set fs=nothing %> Output: File last modified on: 1/10/2001 10:01:19 AM Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder last modified on: ") Response.Write(fo.DateLastModified) set fo=nothing set fs=nothing %> Output: Folder last modified on: 9/19/2001 10:01:19 AM ASP Drive Property The Drive property is used to return the drive letter of the drive where the specified file or folder resides. Syntax FileObject.Drive FolderObject.Drive Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File resides on drive: ") Response.Write(f.Drive) set f=nothing set fs=nothing %> Output: File resides on drive: c: Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder resides on drive: ") Response.Write(fo.Drive) set fo=nothing set fs=nothing %> Output: Folder resides on drive: c: ASP Name Property The Name property is used to set or return the name of a specified file or folder. Syntax FileObject.Name[=newname] FolderObject.Name[=newname] Parameter Description newname Optional. Specifies the name of the file or folder Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("The file's name: ") Response.Write(f.Name) set f=nothing set fs=nothing %> Output: The file's name: test.txt Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The folder's name: ") Response.Write(fo.Name) set fo=nothing set fs=nothing %> Output: The folder's name: test ASP ParentFolder Property The ParentFolder property is used to return the folder object for the parent of the specified file or folder. Syntax FileObject.ParentFolder FolderObject.ParentFolder Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp\test\test.asp") Response.Write("The file test.asp is in the folder: ") Response.Write(f.ParentFolder) set f=nothing set fs=nothing %> Output: The file test.asp is in the folder: C:\asp\test Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp\test") Response.Write("The folder test is in the folder: ") Response.Write(fo.ParentFolder) set fo=nothing set fs=nothing %> Output: The folder test is in the folder: C:\asp ASP Path Property The Path property is used to return the path for a specified drive, file, or folder. Syntax DriveObject.Path FileObject.Path FolderObject.Path Example for the Drive object <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The path is " & d.Path) set d=nothing set fs=nothing %> Output: The path is C: Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp\test\test.asp") Response.Write("The path is: " & f.Path) set f=nothing set fs=nothing %> Output: The path is: C:\asp\test\test.asp Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp\test") Response.Write("The path is: " & fo.Path) set fo=nothing set fs=nothing %> Output: The path is: C:\asp\test ASP ShortName Property The ShortName property is used to return the short name of a specified file or folder (the 8.3 naming convention). Syntax FileObject.ShortName FolderObject.ShortName Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\hitcounterfile.txt")) Response.Write("Name: " & f.Name) Response.Write(" ShortName: " & f.ShortName) set f=nothing set fs=nothing %> Output: Name: hitcounterfile.txt ShortName: HITCOU~1.TXT Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp_test_web") Response.Write("Name: " & fo.Name) Response.Write(" ShortName: " & fo.ShortName) set fo=nothing set fs=nothing %> Output: Name: asp_test_web ShortName: ASP_TE~1 ASP ShortPath Property ________________________________________ The ShortPath property is used to return the short path of the specified file or folder (the 8.3 naming convention). Syntax FileObject.ShortPath FolderObject.ShortPath Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp_test_web\hitcounterfile.txt") Response.Write("Path: " & f.Path) Response.Write(" ShortPath: " & f.ShortPath) set f=nothing set fs=nothing %> Output: Path: C:\asp_test_web\hitcounterfile.txt ShortPath: C:\ASP_TE~1\HITCOU~1.TXT Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp_test_web") Response.Write("Path: " & fo.Path) Response.Write(" ShortPath: " & fo.ShortPath) set fo=nothing set fs=nothing %> Output: Path: C:\asp_test_web ShortPath: C:\ASP_TE~1 ASP Size Property The Size property is used to return the size, in bytes, of the specified file or folder. Syntax FileObject.Size FolderObject.Size Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.asp") Response.Write("The size of test.asp is: ") Response.Write(f.Size & " bytes.") set f=nothing set fs=nothing %> Output: The size of test.asp is: 10556 bytes. Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The size of the folder test is: ") Response.Write(fo.Size & " bytes.") set fo=nothing set fs=nothing %> Output: The size of the folder test is: 123456 bytes. ASP Type Property The Type property is used to return the type of the specified file or folder. Syntax FileObject.Type FolderObject.Type Examples for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:test.txt") Response.Write("The file test.txt is of type: ") Response.Write(f.Type) set f=nothing set fs=nothing %> Output: The file test.txt is of type: Text Document <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:test.asp") Response.Write("The file test.asp is of type: ") Response.Write(f.Type) set f=nothing set fs=nothing %> Output: The file test.asp is of type: Active Server Document Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The folder test is of type: ") Response.Write(fo.Type) set fo=nothing set fs=nothing %> Output: The folder test is of type: File Folder Methods; ASP Copy Method The Copy method copies the specified file or folder from one location to another. Syntax FileObject.Copy(destination[,overwrite]) FolderObject.Copy(destination[,overwrite]) Parameter Description destination Required. Where to copy the file or folder. Wildcard characters are not allowed overwrite Optional. A Boolean value indicating whether an existing file or folder can be overwritten. True indicates that the file/folder can be overwritten, false indicates that the file/folder cannot be overwritten. Default is true. Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") f.Copy("c:\new_test.txt",false) set f=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") fo.Copy("c:\new_test",false) set fo=nothing set fs=nothing %> ASP Delete Method The Delete method deletes a specified file or folder. Syntax FileObject.Delete[(force)] FolderObject.Delete[(force)] Parameter Description force Optional. A Boolean value that indicates whether a read-only file or folder are to be deleted. True indicates that a read-only file/folder will be deleted and false indicates that it will not be deleted. Default is false. Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") f.Delete set f=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") fo.Delete set fo=nothing set fs=nothing %> ASP Move Method The Move method moves the specified file or folder from one location to another. Syntax FileObject.Move(destination) FolderObject.Move(destination) Parameter Description destination Required. Where to move the file or folder. Wildcard characters are not allowed Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") Set f=fs.GetFile("c:\test.txt") f.Move("c:\test\test.txt") set f=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") fo.Move("c:\asp\test") set fo=nothing set fs=nothing %> ASP OpenAsTextStream Method The OpenAsTextStream method opens the specified file and returns a TextStream object to access the file. Syntax FileObject.OpenAsTextStream(mode,format) Parameter Description mode Optional. How to open the file. • 1 = ForReading - Open a file for reading. You cannot write to this file • 2 = ForWriting - Open a file for writing • 8 = ForAppending - Open a file and write to the end of the file format Optional. The format of the file. • 0 = TristateFalse - Default. Open the file as ASCII • -1 = TristateTrue - Open the file as Unicode • -2 = TristateUseDefault - Open the file using the system default Example <% dim fs,f,ts set fs=Server.CreateObject("Scripting.FileSystemObject") Set f=fs.GetFile("c:\test.txt") Set ts=f.OpenAsTextStream(ForWriting) ts.Write("Hello World!") ts.Close Set ts=f.OpenAsTextStream(ForReading) Response.Write(ts.ReadAll) ts.Close set ts=nothing set f=nothing set fs=nothing %> Output: Hello World! 11.ASP Folder Object The Folder Object is used to return information about a specified folder. The Folder Object The Folder object is used to return information about a specified folder. To work with the properties and methods of the Folder object, you will have to create an instance of the Folder object through the FileSystemObject object. First; create a FileSystemObject object and then instantiate the Folder object through the GetFolder method of the FileSystemObject object. The following code uses the GetFolder method of the FileSystemObject object to instantiate the Folder object and the DateCreated property to return the date when the specified folder was created: <% Dim fs,fo Set fs=Server.CreateObject("Scripting.FileSystemObject") Set fo=fs.GetFolder("c:\test") Response.Write("Folder created: " & fo.DateCreated) set fo=nothing set fs=nothing %> Output: Folder created: 10/22/2008 10:01:19 AM The Folder object's collections, properties, and methods are described below: Collections Collection Description Files Returns a collection of all the files in a specified folder SubFolders Returns a collection of all subfolders in a specified folder Properties Property Description Attributes Sets or returns the attributes of a specified folder DateCreated Returns the date and time when a specified folder was created DateLastAccessed Returns the date and time when a specified folder was last accessed DateLastModified Returns the date and time when a specified folder was last modified Drive Returns the drive letter of the drive where the specified folder resides IsRootFolder Returns true if a folder is the root folder and false if not Name Sets or returns the name of a specified folder ParentFolder Returns the parent folder of a specified folder Path Returns the path for a specified folder ShortName Returns the short name of a specified folder (the 8.3 naming convention) ShortPath Returns the short path of a specified folder (the 8.3 naming convention) Size Returns the size of a specified folder Type Returns the type of a specified folder Methods Method Description Copy Copies a specified folder from one location to another Delete Deletes a specified folder Move Moves a specified folder from one location to another CreateTextFile Creates a new text file in the specified folder and returns a TextStream object Collections: ASP Files Collection The Files collection returns a collection of all the files in a specified folder. Syntax FolderObject.Files Example <% dim fs,fo,x set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test\") for each x in fo.files 'Print the name of all files in the test folder Response.write(x.Name & " ") next set fo=nothing set fs=nothing %> Output: test_adv.txt guestbook.txt links.txt links2.txt textads.txt textfile.txt ASP SubFolders Collection The SubFolders collection returns a collection of all subfolders in a specified folder. Syntax FolderObject.SubFolders Example <% dim fs,fo,x set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test\") for each x in fo.SubFolders 'Print the name of all subfolders in the test folder Response.write(x.Name & " ") next set fo=nothing set fs=nothing %> Output: html css asp vbscript Properties: ASP Attributes Property The Attributes property is used to set or return the attribute or attributes of a specified file or folder. Syntax FileObject.Attributes[=newattributes] FolderObject.Attributes[=newattributes] Parameter Description newattributes Optional. Specifies the attribute value for the file or folder. Can take any of the following values or a combination of the following values: 0 = Normal file 1 = Read-only file 2 = Hidden file 4 = System file 16 = Folder or directory 32 = File has changed since last backup 1024 = Link or shortcut 2048 = Compressed file Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("The attributes of the file are: ") Response.Write(f.Attributes) set f=nothing set fs=nothing %> Output: The attributes of the file are: 32 Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The attributes of the folder are: ") Response.Write(fo.Attributes) set fo=nothing set fs=nothing %> Output: The attributes of the folder are: 16 ASP DateCreated Property The DateCreated property is used to return the date and time when a specified file or folder was created. Syntax FileObject.DateCreated FolderObject.DateCreated Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File created: ") Response.Write(f.DateCreated) set f=nothing set fs=nothing %> Output: File created: 9/19/2001 10:01:19 AM Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder created: ") Response.Write(fo.DateCreated) set fo=nothing set fs=nothing %> Output: Folder created: 9/19/2001 10:01:19 AM ASP DateLastAccessed Property The DateLastAccessed property is used to return the date and time when a specified file or folder was last accessed. Syntax FileObject.DateLastAccessed FolderObject.DateLastAccessed Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File last accessed on: ") Response.Write(f.DateLastAccessed) set f=nothing set fs=nothing %> Output: File last accessed on: 10/29/2001 10:21:23 AM Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder last accessed on: ") Response.Write(fo.DateLastAccessed) set fo=nothing set fs=nothing %> Output: Folder last accessed on: 9/19/2001 10:01:19 AM ASP DateLastModified Property The DateLastModified property is used to return the date and time when a specified file or folder was last modified. Syntax FileObject.DateLastModified FolderObject.DateLastModified Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File last modified on: ") Response.Write(f.DateLastModified) set f=nothing set fs=nothing %> Output: File last modified on: 1/10/2001 10:01:19 AM Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder last modified on: ") Response.Write(fo.DateLastModified) set fo=nothing set fs=nothing %> Output: Folder last modified on: 9/19/2001 10:01:19 AM ASP Drive Property The Drive property is used to return the drive letter of the drive where the specified file or folder resides. Syntax FileObject.Drive FolderObject.Drive Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("File resides on drive: ") Response.Write(f.Drive) set f=nothing set fs=nothing %> Output: File resides on drive: c: Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("Folder resides on drive: ") Response.Write(fo.Drive) set fo=nothing set fs=nothing %> Output: Folder resides on drive: c: ASP IsRootFolder Property The IsRootFolder property returns true if the specified folder is the root folder and false if not. Syntax FolderObject.IsRootFolder Example <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp\test") if fo.IsRootFolder=true then Response.Write("The folder is the root folder!") else Response.Write("The folder is not the root folder!") end if set fo=nothing set fs=nothing %> Output: The folder is not the root folder! ASP Name Property The Name property is used to set or return the name of a specified file or folder. Syntax FileObject.Name[=newname] FolderObject.Name[=newname] Parameter Description newname Optional. Specifies the name of the file or folder Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") Response.Write("The file's name: ") Response.Write(f.Name) set f=nothing set fs=nothing %> Output: The file's name: test.txt Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The folder's name: ") Response.Write(fo.Name) set fo=nothing set fs=nothing %> Output: The folder's name: test ASP ParentFolder Property The ParentFolder property is used to return the folder object for the parent of the specified file or folder. Syntax FileObject.ParentFolder FolderObject.ParentFolder Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp\test\test.asp") Response.Write("The file test.asp is in the folder: ") Response.Write(f.ParentFolder) set f=nothing set fs=nothing %> Output: The file test.asp is in the folder: C:\asp\test Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp\test") Response.Write("The folder test is in the folder: ") Response.Write(fo.ParentFolder) set fo=nothing set fs=nothing %> Output: The folder test is in the folder: C:\asp ASP Path Property The Path property is used to return the path for a specified drive, file, or folder. Syntax DriveObject.Path FileObject.Path FolderObject.Path Example for the Drive object <% dim fs,d set fs=Server.CreateObject("Scripting.FileSystemObject") set d=fs.GetDrive("c:") Response.Write("The path is " & d.Path) set d=nothing set fs=nothing %> Output: The path is C: Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp\test\test.asp") Response.Write("The path is: " & f.Path) set f=nothing set fs=nothing %> Output: The path is: C:\asp\test\test.asp Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp\test") Response.Write("The path is: " & fo.Path) set fo=nothing set fs=nothing %> Output: The path is: C:\asp\test ASP ShortName Property The ShortName property is used to return the short name of a specified file or folder (the 8.3 naming convention). Syntax FileObject.ShortName FolderObject.ShortName Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\hitcounterfile.txt")) Response.Write("Name: " & f.Name) Response.Write(" ShortName: " & f.ShortName) set f=nothing set fs=nothing %> Output: Name: hitcounterfile.txt ShortName: HITCOU~1.TXT Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp_test_web") Response.Write("Name: " & fo.Name) Response.Write(" ShortName: " & fo.ShortName) set fo=nothing set fs=nothing %> Output: Name: asp_test_web ShortName: ASP_TE~1 ASP ShortPath Property ________________________________________ The ShortPath property is used to return the short path of the specified file or folder (the 8.3 naming convention). Syntax FileObject.ShortPath FolderObject.ShortPath Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\asp_test_web\hitcounterfile.txt") Response.Write("Path: " & f.Path) Response.Write(" ShortPath: " & f.ShortPath) set f=nothing set fs=nothing %> Output: Path: C:\asp_test_web\hitcounterfile.txt ShortPath: C:\ASP_TE~1\HITCOU~1.TXT Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\asp_test_web") Response.Write("Path: " & fo.Path) Response.Write(" ShortPath: " & fo.ShortPath) set fo=nothing set fs=nothing %> Output: Path: C:\asp_test_web ShortPath: C:\ASP_TE~1 ASP Size Property The Size property is used to return the size, in bytes, of the specified file or folder. Syntax FileObject.Size FolderObject.Size Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.asp") Response.Write("The size of test.asp is: ") Response.Write(f.Size & " bytes.") set f=nothing set fs=nothing %> Output: The size of test.asp is: 10556 bytes. Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The size of the folder test is: ") Response.Write(fo.Size & " bytes.") set fo=nothing set fs=nothing %> Output: The size of the folder test is: 123456 bytes. ASP Type Property The Type property is used to return the type of the specified file or folder. Syntax FileObject.Type FolderObject.Type Examples for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:test.txt") Response.Write("The file test.txt is of type: ") Response.Write(f.Type) set f=nothing set fs=nothing %> Output: The file test.txt is of type: Text Document <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:test.asp") Response.Write("The file test.asp is of type: ") Response.Write(f.Type) set f=nothing set fs=nothing %> Output: The file test.asp is of type: Active Server Document Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") Response.Write("The folder test is of type: ") Response.Write(fo.Type) set fo=nothing set fs=nothing %> Output: The folder test is of type: File Folder Methods: ASP Copy Method The Copy method copies the specified file or folder from one location to another. Syntax FileObject.Copy(destination[,overwrite]) FolderObject.Copy(destination[,overwrite]) Parameter Description destination Required. Where to copy the file or folder. Wildcard characters are not allowed overwrite Optional. A Boolean value indicating whether an existing file or folder can be overwritten. True indicates that the file/folder can be overwritten, false indicates that the file/folder cannot be overwritten. Default is true. Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") f.Copy("c:\new_test.txt",false) set f=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") fo.Copy("c:\new_test",false) set fo=nothing set fs=nothing %> ASP Delete Method The Delete method deletes a specified file or folder. Syntax FileObject.Delete[(force)] FolderObject.Delete[(force)] Parameter Description force Optional. A Boolean value that indicates whether a read-only file or folder are to be deleted. True indicates that a read-only file/folder will be deleted and false indicates that it will not be deleted. Default is false. Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") set f=fs.GetFile("c:\test.txt") f.Delete set f=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") fo.Delete set fo=nothing set fs=nothing %> ASP Move Method The Move method moves the specified file or folder from one location to another. Syntax FileObject.Move(destination) FolderObject.Move(destination) Parameter Description destination Required. Where to move the file or folder. Wildcard characters are not allowed Example for the File object <% dim fs,f set fs=Server.CreateObject("Scripting.FileSystemObject") Set f=fs.GetFile("c:\test.txt") f.Move("c:\test\test.txt") set f=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo set fs=Server.CreateObject("Scripting.FileSystemObject") set fo=fs.GetFolder("c:\test") fo.Move("c:\asp\test") set fo=nothing set fs=nothing %> ASP CreateTextFile Method The CreateTextFile method creates a new text file in the current folder and returns a TextStream object that can be used to read from, or write to the file. Syntax FileSystemObject.CreateTextFile(filename[,overwrite[,unicode]]) FolderObject.CreateTextFile(filename[,overwrite[,unicode]]) Parameter Description filename Required. The name of the file to create overwrite Optional. A Boolean value that indicates whether an existing file can be overwritten. True indicates that the file can be overwritten and False indicates that the file can not be overwritten. Default is True unicode Optional. A Boolean value that indicates whether the file is created as a Unicode or an ASCII file. True indicates that the file is created as a Unicode file, False indicates that the file is created as an ASCII file. Default is False Example for the FileSystemObject object <% dim fs,tfile set fs=Server.CreateObject("Scripting.FileSystemObject") set tfile=fs.CreateTextFile("c:\somefile.txt") tfile.WriteLine("Hello World!") tfile.close set tfile=nothing set fs=nothing %> Example for the Folder object <% dim fs,fo,tfile Set fs=Server.CreateObject("Scripting.FileSystemObject") Set fo=fs.GetFolder("c:\test") Set tfile=fo.CreateTextFile("test.txt",false) tfile.WriteLine("Hello World!") tfile.Close set tfile=nothing set fo=nothing set fs=nothing %> 12.ASP Components ASP AdRotator Componentents The ASP AdRotator component creates an AdRotator object that displays a different image each time a user enters or refreshes a page. A text file includes information about the images. Syntax <% set adrotator=server.createobject("MSWC.AdRotator") adrotator.GetAdvertisement("textfile.txt") %> ASP AdRotator Example Assume that we have the following text file, named "ads.txt": REDIRECT banners.asp * w3s.gif http://www.w3schools.com Free Tutorials from W3Schools 50 xmlspy.gif http://www.altova.com XML Editor from Altova 50 The lines below the asterisk in the text file above specifies the name of the images (ads) to be displayed, the hyperlink addresses, the alternate text (for the images), and the display rates (in percent). The first line in the text file above specifies what to happen when a visitor clicks on one of the images. The redirection page (banners.asp) will receive a querystring with the URL to redirect to. Tip: To specify the height, width, and border of the image, you can insert the following lines under REDIRECT: REDIRECT banners.asp WIDTH 468 HEIGHT 60 BORDER 0 * w3s.gif ... The "banners.asp" file looks like this: Example <% url=Request.QueryString("url") If url<>"" then Response.Redirect(url) %> <% set adrotator=Server.CreateObject("MSWC.AdRotator") response.write(adrotator.GetAdvertisement("textfile.txt")) %> That's all!! ASP AdRotator Properties Property Description Example Border Specifies the size of the borders around the advertisement <% set adrot=Server.CreateObject("MSWC.AdRotator") adrot.Border="2" Response.Write(adrot.GetAdvertisement("ads.txt")) %> Clickable Specifies whether the advertisement is a hyperlink <% set adrot=Server.CreateObject("MSWC.AdRotator") adrot.Clickable=false Response.Write(adrot.GetAdvertisement("ads.txt")) %> TargetFrame Name of the frame to display the advertisement <% set adrot=Server.CreateObject("MSWC.AdRotator") adrot.TargetFrame="target='_blank'" Response.Write(adrot.GetAdvertisement("ads.txt")) %> ASP AdRotator Methods Method Description Example GetAdvertisement Returns HTML that displays the advertisement in the page <% set adrot=Server.CreateObject("MSWC.AdRotator") Response.Write(adrot.GetAdvertisement("ads.txt")) %> ASP Browser Capabilities Component ASP Browser Capabilities Component The ASP Browser Capabilities component creates a BrowserType object that determines the type, capabilities and version number of a visitor's browser. When a browser connects to a server, a User Agent header is also sent to the server. This header contains information about the browser. The BrowserType object compares the information in the header with information in a file on the server called "Browscap.ini". If there is a match between the browser type and version number in the header and the information in the "Browsercap.ini" file, the BrowserType object can be used to list the properties of the matching browser. If there is no match for the browser type and version number in the Browscap.ini file, it will set every property to "UNKNOWN". Syntax <% Set MyBrow=Server.CreateObject("MSWC.BrowserType") %> ASP Browser Capabilities Example The example below creates a BrowserType object in an ASP file, and displays some of the capabilities of your browser: Example <% Set MyBrow=Server.CreateObject("MSWC.BrowserType") %> <table border="0"><tbody> <tr> <th>Client OS</th><th><%=MyBrow.platform%></th> </tr> <tr> <td>Web Browser</td><td><%=MyBrow.browser%></td> </tr> <tr> <td>Browser version</td><td><%=MyBrow.version%></td> </tr> <tr> <td>Frame support?</td><td><%=MyBrow.frames%></td> </tr> <tr> <td>Table support?</td><td><%=MyBrow.tables%></td> </tr> <tr> <td>Sound support?</td><td><%=MyBrow.backgroundsounds%></td> </tr> <tr> <td>Cookies support?</td><td><%=MyBrow.cookies%></td> </tr> <tr> <td>VBScript support?</td><td><%=MyBrow.vbscript%></td> </tr> <tr> <td>JavaScript support?</td><td><%=MyBrow.javascript%></td> </tr> </tbody></table>Output: Client OS WinNT Web Browser IE Browser version 5.0 Frame support? True Table support? True Sound support? True Cookies support? True VBScript support? True JavaScript support? True The Browscap.ini File The "Browsercap.ini" file is used to declare properties and to set default values for browsers. This section is not a tutorial on how to maintain "Browsercap.ini" files, it only shows you the basics; so you get an idea what a "Browsercap.ini" file is all about. The "Browsercap.ini" file can contain the following: [;comments] [HTTPUserAgentHeader] [parent=browserDefinition] [property1=value1] [propertyN=valueN] [Default Browser Capability Settings] [defaultProperty1=defaultValue1] [defaultPropertyN=defaultValueN] Parameter Description comments Optional. Any line that starts with a semicolon are ignored by the BrowserType object HTTPUserAgentHeader Optional. Specifies the HTTP User Agent header to associate with the browser-property value statements specified in propertyN. Wildcard characters are allowed browserDefinition Optional. Specifies the HTTP User Agent header-string of a browser to use as the parent browser. The current browser's definition will inherit all of the property values declared in the parent browser's definition propertyN Optional. Specifies the browser properties. The following table lists some possible properties: • ActiveXControls - Support ActiveX® controls? • Backgroundsounds - Support background sounds? • Cdf - Support Channel Definition Format for Webcasting? • Tables - Support tables? • Cookies - Support cookies? • Frames - Support frames? • Javaapplets - Support Java applets? • Javascript - Supports JScript? • Vbscript - Supports VBScript? • Browser - Specifies the name of the browser • Beta - Is the browser beta software? • Platform - Specifies the platform that the browser runs on • Version - Specifies the version number of the browser valueN Optional. Specifies the value of propertyN. Can be a string, an integer (prefix with #), or a Boolean value defaultPropertyN Optional. Specifies the name of the browser property to which to assign a default value if none of the defined HTTPUserAgentHeader values match the HTTP User Agent header sent by the browser defaultValueN Optional. Specifies the value of defaultPropertyN. Can be a string, an integer (prefix with #), or a Boolean value A "Browsercap.ini" file might look something like this: ;IE 5.0 [IE 5.0] browser=IE Version=5.0 majorver=#5 minorver=#0 frames=TRUE tables=TRUE cookies=TRUE backgroundsounds=TRUE vbscript=TRUE javascript=TRUE javaapplets=TRUE ActiveXControls=TRUE beta=False ;DEFAULT BROWSER [] browser=Default frames=FALSE tables=TRUE cookies=FALSE backgroundsounds=FALSE vbscript=FALSE javascript=FALSE ASP Content Linking ComponentThe ASP Content Linking component is used to create a quick and easy navigation system! The Content Linking component returns a Nextlink object that is used to hold a list of Web pages to be navigated. Syntax <% Set nl=Server.CreateObject("MSWC.NextLink") %> ASP Content Linking Example First we create a text file - "links.txt": asp_intro.asp ASP Intro asp_syntax.asp ASP Syntax asp_variables.asp ASP Variables asp_procedures.asp ASP Procedures The text file above contains the pages to be navigated. The pages must be listed in the same order you want them to be displayed, and it must also contain a description for each file name (use the tab key to separate file name from description). Note: If you want to add a page, or change the order of the pages in the list; you only have to modify the text file! The navigation will automatically be corrected! Then we create an include file, "nlcode.inc". The .inc file creates a NextLink object to navigate between the pages listed in "links.txt". "nlcode.inc": <% dim nl Set nl=Server.CreateObject("MSWC.NextLink") if (nl.GetListIndex("links.txt")>1) then Response.Write("<a href="http://www.blogger.com/%22%20&%20nl.GetPreviousURL(%22links.txt%22))Response.Write(%22">Previous Page</a>") end if Response.Write("<a href="http://www.blogger.com/%22%20&%20nl.GetNextURL(%22links.txt%22))Response.Write(%22">Next Page</a>") %> In each of the .asp pages listed in the text file "links.txt", put one line of code: . This line will include the code in "nlcode.inc" on every page listed in "links.txt" and the navigation will work. ________________________________________ ASP Content Linking Component's Methods Method Description Example GetListCount Returns the number of items listed in the Content Linking List file <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetListCount("links.txt") Response.Write("There are ") Response.Write(c) Response.Write(" items in the list") %> Output: There are 4 items in the list GetListIndex Returns the index number of the current item in the Content Linking List file. The index number of the first item is 1. 0 is returned if the current page is not in the Content Linking List file <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetListIndex("links.txt") Response.Write("Item number ") Response.Write(c) %> Output: Item number 3 GetNextDescription Returns the text description of the next item listed in the Content Linking List file. If the current page is not found in the list file it returns the text description of the last page on the list <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetNextDescription("links.txt") Response.Write("Next ") Response.Write("description is: ") Response.Write(c) %> Next description is: ASP Variables GetNextURL Returns the URL of the next item listed in the Content Linking List file. If the current page is not found in the list file it returns the URL of the last page on the list <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetNextURL("links.txt") Response.Write("Next ") Response.Write("URL is: ") Response.Write(c) %> Next URL is: asp_variables.asp GetNthDescription Returns the description of the Nth page listed in the Content Linking List file <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetNthDescription("links.txt",3) Response.Write("Third ") Response.Write("description is: ") Response.Write(c) %> Third description is: ASP Variables GetNthURL Returns the URL of the Nth page listed in the Content Linking List file <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetNthURL("links.txt",3) Response.Write("Third ") Response.Write("URL is: ") Response.Write(c) %> Third URL is: asp_variables.asp GetPreviousDescription Returns the text description of the previous item listed in the Content Linking List file. If the current page is not found in the list file it returns the text description of the first page on the list <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetPreviousDescription("links.txt") Response.Write("Previous ") Response.Write("description is: ") Response.Write(c) %> Previous description is: ASP Variables GetPreviousURL Returns the URL of the previous item listed in the Content Linking List file. If the current page is not found in the list file it returns the URL of the first page on the list <% dim nl,c Set nl=Server.CreateObject("MSWC.NextLink") c=nl.GetPreviousURL("links.txt") Response.Write("Previous ") Response.Write("URL is: ") Response.Write(c) %> Previous URL is: asp_variables.asp ASP Content Rotator Component (ASP 3.0) The ASP Content Rotator component creates a ContentRotator object that displays a different content string each time a visitor enters or refreshes a page. A text file, called the Content Schedule File, includes the information about the content strings. The content strings can contain HTML tags so you can display any type of content that HTML can represent: text, images, colors, or hyperlinks. Syntax <% Set cr=Server.CreateObject("MSWC.ContentRotator") %> ASP Content Rotator Example The following example displays a different content each time a visitor views the Web page. First, create a text file named "textads.txt" and place it in a subfolder called "text". "textads.txt": %% #3 <h2>This is a great day!!</h2>%% #3 %% #4 <a href="http://www.w3schools.com/">Visit W3Schools.com</a> Notice the #number at the beginning of each content string. This number is an optional parameter that indicates the relative weight of the HTML content string. In the text file above, the Content Rotator will display the first and second content string three-tenth of the time, and the third string four-tenths of the time. Then, create an ASP file, and insert the following code: Example <% set cr=server.createobject("MSWC.ContentRotator") response.write(cr.ChooseContent("text/textads.txt")) %> ASP Content Rotator Component's Methods Method Description Example ChooseContent Gets and displays a content string <% dim cr Set cr=Server.CreateObject("MSWC.ContentRotator") response.write(cr.ChooseContent("text/textads.txt")) %> Output: GetAllContent Retrieves and displays all of the content strings in the text file <% dim cr Set cr=Server.CreateObject("MSWC.ContentRotator") response.write(cr.GetAllContent("text/textads.txt")) %> Output: This is a great day!! Visit W3Schools.com </object></object></object></object></object></a></headername></object></object></div> </article> <article> <h1>c# notes or c -sharp notes</h1> 2010-01-11T01:45:00.000+05:30 C# ( C SHARP) VARIABLE: IT IS A MEMORY LOCATION WHICH IS USED TO STORE OR HOLD THE VALUE. THE VALUE WHICH IS ENTRED IS NOT FIXED IT VARIES. DATATYPE: IT IS USED TO REPRESENT WHAT TYPE OF DATA THAT THE USER IS GOING TO ENTER. THEY ARE Byte - Byte byte An integer from 0 to 255. Int16 -Short short An integer from –32,768 to 32,767. Int32 -Integer int An integer from –2,147,483,648 to 2,147,483,647. Int64 - Long long An integer from about –9.2e18 to 9.2e18. Single -Single float A single-precision floating point number from approximately –3.4e38 to 3.4e38. Double -Double double A double-precision floating point number from approximately –1.8e308 to 1.8e308. Decimal- Decimal decimal A 128-bit fixed-point fractional number that supports up to 28 significant digits. Char -Char char A single 16-bit Unicode character. String -String string A variable-length series of Unicode characters. Boolean -Boolean bool A true or false value. DateTime- Date * If the language does not provide an alias for a given type, you can just use the .NET class name. Represents any date and time from 12:00:00 AM, January 1 of the year 1 in the Gregorian calendar, to 11:59:59 PM, December 31 of the year 9999. Time values can resolve values to 100 nanosecond increments. Internally, this data type is stored as a 64-bit integer. TimeSpan * * Represents a period of time, as in ten seconds or three days. The smallest possible interval is 1 tick (100 nanoseconds). Object Object object The ultimate base class of all .NET types. Can contain any data type or object. OPERATORS: AN OPERATOR IS ONE WHICH OPERATES ON OPERANDS OR VARIABLES. THEY ARE • ARITHMETIC OPERATOR • RELATIONAL OPERATOR • LOGICAL OPERATOR • ASSIGNMENT OPERATOR • INCREMENT AND DECREMENT OPERATOR • TERNARY OR CONDITIONAL OPERATOR • BITWISE • COMMA ARITHMETIC: USED TO PERFORM ARITHMETIC OPERATIONS. + , - , * , / , % RELATIONAL OPERATOR OR COMPARISON OPERATOR: > ,<, >= ,<= ,!= ,== IT PRODUCES BOOLEAN VALUES . THAT IS TRUE OR FALSE. LOGICAL OPERATOR: && (LOGICAL AND) || (LOGICAL OR) ! (LOGICAL NOT) TRUE && TRUE = TRUE TRUE && FALSE =FALSE FALSE && TRUE=FALSE FALSE && FALSE= FALSE NOTE: BOTH THE CONDITIONS MUST BE TRUE TO OBTAIN FINAL VALUE TRUE. || (LOGICAL OR) ANY ONE OF THE CONDITION MUST BE TRUE TO OBTAIN FINAL VALUE TRUE. TRUE || TRUE = TRUE TRUE || FALSE = TRUE FALSE || TRUE = TRUE FALSE || FALSE = FALSE ! (LOGICAL NOT) IT PRODUCES OPPOSITE RESULT. ! ( TRUE ) = FALSE ! ( FALSE ) = TRUE ASSIGNMENT OPERATOR: IT USES THE SYMBOL "=" . USED TO ASSIGN RIGHT HAND SIDE (RHS ) VALUE TO LEFT HAND SIDE (LHS ). EX: a =10 INCREMENT AND DECREMENT OPERATOR: INCREMENTING THE VALUE BY ONE (IT USES ++) DECREMENTING THE VALUE BY ONE (IT USES --) PRE INCREMENT AND POST INCREMENT PRE DECREMENT AND POST DECREMENT PRE INCREMENT: a=10 b=++a a=11 b=11 POST INCREMENT: a=10 b=a++ b=10 a=11 SIMILLARLY PRE AND POST DECREMENT. TERNARY OR CONDITIONAL OPERATOR: TERNARY MEANS THREE. IT CONTAINS 3 EXPRESSIONS. CONDITION, VALUE1,VALUE2 (condition)?value1:value2 IF THE CONDITION IS TRUE , THEN VALUE 1 IS TAKEN. IF THE CONDITION IS FALSE THEN VALUE2 IS TAKEN. c= (a>b)?a:b; BITWISE OPERATOR: IT OPERATES ON BINARY DIGITS. THEY ARE & , | , ^ , << , >> COMMA OPERATOR: TO Access a method and class: MICROSOFT VISUAL STUDIO FILE --NEW---PROJECT-----SELECT ( VISUAL C#) AND CONSOLE APPLICATION ENTER THE NAME EX: program1 (IN THE REQUIRED FOLDER)AND OK. Console-------------> IT IS A CLASS. WriteLine------------> METHOD OR FUNCTION TO RUN THE PROGRAM PRESS F5 FUNCITON KEY. <----------------------------------------------------------------------> NOTE: THE KEYBOARD VALUES ARE ENTERED AFTER THE EXECUTION. IT IS IN THE FORM OF STRING. int x = int.Parse(Console.ReadLine()); double y = double.Parse(Console.ReadLine()); Console.WriteLine(x); Console.WriteLine(y); <--------------------------------------------------------------------------------------------------------------------------------> Reading From the keyboard //To accept for the console Console.Write("Enter name : "); string name = Console.ReadLine(); //Reads as a string from the keyboard Console.Clear(); // clears the screen Console.WriteLine("Name : " + name); <----------------------------------------------------------------------------------------------------------------------------------> //To Add two numbers Console.Write("a = "); int a = int.Parse(Console.ReadLine()); Console.Write("b = "); int b = int.Parse(Console.ReadLine()); //To read other data types //double d = double.Parse(Console.ReadLine()); //long l = long.Parse(Console.ReadLine()); //float f = float.Parse(Console.ReadLine()); int c = a + b; //Console.WriteLine("sum of " + a + " + " + b + " = " + c); //To change console fore and back color Console.ForegroundColor = ConsoleColor.White; Console.BackgroundColor = ConsoleColor.Red; Console.WriteLine("sum of {0} + {1} = {2}",a,b,c); <-----------------------------------------------------------------------------------------------------------------------------------------------> //WAP TO ACCEPT 2 NO. FROM THE USER, AND FIND WHICH IS THE BIG Console.Write("a = "); int a = int.Parse(Console.ReadLine()); Console.Write("b = "); int b = int.Parse(Console.ReadLine()); //To read other data types //double d = double.Parse(Console.ReadLine()); //long l = long.Parse(Console.ReadLine()); //float f = float.Parse(Console.ReadLine()); if (a > b) Console.WriteLine(" a is big " + a); else Console.WriteLine(" b is big" + b); //control Statements in C# // to find the largest of 3 numbers Console.Write("enter number1 : "); int a = int.Parse(Console.ReadLine()); Console.Write("enter number2 : "); int b = int.Parse(Console.ReadLine()); Console.Write("enter number3 : "); int c = int.Parse(Console.ReadLine()); int i = 10; if (a > b && a > c) // boolean expression True/Flase { Console.WriteLine("{0} is the largest number", a); } else if ( b > c) { Console.WriteLine("{0} is the largest number", b); } else { Console.WriteLine("{0} is the largest number", c); } <--------------------------------------------------------------------------------------------------------------> SWITCH CASE : Syntax: switch(expression) { case label: statement; break; case label: statement; break; case label: statement; break; default: statement; break; } Console.Write("Input number : "); int number = int.Parse(Console.ReadLine()); switch (number) { case 1: Console.WriteLine("You entered number : {0}", number); break; case 2: Console.WriteLine("You entered number : {0}", number); break; case 3: Console.WriteLine("You entered number : {0}", number); break; default: Console.WriteLine("You entered number > 3"); break; <-------------------------------------------------------------------------------------------------------------> Console.Write("Input string : "); string choice = Console.ReadLine(); switch (choice) { case "one": Console.WriteLine("You entered number : {0}",choice); break; case "two": Console.WriteLine("You entered number : {0}", choice); break; case "three": Console.WriteLine("You entered number : {0}", choice); break; default: Console.WriteLine("choice not found"); break; } <--------------------------------------------------------------------------------------------------------------------------> STRINGS: BUILT IN FUNCTIONS: THE FOLLOWINGS ARE THE FUNCTIONS OF string CLASS. StartsWith() EndsWith() Equals() Length() Replace() toUpper: THIS FUNCTIO IS USED TO CONVERT THE STRING INTO UPPERCASE. toLower : THIS FUNCTION IS USED TO CONVERT THE STRING INTO LOWERCASE. //declaration string s = "Welcome to Strings in C#"; Console.WriteLine("Length : {0}", s.Length); string upperCase = s.ToUpper(); string lowerCase = s.ToLower(); Console.WriteLine("Message : {0}", s); Console.WriteLine("Uppercase : {0}", upperCase); Console.WriteLine("LowerCase : {0}", lowerCase); <-----------------------------------------------------------------------------------------> StartsWith() : THIS FUNCTION IS USED TO CHECK STRING THAT STARTS WITH. string URL = "http://www.yahoo.com"; if (URL.StartsWith("http")) { Console.WriteLine("Its a HTTP request"); } if (URL.EndsWith(".com")) { Console.WriteLine("Its a Commercial website"); } <---------------------------------------------------------------------------------------> Equals() : THIS FUNCTION IS USED TO COMPARE THE TWO STRINGS. string s1 = "smith"; string s2 = "smith"; if (s1 == s2) //if(s1.Equals(s2)) // if (s1.Equals("amith")) { Console.WriteLine("s1 == s2"); } else { Console.WriteLine("s1 != s2"); } <-------------------------------------------------------------------------------------------------------------> Replace () : THIS FUNCTION IS USED TO REPLACE THE WORD. REPLACE FUNCTION: string message = "Google is fast, Google is Best, Google uses AJAX"; Console.Write("Enter word to search : "); string searchWord = Console.ReadLine(); Console.Write("Enter word to replace : "); string replaceWord = Console.ReadLine(); Console.WriteLine("Message : {0}", message); //Replace the word message = message.Replace(searchWord, replaceWord); Console.WriteLine("Message after Replacing : {0}", message); <-----------------------------------------------------------------------------------------> ITERATIVE OR REPETATIVE LOOP: FOR LOOP Console.WriteLine("enter the value from the keyboard"); int n = int.Parse(Console.ReadLine()); int sum, i; sum = 0; for (i = 1; i <= n; i++) sum = sum + i; Console.WriteLine("total sum is " + sum); output: 1+2+3+4+5 <-----------------------------------------------------------------------------------------------> WHILE LOOP Console.WriteLine("enter the value from the keyboard"); int n = int.Parse(Console.ReadLine()); int i = 2; while (i <= n) { Console.Write(i + " "); i += 2; } i = i +2------------------------------> i+=2 i = i 2------------------------------>i =2 i=i / 2--------------------------------> i / = 2 i = i+1---------------------------->i++ <----------------------------------------------------------------------------------------------> DO WHILE LOOP Console.WriteLine("enter the value from the keyboard"); int n = int.Parse(Console.ReadLine()); int i = 1; do { Console.Write(i + " "); n = n - 1; i = i + 1; } while (n != 0); <---------------------------------------------------> using System.Collections; FOR EACH ArrayList numbers = new ArrayList(); for (int i = 0; i < 10; i++) numbers.Add(i); foreach (int x in numbers) Console.Write(x+" "); <--------------------------------------------------------> ArrayList numbers = new ArrayList(); for (int i = 0; i < 10; i++) numbers.Add(10+i); foreach (int x in numbers) Console.Write(x + " "); <--------------------------------------------------------------------------> CLASS AND OBJECT: OBJECT ORIENTED PROGRAMMING STRUCTURE (OOPS): CLASS AND OBJECT: CLASS IS AN USER DEFINED DATA TYPE, WHICH CONTAINS DATA MEMBERS AND FUNCTIONS. CLASS SAMPLE { INT X;---------------------------->DATA MEMBER VOID GETDATA();----------->FUNCTION } FRUIT----->CLASS MANGO, BANANA, ORANGE ETC-=---> OBJECTS CLASS ANIMAL { EYE,MOUTH;--------DATA MEMBERS SEE() FUNCTION EAT() } TIGER,CAT, DOG----->OBJECTS CLASS EXAM { WHAT IS C++ WHAT IS JAVA } ST1,ST2,ST3,ST4--------->OBJECTS CLASS BANK { DEPOSIT() WITHDRAWAL() BALANCE() } CUST1,CUST2,CUST3-------->OBJECTS CLASS IS A TEMPLATE OR BLUEPRINT OR GENERAL REPRESENATION OR COMMON REPRESENTATION OR SKELETON OF APPLICATION OBJECT: IT IS AN ENTITY WHICH SHARES OR DRAWS THE COMMON PROPERTIES OF THE CLASS AND CAN HAVE ITS OWN BEHAVIOUR. PRIME CONCEPTS OF OOPS: 1. DATA HIDING 2. ABSTRACTION 3. ENCAPSULATION 4. INHERITANCE 5. POLYMORPHISM DATA HIDING: IN PROCEDURAL ORIENTED PROGRAMMING LANGUAGE "C", THERE IS NO SECURITY FOR THE DATA. THE DATA COULD BE ACCESSED IN ANY FUNCTION AND COULD BE MODIFIED. DATA FLOWS FREELY AROUND THE PROGRAM. IN ORDER TO PROVIDE EXCLUSIVELY SECURITY FOR THE DATA AND NOT FOR THE FUNCTIONS, THE PRIME CONCEPT OF OOPS , DATA HIDING CAME IN. HERE DATA IS TREATED AS AN IMPORTANT ELEMENT OR CRITICAL ELEMENT. ABSTRACTION OF DATA: THE DATA MEMBER OF THE CLASS SHOULD BE USED WITH IN THE MEMBER FUNCTIONS OF THE CLASS. THE DATA IS ABSTRACTED. ENCAPSULATION: THE GROUPING UP OF DATA MEMBERS AND FUNCTIONS TOGETHER IS ENCAPSULATION. IT IS USED TO SEPARTE THE ESSENTIAL ENTITIES FROM NON ESSENTIAL. DATA MEMBERS AND FUNCTIONS ARE ENCAPSULATED TO FORM A FAMILY CALLED "CLASS" INHERITANCE: IT IS THE PROCESS OF CREATING NEW CLASS BY MAKING USE OF EXISTING CLASS. IT PROVIDES A CONCEPT CALLED "REUSABILITY". RATHER THAN WRITTING THE CODE AGAIN AND AGAIN REUSE THE EXISTING PROPERTIES. IT AVOIDS WASTAGE OF SYSTEM TIME, USER TIME AND SYSTEM MEMORY. POLYMORPHISM: POLY MEANS MANY AND MORPHISM MEANS FORMS. AN OBJECT CAN TAKE MANY OR MULTIPLE FORMS. SYNTAX: class classname { datamembers functions or methods } ex: class sample { int x;------------>DATA MEMBER void get()-------->FUNCTION OR METHOD { } } OBJECT = DATA + METHOD SYNTAX: class classname { } ex: class test { } CREATION OF OBJECT: test t=new test(); ACCESS SPECIFIER: IT IS USED TO SPECIFY THE ACCESSIBILITY OF THE MEMBERS OF THE CLASS. THEY ARE  PRIVATE,  PUBLIC,  PROTECTED  INTERNAL NOTE: BY DEFAULT THE DATA MEMBERS OF THE CLASS ARE PRIVATE. class test { public int x; } class test1 { static void Main(String [] args) { test t=new test(); // t IS AN OBJECT OF CLASS test t.x=100; Console.WriteLine(t.x); } } <--------------------------------------------------------> class test { int x; public void get() { x = 250; } public void put() { Console.WriteLine(x); } } class test1 { static void Main(String[] args) { test t = new test(); t.get(); t.put(); } } <-----------------------------------------------------------> class demo { int x, y; public void getdata(int m,int n) { x = m; y = n; } public void putdata() { Console.WriteLine(x); Console.WriteLine(y); } } class demo1 { static void Main(String[] args) { demo d1 = new demo(); demo d2 = new demo(); int a = int.Parse(Console.ReadLine()); int b = int.Parse(Console.ReadLine()); int c = int.Parse(Console.ReadLine()); int d = int.Parse(Console.ReadLine()); d1.getdata(a,b ); d2.getdata(c,d ); d1.putdata(); d2.putdata(); } } <--------------------------------------------------------------> class demo { int x, y; public void getdata(int x,int y) { this. x =x; this. y =y; } public void putdata() { Console.WriteLine(x); Console.WriteLine(y); } } class demo1 { static void Main(String[] args) { demo d1 = new demo(); demo d2 = new demo(); int a = int.Parse(Console.ReadLine()); int b = int.Parse(Console.ReadLine()); int c = int.Parse(Console.ReadLine()); int d = int.Parse(Console.ReadLine()); d1.getdata(a,b ); d2.getdata(c,d ); d1.putdata(); d2.putdata();file:///G:/extra/032.jpg } } <-----------------------------------------------------------> NOTE: DATA MEMBER IRRESPECTIVE OF ANY CATEGORY CAN BE INITIALIZED. (private,public,protected) private int x=100; </article> </main></body></html>

Defines a table header

Defines a table cell

Defines a table caption

Computer Technology

Troubleshooting-Repair Pendrive / Flashdrive/ External Hard drive

Method 1:

Step 1: open command prompt (press start button and type cmd or press widows button + R then type cmd Then command prompt will appear.

Method 2:

Congrats!!! you are done :)

How to increase Battery Life and reduce data usage in Android phones

Use power saving mode

Automate your phone

Uninstall or disable apps

Hibernate or freeze apps

Streamline your home screen

Tweak display settings

Turn off vibrations

Turn off notifications

Turn off GPS

Under - clocking the CPU

Bendable Smartphones

How To Turn Your Boring Old Laptop Into A Cool Touch Screen Machine

Now, smartphones that can detect radiation

Computer Troubleshooting Tips

Apple iCloud

Bendable computer

Keep Your Computer Safe from USB

Software Engineering

Engineers you can become scientist..!

Introduction to Mobile Computing and Communications

How to be a Programmer: A Short, Comprehensive, and Personal Summary

How to score good marks in exams

HTML intoduction

My First Heading

and

to

tags.

defines the largest heading.

defines the smallest heading. Example

This is a heading

This is a heading

This is a heading

to

The style attribute defines a style for the

defines the smallest heading.
Example