YOU ARE DOWNLOADING DOCUMENT

Please tick the box to continue:

Transcript

Chapter 1

INTRODUCTION---------------------------------------------------------------------------------A command prompt is used in a text-based or "command-line" interface, such as a UNIX terminal or a DOS shell. It is a symbol or series of characters at the beginning of a line that indicates the system is ready to receive input. It other words, it prompts the user for a command (hence the name).

Since a command prompt requires specific input, it is basically useless if you don't know the syntax of the command you want to enter. Therefore, knowledge of some basic commands is required to use a command-line interface. Fortunately, most operating systems now use a graphical user interface GUI as their main way of requesting input from the user. This means you don't have to learn any special commands in order to use the computer. However, learning to use a command-line interface is kind of like learning to drive a car with a manual transmission. You never know when it might come in handy.

1.1 What is a command prompt or Terminal?

A command prompt is a non-graphical interface that allows you to interact with your operating system. At the command prompt, you enter commands by typing their names followed by options and arguments. Most modern computers use a graphical user interface (GUI), which allows users to more intuitively access programs and documents. However, some programs and commands are still only available only through a command prompt. To access the command prompt, follow the instructions appropriate to your operating system.A user can type commands at the command prompt, such as cd /, which means "change directory to the root folder." The "cd" command allows the user to browse through different directories of files on a hard disk or network. There are dozens of other commands that a user can type, which can be used to list, move, delete, and copy files, run programs, or perform other operations. While the "cd" command is the same in both DOS and UNIX, many other commands have different syntax.

1.2 Windows Command Prompt :-To access the command prompt in Windows, in Windows 7, click the Start button and enter cmd. In other versions, from the Start menu, select Run... and then enter cmd. The command prompt is often preceded by the current directory of the system the user is working with. For example, the default prompt in DOS may be C:\, which indicates the user is working at the root level of the main C: drive.Command Prompt is officially called Windows Command Processor but is also sometimes called the command shell or by its file name cmd.exe. Command Prompt is sometimes incorrectly referred to as "the DOS prompt" or as MS-DOS itself. Command Prompt is a Windows program that emulates many of the command line abilities available in MS-DOS but it is not actually MS-DOS. Command Prompt is most commonly used to execute batch files, perform advanced administrative functions, and troubleshoot and solve certain kinds of Windows issues.1.3 Unix terminal :-When you log into a UNIX computer, your shell begins to run and provides you with a command prompt. The command prompt's appearance varies depending on the shell you're using. In UNIX, the prompt may be ~ user$, where "user" is the name of the current user. The tilde (~) indicates the current directory is the user's home folder.Every user has a unique username. When they logon to the system, they are placed in a HOME directory, which is a portion of the disk space reserved just for them. When you log onto a UNIX system, your main interface to the system is called the UNIX SHELL. This is the program that presents you with the dollar sign ($) prompt. This prompt means that the shell is ready to accept your typed commands. There is more than one variety of shell that can be used on a UNIX system. one of the most standard UNIX shells called the Bourne Shell. Other shells such as the Korn Shell or Bourne Again Shell work very similarly at this level. They all use the dollar sign as their prompt.UNIX commands are strings of characters typed in at the keyboard. To run a command, you just type it in at the keyboard and press the ENTER key. We will look at several of the most common commands below. UNIX extends the power of commands by using special flags or switches. These switches are one of the most powerful features of UNIX commands. Switches are usually preceded with a dash (-) and precede any filenames or other arguments on the command line.

1.4 Comparison between Windows and UNIX commands :-There are many commands which are use for same task but have different syntax in different operating systems. Their comparison is as follows:

In windows, the command for listing files directory is dir while in Unix, command for same task is ls.

In windows, the command for clearing the screen is cls while in Unix, command for same task is clear. In windows, the command for copying a file is Copy while in Unix, command for same task is cp.

In windows, the command for removing a file Del while in Unix, command for same task is rm.

In windows, the command for moving a file Move while in Unix, command for same task is mv.

Windows or DOS commands are not case sensitive, UNIX systems are case sensitive (upper and lower case characters are considered different). Nearly all command names and most of their command line switches will be in lowercase.

1.5 Difficulty :-The main difficulty is, as all operating system such as Unix, windows has their own commands. Therefore, the new user fined it difficult to work on these command prompt or terminal.

To resolve this difficulty, new application is created called Multi-Platform based Virtual terminal. In this terminal, the commands used are common for all platforms such as windows, Unix, etc.

1.6 Multi-platform based Virtual Terminal :-This terminal works as the virtual command prompt on multiple platforms. It is platform independent. It recovers disadvantages of terminal. In this we create user define commands. Same command can be execute on all platform. It also has a built in editor which lets you write files. It is written in Java, So, java must be installed in system i.e. machine has to be a Java Virtual Machine (JVM).

1.6.1 Features of Virtual Terminal :- 1. It supports multiple entries of filenames & website names under a single command, all these entries are then processed sequentially.2. It also has a built in editor which lets you write files:

a) Type "edit" at the command-line.

b) Write whatever you want to write.

c) Type "save example" where, "example" is the name of the file you have

written.

d) Type "exit" at command-line to exit from the editor mode and go back to command mode of Virtual Terminal"

e) To edit an existing file type "edit hello.txt" where, "hello.txt" is the existing file you want to edit.

3. A directory cannot delete with files inside it. the files inside have to be deleted, then delete the directory.4. It supports "command-line surfing". Its just like as of "doskey" in DOS. You can easily switch between your previous commands using the UP arrow & DOWN arrow keys.5. It supports multiple video modes (like orange text on black background etc.).6. It can run any number of programs with a single 'command-line' command e.g. "run calc write mplayer" will start the programs "calc", "write" & "mplayer" simultaneously.

7. It cannot access any other partition or drivedirectly from the command-line. If the Terminal.class file is in yourdrive C:\, then only C drive can be accessed.

Chapter2SOFTWARE ENGINEERING PARADIGM------------------------------------------------------------------------------------------------------------Every project has its own methodology. Various methodology models such as waterfall, incremental, prototyping, spiral etc. The model suitable for our project is waterfall model.

2.1 Phases of Project :-This section explains the various phases of the project. The software model followed for implementing this project is waterfall model.

Fig 2.1 Waterfall Model

This project consists of following phases:-

*Requirements

*Analysis

*Design

*Implementation

*Testing

2.1.1 Requirements Phase :- In this phase, all the requirements of the project will be gathered based on which the problem will be analyzed. We will try to understand the specific requirements that must be achieved to implement this project. At the end of this phase, we will have detailed understanding of the nature of application to be developed by identifying the problem and specify refined preliminary set of proposed solution.

This phase will state following points in detail

*Problem definition

*Need for building this application

*Requirement Specification

*Scope of the Project.

*Deliverables of the Project.2.1.1.1 Requirement specification :-In the context of computer-based systems (and software), the term specification means different things to different people, a specification can be written document, a graphical model, a formal mathematical model, and a collection of usage of scenarios, prototype or any combination of these. The System specification is the final work product produced by the system and requirements engineer. It serves as the foundation for the hardware engineering, software engineering, database engineering and human engineering. It describes the function and performance of a computer-based system and the constrained that will govern its development. The specification also describes the information that is input to and output from the system.2.1.1.2 Hardware requirements :-These are the minimum requirements of the computer setup for the product developed to run, giving satisfactory results. Any faster machine would certainly improve the performance and speed.

1. Pentium III 700 MHz (2)

2. 64 MB Ram

3. 2 GB Hard Disk space.

2.1.1.3 Software requirements :-These are the requirement for the well functioning of the software. any upgraded versions of the software will also works.

1) JDK 1.6.0 or above.2.1.2 Analysis Phase :-This phase analyzes the various aspects of the project. In this phase, the architecture of the project will be designed and designed and decisions regarding problem evaluation will be taken. The basic modules in which the project will be divided will be taken. The technology decision for implementing the project is taken in this phase.2.2 Design :-In this phase, we will come out with various UML diagrams, which explain the design of the project. The database designing will be done keeping in view the performance issues. All the data structures and interfaces required would be designed as per the specifications mentioned in Requirements phase.

2.3 Implementation :-In this phase, we will decide the coding strategy that will be employed to implements this Project. Based on the decided strategy, we will implement the project using the technologies decided in analysis phase. The modules will be implemented as per the design. The functionality of each unit will be tested during this phase.

2.4 Testing :-In this phase, various testing strategies like Unit Testing, Integration Testing, Validation Testing and system Testing will be carried out for various test cases. All the modules will be tested for specific test and all the errors uncovered will be fixed.

2.5 Technology Used :- JAVA

A programming tool or software tool is a program or application that software developers use to create, debug, maintain, or otherwise support other programs and applications. The term usually refers to relatively simple programs that can be combined together to accomplish a task. The Chapter describes about the software tool that is used in our project.2.5.1 What Is Java?

Java is a computer programming language. It enables programmers to write computer instructions using English based commands, instead of having to write in numeric codes. Its known as a high-level language because it can be read and written easily by humans. Like English, Java has a set of rules that determine how the instructions are written. These rules are known as its syntax. Once a program has been written, the high-level instructions are translated into numeric codes that computers can understand and execute.

2.5.2 Why Choose Java?

Java was designed with a few key principles in mind:

Easy to Use: The fundamentals of Java came from a programming language called c++. Although c++ is a powerful language, it was felt to be too complex in its syntax, and inadequate for all of Java's requirements. Java built on, and improved the ideas of c++, to provide a programming language that was powerful and simple to use.

Reliability: Java needed to reduce the likelihood of fatal errors from programmer mistakes. With this in mind, object-oriented programming was introduced. Once data and its manipulation were packaged together in one place, it increased Javas robustness.

Secure: As Java was originally targeting mobile devices that would be exchanging data over networks, it was built to include a high level of security. Java is probably the most secure programming language to date.

Platform Independent: Programs needed to work regardless of the machine they were being executed on. Java was written to be a portable language that doesn't care about the operating system or the hardware of the computer.

The team at Sun Microsystems was successful in combining these key principles, and Java's popularity can be traced to it being a robust, secure, easy to use, and portable language.

2.5.3 Java is a Platform :-Java (with a capital J) is a platform for application development. A platform is a loosely defined computer industry buzzword that typically means some combination of hardware and system software that will mostly run all the same software. For instance PowerMacs running Mac OS 9.2 would be one platform. DEC Alphas running Windows NT would be another. There's another problem with distributing executable programs from web pages. Computer programs are very closely tied to the specific hardware and operating system they run. A Windows program will not run on a computer that only runs DOS. A Mac application can't run on a Unix workstation. Java solves the problem of platform-independence by using byte code. The Java compiler does not produce native executable code for a particular machine like a C compiler would. Instead it produces a special format called byte code. Java byte code written in hexadecimal, byte by byte, looks like this: CA FE BA BE 00 03 00 2D 00 3E 08 00 3B 08 00 01 08 00 20 08This looks a lot like machine language, but unlike machine language Java byte code is exactly the same on every platform. This byte code fragment means the same thing on a Solaris workstation as it does on a Macintosh PowerBook. Java programs that have been compiled into byte code still need an interpreter to execute them on any given platform. The interpreter reads the byte code and translates it into the native language of the host machine on the fly. The most common such interpreter is Sun's program java (with a little j). Since the byte code is completely platform independent, only the interpreter and a few native libraries need to be ported to get Java to run on a new computer or operating system. The rest of the runtime environment including the compiler and most of the class libraries are written in Java. All these pieces, the javac compiler, the java interpreter, the Java programming language, and more are collectively referred to as Java.

2.5.4 Java is Simple :-Java was designed to make it much easier to write bug free code. According to Sun's Bill Joy, shipping C code has, on average, one bug per 55 lines of code. The most important part of helping programmers write bug-free code is keeping the language simple. Java has the bare bones functionality needed to implement its rich feature set. It does not add lots of syntactic sugar or unnecessary features. Despite its simplicity Java has considerably more functionality than C, primarily because of the large class library. Because Java is simple, it is easy to read and write. Obfuscated Java isn't nearly as common as obfuscated C. There aren't a lot of special cases or tricks that will confuse beginners. About half of the bugs in C and C++ programs are related to memory allocation and deallocation.

2.5.5 Java is Platform Independent :-Java was designed to not only be cross-platform in source form like C, but also in compiled binary form. Since this is frankly impossible across processor architectures Java is compiled to an intermediate form called byte-code. A Java program never really executes natively on the host machine. Rather a special native program called the Java interpreter reads the byte code and executes the corresponding native machine instructions. Thus to port Java programs to a new platform all that is needed is to port the interpreter and some of the library routines. Even the compiler is written in Java. The byte codes are precisely defined, and remain the same on all platforms. The second important part of making Java cross-platform is the elimination of undefined or architecture dependent constructs. Integers are always four bytes long, and floating point variables follow the IEEE 754 standard for computer arithmetic exactly.

2.5.6 Java is Multi-Threaded :-Java is inherently multi-threaded. A single Java program can have many different threads executing independently and continuously. Three Java applets on the same page can run together with each getting equal time from the CPU with very little extra effort on the part of the programmer. This makes Java very responsive to user input. It also helps to contribute to Java's robustness and provides a mechanism whereby the Java environment can ensure that a malicious applet doesn't steal all of the host's CPU cycles. Unfortunately multithreading is so tightly integrated with Java, that it makes Java rather difficult to port to architectures like Windows 3.1 or the PowerMac that don't natively support preemptive multi-threading.

2.6 The Architecture of the Java Virtual Machine :-In the Java virtual machine specification, the behavior of a virtual machine instance is described in terms of subsystems, memory areas, data types, and instructions. These components describe an abstract inner architecture for the abstract Java virtual machine. The purpose of these components is not so much to dictate an inner architecture for implementations. It is more to provide a way to strictly define the external behavior of implementations. The specification defines the required behavior of any Java virtual machine implementation in terms of these abstract components and their interactions. Figure 2.2 shows a block diagram of the Java virtual machine that includes the major subsystems and memory areas described in the specification. As mentioned in previous chapters, each Java virtual machine has a class loader subsystem: a mechanism for loading types given fully qualified names. Each Java virtual machine also has an execution engine: a mechanism responsible for executing the instructions contained in the methods of loaded classes. When a Java virtual machine runs a program, it needs memory to store many things, including byte codes and other information it extracts from loaded class files, objects the program instantiates, parameters to methods, return values, local variables, and intermediate results of computations.

Fig. 2.2. The internal architecture of the Java virtual machine.The Java virtual machine organizes the memory it needs to execute a program into several runtime data areas. Although the same runtime data areas exist in some form in every Java virtual machine implementation, their specification is quite abstract. Many decisions about the structural details of the runtime data areas are left to the designers of individual implementations.

Different implementations of the virtual machine can have very different memory constraints. Some implementations may have a lot of memory in which to work, others may have very little. Some implementations may be able to take advantage of virtual memory, others may not.Some runtime data areas are shared among all of an application's threads and others are unique to individual threads. Each instance of the Java virtual machine has one method area and one heap. These areas are shared by all threads running inside the virtual machine. When the virtual machine loads a class file, it parses information about a type from the binary data contained in the class file. It places this type information into the method area. As the program runs, the virtual machine places all objects the program instantiates onto the heap.Chapter 3DESIGN DETAILS------------------------------------------------------------------------------------------------------------This software has written in JAVA as frontend. As java is platform independent. Following are details for java3.1 JAVA :-3.1.1 The Creation of Java :-Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc. in 1991. It took 18 months to develop the first working version. This language was initially called Oak but was renamed Java in 1995. Between the initial implementation of Oak in the fall of 1992 and the public announcement of Java in the spring of 1995, many more people contributed to the design and evolution of the language.

Bill Joy, Arthur van Hoff, Jonathan Payne, Frank Yellin, and Tim Lindholm were key contributors to the maturing of the original prototype. Somewhat surprisingly, the original impetus for Java was not the Internet! Instead, the primary motivation was the need for a platform-independent (that is, architecture-neutral) language that could be used to create software to be embedded in various consumer electronic devices, such as microwave ovens and remote controls.

The trouble with C and C++ (and most other languages) is that they are designed to be compiled for a specific target. Although it is possible to compile a C++ program for just about any type of CPU, to do so requires a full C++ compiler targeted for that CPU. The Problem is that compilers are expensive and time-consuming to create. An easier and more cost-efficientsolution was needed. In an attempt to find such a solution, Gosling and others began work on a portable, platform-independent language that could be used to produce code that would run on a variety of CPUs under differing environments. This effort ultimately led to the creation of Java.

3.1.2 The Java Buzzwords :-No discussion of the genesis of Java is complete without a look at the Java buzzwords. Although the fundamental forces that necessitated the invention of Java are portability and security, other factors also played an important role in molding the final form of the language. The key considerations were summed up by the Java team in the following list of buzzwords:

Simple

Secure

Portable

Object-oriented

Robust

Multithreaded

Architecture-neutral

Interpreted

High performance

Distributed

Dynamic3.1.3 Event Handling :-3.1.3.1 Events :-Event is an object that describes a state change in a source. It can be generated as consequence of a person interacting with the elements in a graphical user interface. Some of the activities that cause events to be generated are pressing a button, entering a character via the keyboard, electing an item in a list, and clicking the mouse.

3.1.3.2 The KeyListener Interface :- This interface defines three methods. The keyPressed( ) and keyReleased( ) methods are invoked when a key is pressed and released, respectively. The keyTyped( ) method is invoked when a character has been entered. For example, if a user presses and releases the A key, three events are generated in sequence: key pressed, typed, and released. If a user presses and releases the HOME key, two key events are generated in sequence: key pressed and released. The general forms of these methods are shown here:void keyPressed(KeyEvent ke)

void keyReleased(KeyEvent ke)

void keyTyped(KeyEvent ke)3.2 The Java Class Library :-The Java class library provides the set of classes that are guaranteed to be available in any commercial Java environment. Those classes are in the Java package and include all the classes .The Java Developer's Kit comes with documentation for all of the java class library, which includes descriptions of each class's instance variables, methods, constructors, interfaces, and so on. You can get to this documentation (called the Java Application Programmer's Interface, or API) via the web. A shorter summary of the Java API is in appendix C as well. Exploring the Java class library and its methods and instance variables is a great way to figure out what java can and cannot do, as well as how it can become a starting point for your own development.Here are the class packages that are part of the Java class library: java.lang- Classes that apply to the language itself, including the Object class, the string class, and the system class. It also contains the special classes for the primitive types (Integer, character, float, and so on). You will get at least a glance at most of the classes in this package in this first week.

java.util Utility classes, such as Date, as well as simple collection classes such as vector and Hash table. You'll learn more about these classes in the Bonus week.

java.io- Input and output classes for writing to and reading from streams ( such as standard input and output ) and for handling files, "Streams and I/O," describes the classes in this package.

java.net- Classes for networking support, including socket and URL ( a class to represent references to documents on the World Wide Web) You'll learn a little about networking on "Windows, networking, and other Tidbits," and then on " Client/Server Networking in Java.

java.awt- This is the abstract Windowing Toolkit. It contains classes to implement graphical user interface features, including classes for Window, Menu, Button, Font, Check Box , and so on It also includes mechanisms for managing system events and for processing images. java.applet- Classes to implement Java applets.

In addition to the Java classes, your development environment may also include additional classes that provide other utilities or functionality. Although these classes may be useful, because they are not part of the standard Java library, they may not be available to other people trying to run your java program unless you explicitly include those classes with your program. This is particularly important for applets, because applets are expected to be able to run on any platform, using any Java - enabled browser. Only classes inside the Java package are guaranteed to be available on all browsers and Java environments.

Fig. 3.1 Applet Hierarchy

3.3 Window Fundamentals :-The AWT defines windows according to a class hierarchy that adds functionality and specificity with each level. The two most common windows are those derived from Panel, which is used by applets, and those derived from Frame, which creates a standard window. Much of the functionality of these windows is derived from their parent classes. Thus, a description of the class hierarchies relating to these two classes is fundamental to their understanding. Figure 3.1 shows the class hierarchy for Panel and Frame. 3.3.1 Component :-At the top of the AWT hierarchy is the Component class. Component is an abstract class that encapsulates all of the attributes of a visual component. All user interface elements that are displayed on the screen and that interact with the user are subclasses of Component. It defines over a hundred public methods that are responsible for managing events, such as mouse and keyboard input, positioning and sizing the window, and repainting.

A Component object is responsible for remembering the current foreground and background colors and the currently selected text font. Class Description ScrollPane a container that provides horizontal and/or vertical scroll bars for another component. System Color contains the colors of GUI widgets such as windows, scroll bars, text, and others. TextArea Creates a multiline edit control. TextComponent A superclass for TextArea and TextField. TextField Creates a single-line edit control. Toolkit abstract class implemented by the AWT. Window Creates a window with no frame, no menu bar, and no title.

3.3.2 Container :-The Container class is a subclass of Component. It has additional methods that allow other Component objects to be nested within it. Other Container objects can be stored inside of a Container. This makes for a multileveled containment system. A container is responsible for laying out any components that it contains. It does this through the use of various layout managers.3.3.3 Panel :-The Panel class is a concrete subclass of Container. It doesnt add any new methods; it simply implements Container. A Panel may be thought of as a recursively nestable, concrete screen component. Panel is the super class for Applet. When screen output is directed to an applet, it is drawn on the surface of a Panel object. In essence, a Panel is a window that does not contain a title bar, menu bar, or border. This is why you dont see these items when an applet is run inside a browser. When you run an applet using an applet viewer, the applet viewer provides the title and border. Other components can be added to a Panel object by its add( ) method from. Once these components have been added, you can position and resize them manually using the setLocation( ), setSize( ), or setBounds( ) methods defined by Component.

Fig.3.2The class hierarchy for Panel and Frame3.3.4 Window :-The Window class creates a top-level window. A top-level window is not contained within any other object; it sits directly on the desktop. Generally, you wont create Window objects directly. Instead, you will use a subclass of Window called Frame, described next.3.3.5 Frame :-Frame encapsulates what is commonly thought of as a window. It is a subclass of Window and has a title bar, menu bar, borders, and resizing corners. If you create a Frame object from within an applet, it will contain a warning message, such as Java Applet Window, to the user that an applet window has been created. This message warns users that the window they see was started by an applet and not by software running on their computer. When a Frame window is created by a program rather than an applet, a normal window is created.CONCLUSION------------------------------------------------------------------------------------------------------------

Thus, we implemented project on Multi-platform based Virtual Terminal. The project consists of one window which has two panels. This can be dynamically installed on any operating system. It has its own inbuilt commands which are same for all operating system and can be run manually.

From two panels, the above panel show output or operation of commands and as in second panel accept the commands.

This project provides multi-platform facility which avoids confusion of user for using different commands. As user has to remember different commands used in different operating system this difficulty can be avoided by this multi-platform virtual terminal. The default command prompts are statically installed in operating system. This terminal can be installed dynamically and can be used virtually.REFERENCES

-------------------------------------------------------------------------------------------------------

[1] Complete Reference Java, By H. Shields.[2] The Linux Command Line, William E. Shotts.[3] Windows command line reference, by Microsoft.[4] Software Engineering by Roger S. Pressman.1


Related Documents