Programming

Best programming languages to learn on your own time

With thousands of programming languages out there, it can be daunting to find a language to start with and a good course that assumes no prior knowledge. This post highlights programming languages that are good for beginning programmers and some resources to get started.

With thousands of programming languages out there, it can be daunting to find a language to start with and a good course that assumes no prior knowledge. Especially if you are someone who is busy and wants to learn on their own time and don’t have the flexibility to take an in- person class, getting started with programming can be difficult. This post highlights programming languages that are good for beginning programmers and some resources to get started.

For those with no experience

These courses have been designed for people who have little or no programming experience.

C

C is one of the most widely used programming languages and often used as an introduction to programming. It has influenced many languages that came after it, and knowledge of C will make learning later languages, such as Objective-C (used by Apple), easier. It influences many later languages you could want to learn, so starting with C will give you a deeper understanding of how computers work.

Java

Java is a higher level language which is designed to be compatible with any operating system. It has similar syntax to C and C++. It’s a great programming language to start with because it is widely used and practical, however it won’t give you as deep of an understanding of computer operation as a lower level language like C will.

C++

C++ bridges the gap between a language like C and Java as it has features of both low-level and high-level languages. It’s another commonly used language that has a wide range of uses and compatibility. It’s based off of C and adds object-oriented features. It has also influenced many other languages such as C# and Java.

Python

Python is a language that was designed with human readability in mind. Because of this, it doesn’t take as much code to execute programs as other languages. It’s a great, easy way to earn recurring concepts in computer science and has real world use in the creation of scripts.

Ruby

Ruby has similar function to Python but is less readable. It’s more object-oriented than Python and is similarly designed with simplicity in mind. It has many applications, but is most often used for web applications.

HTML and CSS

HTML and CSS are used for webpage design. While these languages won’t really help pave the way for learning more traditional programming languages, they are essential for webpage design. HTML (HyperText Markup Language) is a “markup language” which allows you to put content into a webpage whereas CSS (Cascading Style Sheets), is used to format and define the layout of a page.

MIT App Inventor for Android

If you aren’t interested in programming as a profession (at least at the moment) it may be worth looking at using the MIT App Inventor for Android. It requires no coding, but will teach you how programmers think and provide knowledge on some concepts in computing. Plus, you’ll end up being able to make Android apps once you’ve mastered it!

What’s next?

If you already have knowledge of another programming language then these are great follow-up languages.

C#

C# is primarily used for Windows applications in the .NET Framework. Learning C# is easy if you have experience in C, C++, or Java. The syntax is similar. It’s popularity has been increasing as C# is used for third-party apps on Windows 8 or Windows Phone.

Objective-C

Objective-C is primarily used for Apple’s operating systems, OSX (for Macs) and iOS (for iPhone and iPad). If you are looking to develop for Mac, Objective-C is the way to go. Apple provides lots of support for learning Objective-C through their developer program.

Javascript

Javascript (little relation to Java) is a common language used to make webpages more dynamic. With a syntax similar to C, it doesn’t require a lot of effort to set up as it’s built into web browsers. It’s also used in other applications such as PDFs.

PHP

PHP is another language often used for web development, although it works well as a general- purpose language as well. PHP can be implemented directly into HTML. Those looking to learn PHP should already know HTML, CSS, and Javascript.




Programming language

A "programming language" is a language designed to describe a set of consecutive actions to be executed by a computer. A programming language is therefore a practical way for us (humans) to give instructions to a computer.

On the other hand, the term "natural language" defines a means of communication shared by a group of individuals (for example: English or French)

Languages that computers use to communicate with each other, have nothing to do with programming languages, they are referred to as communication protocols, these are two very different concepts. A programming language is very strict:

EACH instruction corresponds to ONE processor action. The language used by the processor is called machine code. The code that reaches the processor consists of a series of 0s and 1s known as (binary data).

Machine code is therefore difficult for humans to understand, which is why intermediary languages, which can be understood by humans, have been developed. The code written in this type of language is transformed into machine code so that the processor can process it.

The assembler was the first programming language ever used. This is very similar to machine code but can be understood by developers. Nonetheless, such a language is so similar to machine code that it strictly depends on the type of processor used (each processor type may have its own machine code). Thus a program developed for one machine may not be ported to another type of machine. The term "portability"describes the ability to use a software program on different types of machines. A software program written in assembler code, may sometimes have to be completely rewritten to work on another type of computer!

A programming language has therefore several advantages:

• it is much more understandable than machine code;
  
• it allows greater portability, i.e. can be easily adapted to run on different types of computers.
  
  
  

Imperative and functional programming languages

Programming languages are generally divided into two major groups according to how their commands are processed:

• imperative languages;
  
• functional languages.
  

An imperative language programs using a series of commands, grouped into blocks and comprising of conditional statements which allow the program to return to a block of commands if the condition is met. These were the first programming languages in use, even today many modern languages still use this principle.

Structured imperative languages suffer, however, from lack of flexibility due to the sequentiality of instructions.

Functional programming language

A functional programming language (often called procedural language) is a language which creates programs using functions, returning to a new output state and receiving as input the result of other functions. When a function invokes itself, we refer to this as recursion.

Interpretation and compilation

Programming languages may be roughly divided into two categories:

• interpreted languages
• compiled languages

Interpreted language

A programming language is by definition different to machine code This must therefore be translated so that the processor can understand the code. A program written in an interpreted language requires an extra program (the interpreter) which translates the programs commands as needed.

Compiled language

A program written in a "compiled" language is translated by an additional program called a compiler which in turn creates a new stand-alone file which does not require any other program to execute itself, such a file is called an executable. A program written in a compiled language has the advantage of not requiring an additional program to run it once it has been compiled. Furthermore, as the translation only needs to be done once, at compilation it executes much faster. However, it is not as flexible as a program written in an interpreted language, as each modification of the source file (the file understandable by humans: the file to be compiled) means that the program must be recompiled for the changes to take effect.

On the other hand, a compiled program has the advantage of guaranteeing the security of the source code. In effect, interpreted language, being a directly legible language, means that anyone can find out the secrets of a program and thus copy or even modified the program. There is therefore a risk of copyright violation. On the other hand, certain secure applications need code confidentiality to avoid illegal copying (bank transactions, on-line payments, secure communications...).

Intermediary languages

Some languages belong to both categories (LISP, Java, Python...) as the program written in these languages may in certain cases undergo an intermediary compilation phase, into a file written in a language different to the source file and non-executable (requiring an interpreter). Java applets, small programs, often loaded in web pages, are compiled files, which can only be executed from within a web browser (these are files with the .class extension).




Computer Programming For Beginners, Kids, and Adults

This program aims to bring "fun" back to programming by using a small, easy to learn programming language for beginners. If you have any interest in learning computer programming, this appplication is aimed at kids, adults, and beginners is a good place to start.
Small Basic is a programming language that is designed to make programming extremely easy, approachable and fun for beginners.

It encourages everyone, from kids to adults to take their first step into the world of programming.

Some information about Small Basic:
- Small Basic derives its inspiration from the original BASIC programming language, and is based on the Microsoft .Net platform. It is really small with just 15 keywords and uses minimal concepts to keep the barrier to entry as low as possible.
- The Small Basic development environment is simple, yet provides powerful modern environment features like Intellisense™ and instant context sensitive help.
- Small Basic allows third-party libraries to be plugged in with ease, making it possible for the community to extend the experience in fun and interesting ways.
You might want to grab the Getting Started Guide when you download the program, its a great resource.
Aimed at kids and beginners, its well written, well illustrated and easy to understand.
Computer Programming For Beginners, Kids, and Adults




To install Small Basic, you'll need Windows XP, Windows Vista, or Windows 7, and Microsoft .NET Framework 3.5.




structured programming (modular programming)

Structured programming (sometimes known as modular programming) is a subset of procedural programming that enforces a logical structure on the program being written to make it more efficient and easier to understand and modify. Certain languages such as Ada, Pascal, and dBASE are designed with features that encourage or enforce a logical program structure.

Structured programming frequently employs a top-down design model, in which developers map out the overall program structure into separate subsections. A defined function or set of similar functions is coded in a separate module or submodule, which means that code can be loaded into memory more efficiently and that modules can be reused in other programs. After a module has been tested individually, it is then integrated with other modules into the overall program structure.

Program flow follows a simple hierarchical model that employs looping constructs such as "for," "repeat," and "while." Use of the "Go To" statement is discouraged.

Structured programming was first suggested by Corrado Bohm and Guiseppe Jacopini. The two mathematicians demonstrated that any computer program can be written with just three structures: decisions, sequences, and loops. Edsger Dijkstra's subsequent article, Go To Statement Considered Harmful was instrumental in the trend towards structured programming. The most common methodology employed was developed by Dijkstra. In this model (which is often considered to be synonymous with structured programming, although other models exist) the developer separates programs into subsections that each have only one point of access and one point of exit.

Almost any language can use structured programming techniques to avoid common pitfalls of unstructured languages. Unstructured programming must rely upon the discipline of the developer to avoid structural problems, and as a consequence may result in poorly organized programs. Most modern procedural languages include features that encourage structured programming. Object-oriented programming (OOP) can be thought of as a type of structured programming, uses structured programming techniques for program flow, and adds more structure for data to the model.

The History of Object Oriented Programming

The basis for OOP started in the early 1960s. A breakthrough involving instances and objects was achieved at MIT with the PDP-1, and the first programming language to use objects was Simula 67. It was designed for the purpose of creating simulations, and was developed by Kristen Nygaard and Ole-Johan Dahl in Norway.

They were working on simulations that deal with exploding ships, and realized they could group the ships into different categories. Each ship type would have its own class, and the class would generate its unique behavior and data. Simula was not only responsible for introducing the concept of a class, but it also introduced the instance of a class.

The term "object oriented programming " was first used by Xerox PARC in their Smalltalk programming language. The term was used to refer to the process of using objects as the foundation for computation. The Smalltalk team was inspired by the Simula 67 project, but they designed Smalltalk so that it would be dynamic. The objects could be changed, created, or deleted, and this was different from the static systems that were commonly used. Smalltalk was also the first programming language to introduce the inheritance concept. It is this feature that allowed Smalltalk to surpass both Simula 67 and the analog programming systems. While these systems were advanced for their time, they did not use the inheritance concept.

Simula 67 was a groundbreaking system that has inspired a large number of other programming languages, and some of these include Pascal and Lisp. By the 1980s, object oriented programming had become prominent, and the primary factor in this is C++. Object oriented programming was also important for the development of Graphical user interfaces. The Cocoa structure that exists within Mac OS X is a good example of a dynamic GUI that works with an object oriented programming language. This paradigm of programming has also played an important role in the development of event- driven programming.

Niklaus Wirth and his associates were looking at areas such as modular programming and data abstraction, and they developed two systems which incorporated these elements. These two systems are Oberon and Modula-2. Oberon used a unique approach to classes and object orientation that is much different than C++ or Smalltalk. Since the introduction of OOP, a large number of modern programming languages are now using the concept. Some of these are Fortran, BASIC, and Pascal. There have been some compatibility issues, because many programs were not designed with a OOPs approach in mind. Object oriented programming languages that were "pure" did not have many of the functions that programmers needed.

To solve these problems, a number of researchers have been attempting to design new programming languages that used object oriented concepts but still retained many of the functions that programmers needed. One example of a programming language that has achieved this to some degree is Eiffel. Another programming language that has attempted to solve this problem is Java. Java has become popular because it uses a virtual machine, and it is very similar to C++ and C. The virtual machine is important because it allows code to be run on multiple platforms without having to be changed. Another system that is similar is Microsoft's .NET. Many developers now understand the importance of OOP, and are actively using it within their own programs. Many researchers have continued to make advancements by using the object oriented approach.

There are a number of other languages that have successfully combined the object oriented approach with procedures that are useful to programmers. Python is one example, and Ruby uses a similar approach as well.

The use of an object oriented approach has led to advancements in modeling languages, design patterns, and a number of other areas. It is likely that OOP is a programming paradigm that will continue to evolve as we move forward into the future. It is a powerful language which has continued to improve over the years. It is the subject of debate within the programming community, as critics point out a number of problems with the structure. However, the popularity of programming languages such as Java demonstrate that it is a paradigm that is here to stay.




Four major principles of Object-Oriented Programming (OOP)

The Objects Oriented Programming (OOP) is constructed over four major principles: Encapsulation, Data Abstraction, Polymorphism and Inheritance.

1. Encapsulation:
Encapsulation means that the internal representation of an object is generally hidden from view outside of the object’s definition. Typically, only the object’s own methods can directly inspect or manipulate its fields.

Encapsulation is the hiding of data implementation by restricting access to accessors and mutators.

An accessor is a method that is used to ask an object about itself. In OOP, these are usually in the form of properties, which have a get method, which is an accessor method. However, accessor methods are not restricted to properties and can be any public method that gives information about the state of the object. A Mutator is public method that is used to modify the state of an object, while hiding the implementation of exactly how the data gets modified. It’s the set method that lets the caller modify the member data behind the scenes.

Hiding the internals of the object protects its integrity by preventing users from setting the internal data of the component into an invalid or inconsistent state. This type of data protection and implementation protection is called Encapsulation.

A benefit of encapsulation is that it can reduce system complexity.

2. Abstraction
Data abstraction and encapuslation are closely tied together, because a simple definition of data abstraction is the development of classes, objects, types in terms of their interfaces and functionality, instead of their implementation details. Abstraction denotes a model, a view, or some other focused representation for an actual item.

“An abstraction denotes the essential characteristics of an object that distinguish it from all other kinds of object and thus provide crisply defined conceptual boundaries, relative to the perspective of the viewer.” — G. Booch

In short, data abstraction is nothing more than the implementation of an object that contains the same essential properties and actions we can find in the original object we are representing.

3. Inheritance
Inheritance is a way to reuse code of existing objects, or to establish a subtype from an existing object, or both, depending upon programming language support. In classical inheritance where objects are defined by classes, classes can inherit attributes and behavior from pre-existing classes called base classes, superclasses, parent classes or ancestor classes. The resulting classes are known as derived classes, subclasses or child classes. The relationships of classes through inheritance gives rise to a hierarchy.

Subclasses and Superclasses A subclass is a modular, derivative class that inherits one or more properties from another class (called the superclass). The properties commonly include class data variables, properties, and methods or functions. The superclass establishes a common interface and foundational functionality, which specialized subclasses can inherit, modify, and supplement. The software inherited by a subclass is considered reused in the subclass. In some cases, a subclass may customize or redefine a method inherited from the superclass. A superclass method which can be redefined in this way is called a virtual method.

4. Polymorphism
Polymorphism means one name, many forms. Polymorphism manifests itself by having multiple methods all with the same name, but slightly different functionality.

There are 2 basic types of polymorphism. Overridding, also called run-time polymorphism. For method overloading, the compiler determines which method will be executed, and this decision is made when the code gets compiled.

Overloading, which is referred to as compile-time polymorphism. Method will be used for method overriding is determined at runtime based on the dynamic type of an object.




Advantages of an Object-Oriented Approach (for new programmers)
If you are new to OOP or to programming in general, I’ll give you a very simplified and quick assessment of approaching a new software design with object-oriented eyes.

Like structured programming in legacy systems, object-oriented programming (OOP) is used to manage the complexity of software systems. However, OOP technology provides several advantages. OOP applications are easier to maintain, have more reusable components, and are more scalable, to name a few.

Maintainable
OOP methods make code more maintainable. Identifying the source of errors becomes easier because objects are self-contained (encapsulation). The principles of good OOP design contribute to an application’s maintainability.

Reusable
Because objects contain both data and functions that act on data, objects can be thought of as self-contained “boxes” (encapsulation). This feature makes it easy to reuse code in new systems. Messages provide a predefined interface to an object’s data and functionality. If you know this interface, you can make use on an object in any context you want. OOP languages, such as C# and VB.Net, make it easy to expand on the functionality of these “boxes” (polymorphism and inheritance), even if you don’t know much about their implementation (again, encapsulation).

Scalable
OO applications are more scalable then their structured programming roots. As an object’s interface provides a roadmap for reusing the object in new software, it also provides you with all the information you need to replace the object without affecting other code. This makes it easy to replace old and aging code with faster algorithms and newer technology.

Some Disadvantages
The challenges of OOP exists mainly in the conversion of legacy systems that are built in structured programming languages. The technical challenge is not as big as the actual design challenge. The goal when converting is to minimize the effects of the stuctural systems on the OO nature of the new design, and this can sometimes be difficult.




Object-Oriented JavaScript

In this chapter, you'll learn about OOP (Object-Oriented Programming) and how it relates to JavaScript. As an ASP.NET developer, you probably have some experience working with objects, and you may even be familiar with concepts such as inheritance. However, unless you're already an experienced JavaScript programmer, you probably aren't familiar with the way JavaScript objects and functions really work. This knowledge is necessary in order to understand how the Microsoft AJAX Library works, and this chapter will teach you the necessary foundations. More specifically, you will learn:

What encapsulation, inheritance, and polymorphism
mean
How JavaScript functions work
How to use anonymous functions and closures
How to read a class diagram, and implement it using
JavaScript code
How to work with JavaScript prototypes
How the execution context and scope affect the output of
JavaScript functions
How to implement inheritance using closures and
prototypes
What JSON is, and what a JSON structure looks like
In the next chapters you'll use this theory to work effectively with the Microsoft AJAX Library.
Concepts of Object-Oriented Programming

Most ASP.NET developers are familiar with the fundamental OOP principles because this knowledge is important when developing for the .NET development. Similarly, to develop client-side code using the Microsoft AJAX Library, you need to be familiar with JavaScript's OOP features. Although not particularly difficult, understanding these features can be a bit challenging at first, because JavaScript's OOP model is different than that of languages such as C#, VB.NET, C++, or Java.

JavaScript is an object-based language. Just as in C#, you can create objects, call their methods, pass them as parameters, and so on. You could see this clearly when working with the DOM, where you manipulated the HTML document through the methods and properties of the implicit documentobject. However, JavaScript isn't generally considered a fully object- oriented language because it lacks support for some features that you'd find in "real" OOP languages, or simply implements them differently.

Your most important goal for this chapter is to understand how to work with JavaScript objects. As an ASP.NET developer, we assume that you already know how OOP works with .NET languages, although advanced knowledge isn't necessary. A tutorial written by Cristian Darie on OOP development with C# can be downloaded in PDF format.

To ensure we start off from the same square, in the following couple of pages we'll review the essential OOP concepts as they apply in C# and other languages—objects, classes, encapsulation, inheritance, and polymorphism. Then we'll continue by "porting" this knowledge into the JavaScript realm.

Objects and Classes

What does "object-oriented programming" mean anyway? Basically, as the name suggests, OOP puts objects at the cent of the programming model. The object is probably the most important concept in the world of OOP—a self-contained entity that has state and behavior, just like a real-world object. Each object is an instance of a class (also called type),

which defines the behavior that is shared by all its objects.

We often use objects and classes in our programs to represent real-world objects, and types (classes) of objects. For example, we can have classes like Car, Customer, Document, or Person, and objects such as myCar, johnsCar, or davesCar.

The concept is intuitive: the class represents the blueprint, or model, and objects are particular instances of that model. For example, all objects of type Car will have the same behavior—for example, the ability to change gear. However, each individual Car object may be in a different gear at any particular time—each object has its particular state. In programming, an object's state is described by its fields and properties, and its behavior is defined by its methods and events.

You've already worked with objects in the previous chapter. First, you've worked with the built-in documentobject. This is a default DOM object that represents the current page, and it allows you to alter the state of the page. However, you also learned how to create your own objects, when you created the xmlHttp object. In that case, xmlHttp is an object of the XMLHttpRequestclass. You could create more XMLHttpRequest objects, and all of them would have the same abilities (behavior), such as the ability to contact remote servers as you learned earlier, but each would have a different state. For example, each of them may be contacting a different server.

In OOP's world everything revolves around objects and classes, and OOP languages usually offer three specific features for manipulating them—encapsulation, inheritance, and polymorphism.




Understanding The Message Concept In OOPs

To understand object oriented programming, you will need to become familiar with messages. As the name implies, a message is a process in which software objects will communicate with one another. Because of this, having one object is not enough.

An object will work best when it is exists in a large application that is populated by other objects. When these objects interact with each other, programmers will be able to gain a high level of functionality, and the behavior of the system will be very complex. To give you an example of this, imagine that you have a motorcycle that is sitting in your garage. By itself, it is nothing but gears and metal. However, when you sit on it, turn it on, and begin riding it, both you and the motorcycle have created interaction.

The software objects that exist within a program must interact as well. They will do this by sending messages to each other. When object Z wants object R to initiate one of R's methods, object Z will transmit a signal to object R. There is a possibility that object R will not have enough information to activate the method. For example, if you want your motorcycle to slow down, you will need to "communicate" with it by pressing down on the brakes. The data that is transferred with the message is called parameters. The messages that are sent between software objects are comprised of three things. The first is the object to which the message is being sent. The second is the name of the method that is being requested. The third is the parameters that must be used with the method.

The messages use parameters to make sure the information is precise. If the receiving object does not have enough information, it will not be able to properly carry out the method. The three parts that make up a message are enough for the receiving software object to carry out the requested method. There is no other information that is needed. There are two important advantages that messages have. First, the behavior of an object will be displayed through the methods it uses. Because of this, transferring messages will allow a large number of interactions to occur between objects. Second, the objects will not have to be in the same machine in order to send or receive messages. It is also not necessary for them to be in the same process.

Encapsulation plays an important role in object oriented programming. It can be defined as concealing decisions which are related to the design of a computer program. The information that will often be hidden are things that are likely to be altered. The purpose of encapsulation is to protect the other parts of the application from changing when one piece of information is changed. To conceal a design decision, a programmer will need to build a strong interface. This interface will cover the rest of the application from any changes that are made. In contemporary programming languages, the concept of encapsulation has been used in a number of different ways.

While some people choose to use encapsulation as a general term for hiding information, others use it in a manner which is much more specific. In object oriented programming, the software module may hide the data by encapsulating it within a module which showcases an interface. It will reduce the chances of a software being damaged during its development by transferring the dependency of the code into an interface which is secure. The elements will carry out operations on the interface so that if a change occurs, it is not necessary for the clients to change as well. In most cases, the information will be hidden by concealing the layout of the data. If the layout is altered, the change will be reduced to a small portion of the program.

Information hiding is important for splitting up software, hardware, or equipment into parts that are functional. A good example of this is a car. A car is a intricate device that is split into a number of modules. Each module will have an interface which hides the decisions which are related to design. This will allow car companies to offer a number of products while maintaining a car which is cost effective to build.

History of Database Management Systems

Database management systems (DBMSs) have played an outsized role in the history of software development and the creation and growth of the software products industry. Recognizing the major role played by these products, the Annals is publishing two special issues on the subject. This special issue (the first) is focused on the products, companies, and people who designed, programmed, and sold mainframe DBMS software products beginning in the 1960s and 1970s.

Database management systems (DBMSs) have played an outsized role in the history of software development and in the creation and growth of the software products industry. Recognizing the major role played by these products, the Annals is publishing two special issues on the subject. These two issues will be the fourth and fifth sponsored by the Software Industry Special Interest Group of the Computer History Museum (formerly the Software History Center). This issue (the first) is focused on the products, companies, and people who designed, programmed, and sold mainframe DBMS software products beginning in the 1960s and 1970s. The second issue will be devoted to the relational DBMS products, which were developed during the 1970s and came to prominence (and some say dominance) during the 1980s and 1990s.

What was so important about these DBMS products? Why did they have such a major impact on the growth of the software products industry and, more importantly, on the way that almost all major commercial applications were built from the 1970s on? It is a complex story, part of which is told in this issue. Thomas Haigh begins this issue by describing the world prior to DBMSs and some of the early DBMS products. Tim Bergin and Thomas Haigh then examine the database management products that dominated the IBM environment and other major computer platforms in the 1970s and 1980s.

This issue tells the rest of the story through a series of pioneer recollections, principally from people who founded the major DBMS companies or were heavily involved in the growth and development of these products and companies. These eight recollections cover the principal DBMS software products for IBM mainframe computers. 1 IBM itself was a significant player in this marketplace with its IMS product, but all the other products were produced and marketed by independent software companies. Many historians and industry analysts believe that these products and these companies formed the foundation on which the mainframe software products industry was built.




The significance of DBMSs

In some sense, these DBMSs, with their accompanying data communications (or online transaction processing) systems, enabled users in all industries to construct both online and batch applications in a far more timely and cost effective manner. These database and data communications systems became the foundation for building many (some say most) of the core applications in every industry and government agency, and they became the engines that drove the sale of mainframe computers during the 1970s and afterward.

The following list supplies just some of the reasons why industry analysts and historians consider DBMS software products so important from both a technological and business standpoint:

• They provided an efficient way to program complex applications without the cost of rewriting the data access and retrieval functions for each application.
  
• They provided a relatively simple, standard way to share data among multiple applications and multiple users.
  
• They created specialized user-oriented languages.
  
• They provided standard interfaces for the data communications programs so that the online transaction processing applications could be efficiently built, tested, and maintained (both in time and cost).
  
• They managed the databases on various random- and sequential-access devices without the application programmer having to think about the differences.
  
• They provided portability; in many cases, they enabled customers to move their applications from one manufacturer's platform to another or from one operating system to another with relative ease.
  
• The companies marketing these products became the largest independent software products companies and were the first to go public in the late 1970s and early 1980s.
  
• They effectively sold a tremendous amount of hardware for IBM, IBM's mainframe competitors, many minicomputer manufacturers, and the independent storage device and terminal companies.
  
  

This issue only minimally refers to other related areas that some feel should be considered a vital part of the DBMS story. These DBMS products were preceded by a number of report writers, which used stored information to produce reports in the layout and form desired by the user. These report writers pioneered the definition-based applications approach versus a procedural programming approach. This category included IBM's Fargo and Report Program Generator (RPG), Informatics' Mark IV, Pansophic's Easytrieve, Cullinane's Culprit, Bill Newcomer's Dylakor, and many others. As the Bergin and Haigh article notes, almost every DBMS had its own report writer or could interface to one of the available products.

A second area that was of at least equal significance to report writers were the fourth generation languages (4GLs), which had a user-specified layout mapping the inputs and transformations to the outputs, but each of these products had its own proprietary database within the program. These software products were successful over many years and are still in use today. Ramis, Focus, and Nomad were among the early leaders, and they were followed by many more such application development software products that were introduced in the 1980s. These gave run-of-the-mill users the ability to specify and "program" their own applications without having to wait for the professional programmers.




Database management system type and characteristics

Database management is an integral part of every company that is organized and managed the data is found. Database server and desktop database are two types of database management systems.

Although primarily a multi-user database server applications and data consistency is the most reliable. It is more expensive than desktop database and operates on a high performance server.

Choose a web site database design before the end blindly in the analysis and research required, must dip.Also, many times for server-based database needs are emerging.

Database that would be best to analyze the needs of companies, some points should be clarified.Database and using it will be in charge of the relevant authority should be known. In addition, data and IT resources that will assist the person responsible for maintenance should be aware. Make sure the hardware available and the budget to buy hardware.

Important issues that you evaluate the implementation of specific database management system can start after cleaning.Requirements for simple desktop database like Microsoft Access is the right choice. It’s cheap and a simple data storage and manipulation facilities offers. As the name suggests, it runs on a personal computer and is best for them. Microsoft Access, Lotus, FileMaker Pro, in addition, FoxPro and contradiction are some popular desktop database software.

Oracle, Microsoft SQL Server and IBM DB 2 is a popular database servers. The amount of data effectively manage large enough to provide expertise, and users can access to data when needed.

A structure and a solid foundation for future corporate success plan for providing such a database design. If you plan accordingly to improve performance and future development can.




Component Database Management Systems

OLE DB uses the Component Object Model (COM) infrastructure, which reduces unnecessary duplication of services and provides a higher degree of interoperability, not only among diverse information sources but also among existing programming environments and tools. Indeed, OLE DB is the way to access data in a COM environment. OLE DB defines an open, extensible collection of COM interfaces that encapsulate reusable portions of DBMS functionality. These interfaces define the boundaries of DBMS components, such as row containers, query processors, and transaction coordinators, that provide uniform transactional access to diverse information sources. Such components factor a DBMS into a set of cooperating components that consume and produce data through a uniform set of interfaces.

The OLE DB functional areas include data access and updates (rowsets), query processing, catalog information, notifications, transactions, security, and remote data access. By defining a uniform set of interfaces to access data, OLE DB components not only contribute to uniform data access among diverse information sources but also help reduce the application's complexity by enabling developers to use only the DBMS functionality they need. The following illustration shows how an application can employ OLE DB interfaces to initiate actions by a query processor to access different data structures.

A component DBMS architecture using OLE DB interfaces

The sections that follow go into these concepts in detail.




Components of a DBMS

Database Management System (DBMS)

DBMSs are the technology tools that directly support managing organizational data. With a DBMS you can create a database including its logical structure and constraints, you can manipulate the data and information it contains, or you can directly create a simple database application or reporting tool. Human administrators, through a user interface, perform certain tasks with the tool such as creating a database, converting an existing database, or archiving a large and growing database. Business applications, which perform the higher level tasks of managing business processes, interact with end users and other applications and, to store and manage data, rely on and directly operate their own underlying database through a standard programming interface like ODBC.

The following diagram illustrates the five components of a DBMS.

Database Engine:

The Database Engine is the core service for storing, processing, and securing data. The Database Engine provides controlled access and rapid transaction processing to meet the requirements of the most demanding data consuming applications within your enterprise.Use the Database Engine to create relational databases for online transaction processing or online analytical processing data. This includes creating tables for storing data, and database objects such as indexes, views, and stored procedures for viewing, managing, and securing data. You can use SQL Server Management Studio to manage the database objects, and SQL Server Profiler for capturing server events.

Data dictionary:

A data dictionary is a reserved space within a database which is used to store information about the database itself. A data dictionary is a set of table and views which can only be read and never altered.Most data dictionaries contain different information about the data used in the enterprise. In terms of the database representation of the data, the data table defines all schema objects including views, tables, clusters, indexes, sequences, synonyms, procedures, packages, functions, triggers and many more. This will ensure that all these things follow one standard defined in the dictionary. The data dictionary also defines how much space has been allocated for and / or currently in used by all the schema objects.A data dictionary is used when finding information about users, objects, schema and storage structures. Every time a data definition language (DDL) statement is issued, the data dictionary becomes modified.

A data dictionary may contain information such as:

• Database design information
  
• Stored SQL procedures
  
• User permissions
  
• User statistics
  
• Database process information
  
• Database growth statistics
  
• Database performance statistics
  
  

Query Processor :

A relational database consists of many parts, but at its heart are two major components: the storage engine and the query processor. The storage engine writes data to and reads data from the disk. It manages records, controls concurrency, and maintains log files.The query processor accepts SQL syntax, selects a plan for executing the syntax, and then executes the chosen plan. The user or program interacts with the query processor, and the query processor in turn interacts with the storage engine. The query processor isolates the user from the details of execution: The user specifies the result, and the query processor determines how this result is obtained. The query processor components include

• DDL interpreter
  
• DML compiler
  
• Query evaluation engine
  
  

Report writer:

Also called a report generator, a program, usually part of a database management system, that extracts information from one or more files and presents the information in a specified format. Most report writers allow you to select records that meet certain conditions and to display selected fields in rows and columns. You can also format data into pie charts, bar charts, and other diagrams. Once you have created a format for a report, you can save the format specifications in a file and continue reusing it for new data.

All About Java

The Java Programming Language

Java, the language, is a high-level object-oriented programming language, influenced in various ways by C, C++, and Smalltalk, with ideas borrowed from other languages as well (see O'Reilly's History of Programming Languages). Its syntax was designed to be familiar to those familiar with C-descended "curly brace" languages, but with arguably stronger OO principles than those found in C++, static typing of objects, and a fairly rigid system of exceptions that require every method in the call stack to either handle exceptions or declare their ability to throw them. Garbage collection is assumed, sparing the developer from having to free memory used by obsolete objects.

One of Java's more controversial aspects--widely accepted at the time of its release but increasingly criticized today--is its incomplete object-orientation. Specifically, Java primitives such as int, char, boolean, etc. are not objects, and require a completely different treatment from the developer: as int is not a class, you cannot subclass and declare new methods on it, cannot pass it to a method that expects a generic Object, and so on. The inclusion of primitives increases Java performance, but at the arguable expense of code clarity, as anyone who's had to work with the so-called "wrapper classes" (Integer, Character, and Boolean) will attest. Java 5.0 introduces an "autoboxing" scheme to eliminate many uses of the wrapper classes, but in some ways it obscures what is really going on.

Philosophically, Java is a "fail early" language. Because of its syntactic restrictions, many programming failures are simply not possible in Java. With no direct access to pointers, pointer-arithmetic errors are non-existent. Using an object as a different type than what it was originally declared to be requires an explicit cast, which gives the compiler an opportunity to reject illogical programming, like calling a String method on an Image.

Many Java enterprise frameworks require the use of configuration files or deployment descriptors, typically written in XML, to specify functionality: what class handles a certain HTTP request, the order of steps to execute in a rule engine, etc. In effect, they have to go beyond the language to implement their functionality. Critics point out that this has the perverse effect of not only escaping Java's compiler checks, but also that a developer can no longer determine how a program will operate just by looking at its source code. Java 5.0 adds annotations to the language, which allows the tagging of methods, fields, and classes with values that can then be inspected and operated on at runtime, usually through reflection. Many programmers like annotations because they simplify tasks that might otherwise be addressed by deployment descriptors or other means. But again, they can make it difficult to understand Java code, as the presence or absence of an annotation may affect how the code is executed, in ways that are in no way obvious from the annotation.

Despite these criticisms, Java is generally understood to be the most popular general-purpose computing language in use today. It is a widely used standard in enterprise programming, and in 2005, it replaced C++ as the language most used by projects on SourceForge. What it has going for it is immense: free tools (on multiple platforms: Linux, Windows, Solaris, and Mac can all compile and execute Java apps), a vast base of knowledge, and a large pool of readily available developers.

The Java language hits a specific point in the tradeoff between developer productivity and code performance: CPU cycles keep getting cheaper, developers largely don't, so it is perhaps inevitable to accept another layer of abstraction between the developer and the execution of CPU opcodes, if it allows the developer to create better software faster. In fact, critics of Java's productivity, such as Bruce Tate in Beyond Java, may simply be observing this trend continuing past Java to a new sweet spot that further trades performance for developer productivity.

Java Security Exploit

A term that refers to any number of security exploits in Oracle's Java software, which has a long history of being vulnerable to security flaws. The most recent Java Security Exploit appeared in early 2013, and affected all versions of Java up to Java 7 Update 10.

This zero-day security vulnerability, referenced as CVE-2013-0422 by the CVE, carried a payload of malware that could result in identity theft as well as rendering the host machine an unauthorized botnet that could then be used in denial-of-service (DoS) attacks against other machines.

Oracle periodically releases software patches developed to address Java security exploits, and it released one as Java 7 Update 11 two days after the most recent vulnerability was discovered. Only days after that patch debuted, a new zero-day Java security exploit was publicized and marketed by crimeware sites for $5,000.




Top Ten Things Every Java Programmer Should Know

These are in no particular order, but these are things that all Java programmers should probably know.

Who Invented Java, and when?

James Gosling, at Sun Labs, around 1992; the group was building a set-top box and started by "cleaning up" C++ and wound up with a new language and runtime.

What does Java stand for?

Java is not an acronym (not even Just Another Vague Acronym :-)). The language was first named Oak, after the tree outside James' window. The lawyers found another language called Oak so, legend has it, the gang went out to the local cafe to discuss names and wound up naming it after the beverage Java (which is in turn named after the island of Java). Possible confirmation of this theory.

What is the JLS?

JLS is The Java Language Specification. Every developer should buy or download (free) this specification and read it, a bit at a time.

How do changes get into Java?

JCP (Java Community Process).

Why is there no printf-like function in Java?

Actually there are! This was fixed in Java 5; see Java Cookbook (2nd Edition) Chapter 9. Java 5 (J2SE 1.5) includes printf (and scanf), String.format(), and lots more.

What is the GOF book?

The Gang Of Four book is entitled Design Patterns, by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides. This is a very good book. You should read it. Not when you're just learning Java, but when you've let it sink in for about six months.

What other Java book do I need?

Most of the O'Reilly Java books. Effective Java, by Joshua Bloch Java Developer's Almanac My Java Cookbook (see below)

What is the Java Cookbook?

That's my own book of Java recipes (for the programming language, not the coffee, but some bookstores still wind up listing it under Cooking).

What other Java sites do I need to know about?

java.sun.com, Sun's main technology site
java.net, a collaborative site (run by Sun)
java.com, an advocacy/news site (run by Sun)
developer.java.sun.com, Sun's main developer site
www.javalobby.org, independent advocacy group
www.javaworld.com, Java news
www.theserverside.com, Java Review
http://www.darwinsys.com/java/, my own Java site

What else do I need to know?

Everything! But nobody can know everything about Java - the subject is now too vast. Imagine somebody saying that they know everything about every single Microsoft product and technology. If someone like that calls me, I'm always out.




Features of Java Programming, New Features of Java Language, Advanced Java Features with Examples

Features of Java Language

Java have so many features which are as -

Java is Simple
There are various features that makes the java as a simple language. because Java is easy to learn and developed by taking the best features from other languages mainly like C and C++. It is very easy to learn Java who have knowledge of object oriented programming concepts. Java provides the error free development environment for programmer because it provide automatic memory management by development environment and eliminate pointers.

Java is Platform Independent- Java provides the facility to "Write once -Run any where"(Known as plateform independent). Not even a single language is idle to this feature but java is more closer to this feature. Java Provide the facility of cross-plateform programs by compiling in intermediate code known as bytecode. this bytecode can be interpreted on any system which have Java Virtual Machine(JVM).

Java is Object-oriented- The object oriented language must support the characterstics of the OOPs. and Java is a fully object oriented language . it supports all the characterstics needed to be object oriented. In the Java every thing is treated as objects to which methods are applied.As the languages like Objective C, C++ fulfills the above four characteristics yet they are not fully object oriented languages because they are structured as well as object oriented languages. But in case of java, it is a fully Object Oriented language because object is at the outer most level of data structure in java. No stand alone methods, constants, and variables are there in java. Everything in java is object even the primitive datatypes can also be converted into object by using the wrapper class.

Java is Distributed- The widely used protocols like HTTP and FTP are developed in java. Internet programmers can call functions on these protocols and can get access the files from any remote machine on the internet rather than writing codes on their local system. Java is Secure- Java does not use memory pointers explicitly. All the programs in java are run under an area known as the sand box. Security manager determines the accessibility options of a class like reading and writing a file to the local disk. Java uses the public key encryption system to allow the java applications to transmit over the internet in the secure encrypted form. The bytecode Verifier checks the classes after loading.

No memory pointers
Programs runs inside the virtual machine sandbox.
Array index limit checking
bytecode verifier - checks classes after loading

class loader - confines objects to unique namespaces. Prevents loading a hacked "java.lang.SecurityManager" class, for example.

security manager - determines what resources a class can access such as reading and writing to the local disk.

Java is compiled and interpreted- We all know that in Java code is compiled to bytecodes that are interpreted by Java virtual machines (JVM) . This provides portability to any machine for which a virtual machine has been written. The interpreter program reads the source code and translates it on the fly into computations.The two steps of compilation and interpretation allow for extensive code checking and improved security.

Java is Robust- Java has the strong memory allocation and automatic garbage collection mechanism. It carries out type checking at both compile and runtime making sure that every data structure has been clearly defined and typed. compiler checks the program for any error and interpreter checks any run time error that every data structure is clearly defined and typed. Java manages the memory automatically by using an automatic garbage collector. all the above features makes Java language robust.

Java is Portable- The feature of java "write once -run any where" make java portable. Many type of computers and operating systems are used for programs By porting an interpreter for the Java Virtual Machine to any computer hardware/operating system, one is assured that all code compiled for it will run on that system. This forms the basis for Java's portability.

Java Compared with Other Languages

Java is a relatively new language, but it draws on many years of programming experience with other languages in its choice of features. It is worth taking a moment to compare Java at a high level with some other popular languages today, both for the benefit of those of you with other programming experience and for the newcomers who need to put things in context. We do not expect you to have a knowledge of any particular programming language in this book and when we refer to other languages by way of comparison we hope that the comments are selfexplanatory.

At least three pillars are necessary to support a universal programming language today: portability, speed, and security. Figure 1-2 shows how Java compares to a couple of other languages.

You may have heard that Java is a lot like C or C++, but that's really not true, except at a superficial level. When you first look at Java code, you'll see that the basic syntax looks like C or C++. But that's where the similarities end. Java is by no means a direct descendant of C or a next-generation C++. If you compare language features, you'll see that Java actually has more in common with highly dynamic languages such as Smalltalk and Lisp. In fact, Java's implementation is about as far from native C as you can imagine.

The surface-level similarities to these languages are worth noting, however. Java borrows heavily from C and C++ syntax, so you'll see terse language constructs, including an abundance of curly braces and semicolons. Java subscribes to the C philosophy that a good language should be compact; in other words, it should be sufficiently small and regular so a programmer can hold all the language's capabilities in his or her head at once. Just as C is extensible with libraries, packages of Java classes can be added to the core language components to extend its vocabulary.

C has been successful because it provides a reasonably feature-packed programming environment, with high performance and an acceptable degree of portability. Java also tries to balance functionality, speed, and portability, but it does so in a very different way. C trades functionality for portability; Java initially traded speed for portability. Java also addresses security issues while C doesn't.

In the early days before JIT and adaptive compilation, Java was slower than statically compiled languages and there was a constant refrain from detractors that it would never catch up. But as we described in the previous section, Java's performance is now comparable to C or C++ for equivalent tasks and those criticisms have generally fallen quiet. In fact, in 2004, ID Software's open source Quake2 video game engine was ported to Java. If Java is fast enough for firstperson- shooter video games, it's certainly fast enough for business applications.

Scripting languages, such as Perl, Python, and Ruby, are very popular, and for good reason. There's no reason a scripting language can't be suitable for safe, networked applications. But most scripting languages are not designed for serious, large-scale programming. The attraction to scripting languages is that they are dynamic; they are powerful tools for rapid development. Some scripting languages such as Perl also provide powerful tools for text-processing tasks that more general-purpose languages find unwieldy. Scripting languages are also highly portable, albeit at the source-code level.

Not to be confused with Java, JavaScript is an object-based scripting language originally developed by Netscape for the web browser. It serves as a glue and an "in the document" language for dynamic, interactive HTML-based applications. JavaScript takes its name from its intended integration with Java applets and some similarity in syntax, but the comparison really ends there. While there have been applications of JavaScript outside of the browser, it has never really caught on as a general scripting language. For more information on JavaScript, check out JavaScript: The Definitive Guide by David Flanagan (O'Reilly).

The problem with scripting languages is that they are rather casual about program structure and data typing. Most scripting languages (with a hesitant exception for Python and later versions of Perl) are not object-oriented. They also have vastly simplified type systems and generally don't provide for sophisticated scoping of variables and functions. These characteristics make them unsuitable for building large, modular applications. Speed is another problem with scripting languages; the high-level, fully interpreted nature of these languages often makes them quite slow.

Advocates of individual scripting languages would take issue with some of these generalizations and no doubt they'd be right in some casesscripting languages are growing up. But the fundamental tradeoff is undeniable: scripting languages were born as loose, less structured alternatives to systems programming languages and are generally not as suitable for large or complex projects for a variety of reasons, at least not today.

Java offers some of the essential advantages of a scripting language (it is highly dynamic), along with the added benefits of a lower-level language. Java 1.4 added a powerful Regular Expression API that competes with Perl for working with text and Java 5.0 has introduced new language features that streamline coding, such as "foreach"-style iteration over collections, variable argument lists, autoboxing and unboxing of primitives, and static imports of methods. Incremental development with object-oriented components, combined with Java's simplicity, make it possible to develop applications rapidly and change them easily. Studies have found that development in Java is faster than in C or C++, strictly based on language features.[*] Java also comes with a large base of standard core classes for common tasks such as building GUIs and handling network communications. But along with these features, Java has the scalability and software-engineering advantages of more static languages. It provides a safe structure on which to build higher-level frameworks (and even other languages).

As we've already said, Java is similar in design to languages such as Smalltalk and Lisp. However, these languages are currently used mostly as research vehicles rather than for development of large-scale systems. One reason is that these languages never developed a standard portable binding to operating-system services, such as the C standard library or the Java core classes. Smalltalk is compiled to an interpreted bytecode format, and it can be dynamically compiled to native code on the fly, just like Java. But Java improves on the design by using a bytecode verifier to ensure the correctness of compiled Java code. This verifier gives Java a performance advantage over Smalltalk because Java code requires fewer runtime checks. Java's bytecode verifier also helps with security issues, something that Smalltalk doesn't address. Smalltalk is a mature language, though, and Java's designers took lessons from many of its features.

Throughout the rest of this chapter, we'll present a bird's-eye view of the Java language. We'll explain what's new and what's not-so-new about Java and why.

History

The History Of Microsoft

Microsoft was formed by a Harvard College Dropout called Bill Gates. Bill Gates was born William Henry Gates III on October 28, 1955. He was born to a family that was successful in business, living a comfortable upper middle class life in Seattle, Washington.
Early in his elementary school days, Bill Gates quickly shot to the head of the class, consistently outscoring his peers in most subjects, but especially math and science. His parents soon enrolled him in Lakeside Prep School, where the atmosphere was intellectual enough to stimulate the young Gates. This move to Lakeside would prove historic, for it was here, in the spring of 1968, that he was introduced to computers.

At that time, computers were still too large and expensive for the school to purchase one of its own. Over the next ten months or so, the school struck agreements with various corporations who allowed the students to use their computers. Bill Gates, his buddy Paul Allen and a handful of others quickly took to computing. In fact, they began to skip classes, opting instead to stay in the computer room and write programs, read computer books and find out exactly how these machines worked. They soon learned to hack the system, and altered and crashed valuable files until they were banned from the computer. Soon, however, Bill and his friends were actually hired by the computer company to find bugs and explore weaknesses in the system, which kept causing the computers to crash. Instead of paying the boys for their time, they were granted something even better--unlimited computer time.

Gates has been quoted as saying that that was the time when he got into computers fulltime. "I mean, then I became hardcore. It was day and night," he said. The boys used their time eating, drinking and breathing computers. They studied manuals, explored the system, and hounded the employees with questions until they had formed a base of knowledge that would eventually lead to the formation of Microsoft.

The computer company that was hiring the group went out of business in 1970, and the boys had to find alternate sources for computer time. They were soon hired by Information Sciences Inc. to write a program for payroll. This time they actually earned money as well as enjoying the unlimited computer time. It was during this time that the group gained notoriety for their skill in computer programming. They were hired or contracted by various organizations to find bugs and fix them. Each job helped Gates and his friends learn their skill and delve ever deeper into the world of programming.

In the fall of 1973, Gates left for Harvard University. He enrolled as a prelaw student, but spent most of his time in the campus computer center, programming away. He stayed in touch with Paul Allen and they continued to talk about future projects and the possibility of one day having their very own business. Allen even moved to Boston to be closer to Gates, so they could continue working on projects. Allen continually urged Gates to quit school and work with him full-time, and Gates was unsure of what he wanted to do. This was soon to change.

One year later, Paul Allen saw the first microcomputer on the cover of a magazine. He bought the magazine and went immediately to show it to Gates. They realized the time was right. The home PC business was about to explode and someone would need to provide software for the machines. By stretching the truth somewhat, Gates arranged for a meeting with the Altair manufacturers. He had called them to let them know he had a program written for them. After the appointment was made, Gates and Allen stayed up for nights, feverishly writing the program he had promised. It worked perfectly at the meeting, and everyone was impressed. They sold the program, and saw that this was something they could do for real. Within a year, Gates had dropped out of Harvard and Microsoft was formed.

The company went through some rough first years, but eventually were able to license MS-DOS to IBM. The IBM PC took the public by storm, and its success signaled the success of Microsoft. Microsoft continued writing software, for businesses as well as the consumer market. In 1986, the company went public, and Gates became a 31-year old billionaire. The next year, the first version of Windows was introduced, and by 1993 a million copies per month were being sold.

In 1995, Gates knew that the Internet was the next area of focus, and the course of Microsoft shifted dramatically. The popular Internet Explorer browser soon became a bestseller. Today, Microsoft software is everywhere.




The History of Microsoft Operating Systems

Microsoft Windows is a family of operating systems for personal computers. In this article we look at the history of Microsoft operating systems from 1985 to present day.

Microsoft Windows is a family of operating systems for personal computers. Windows dominates the personal computer world, running, by some estimates, on more than 90 percent of all personal computers – the remainder running Linux and Mac operating systems. Windows provides a graphical user interface (GUI), virtual memory management, multitasking, and support for many peripheral devices.

Microsoft Operating Systems for Personal Computers
The following details the history of Microsoft operating systems designed for personal computers (PCs).
Key definitions to know: operating system, computer, Microsoft, Microsoft Windows.

MS-DOS (Microsoft disk operating system)
Originally developed by Microsoft for IBM, MS-DOS was the standard operating system for IBM-compatible personal computers. The initial versions of DOS were very simple and resembled another operating system called CP/M. Subsequent versions have become increasingly sophisticated as they incorporated features of minicomputer operating systems.

Windows 1.0 – 2.0 (1985-1992)
Introduced in 1985, Microsoft Windows 1.0 was named due to the computing boxes, or "windows" that represented a fundamental aspect of the operating system. Instead of typing MS-DOS commands, windows 1.0 allowed users to point and click to access the windows.

In 1987 Microsoft released Windows 2.0, which was designed for the designed for the Intel 286 processor. This version added desktop icons, keyboard shortcuts and improved graphics support.

Windows 3.0 – 3.1 (1990–1994)
Microsoft released Windows 3.0 in May, 1900 offering better icons, performance and advanced graphics with 16 colors designed for Intel 386 processors. This version is the first release that provides the standard "look and feel" of Microsoft Windows for many years to come. Windows 3.0 included Program Manager, File Manager and Print Manager and games (Hearts, Minesweeper and Solitaire). Microsoft released Windows 3.1 in 1992.

Windows 95 (August 1995)
A major release of the Microsoft Windows operating system released in 1995. Windows 95 represents a significant advance over its precursor, Windows 3.1. In addition to sporting a new user interface, Windows 95 also includes a number of important internal improvements. Perhaps most important, it supports 32-bit applications, which means that applications written specifically for this operating system should run much faster.

Although Windows 95 can run older Windows and DOS applications, it has essentially removed DOS as the underlying platform. This has meant removal of many of the old DOS limitations, such as 640K of main memory and 8-character filenames. Other important features in this operating system are the ability to automatically detect and configure installed hardware (plug and play).

Windows 98 (June 1998)
Windows 98 offers support for a number of new technologies, including FAT32, AGP, MMX, USB, DVD, and ACPI. Its most visible feature, though, is the Active Desktop, which integrates the Web browser (Internet Explorer) with the operating system. From the user's point of view, there is no difference between accessing a document residing locally on the user's hard disk or on a Web server halfway around the world.

Windows ME - Millennium Edition (September 2000)
The Windows Millennium Edition, called "Windows Me" was an update to the Windows 98 core and included some features of the Windows 2000 operating system. This version also removed the "boot in DOS" option.

Windows NT 31. - 4.0 (1993-1996)
A version of the Windows operating system. Windows NT (New Technology) is a 32-bit operating system that supports preemptive multitasking. There are actually two versions of Windows NT: Windows NT Server, designed to act as a server in networks, and Windows NT Workstation for stand-alone or client workstations.

Windows 2000 (February 2000)
Often abbreviated as "W2K," Windows 2000 is an operating system for business desktop and laptop systems to run software applications, connect to Internet and intranet sites, and access files, printers, and network resources. Microsoft released four versions of Windows 2000: Professional (for business desktop and laptop systems), Server (both a Web server and an office server), Advanced Server (for line-of-business applications) and Datacenter Server (for high-traffic computer networks).

Windows XP (October 2001)
Windows XP was first introduced in 2001. Along with a redesigned look and feel to the user interface, the new operating system is built on the Windows 2000 kernel, giving the user a more stable and reliable environment than previous versions of Windows. Windows XP comes in two versions, Home and Professional. Microsoft focused on mobility for both editions, including plug and play features for connecting to wireless networks. The operating system also utilizes the 802.11x wireless security standard. Windows XP is one of Microsoft's best-selling products.

Windows Vista (November 2006)
Windows Vista offered an advancement in reliability, security, ease of deployment, performance and manageability over Windows XP. New in this version was capabilities to detect hardware problems before they occur, security features to protect against the latest generation of threats, faster start-up time and low power consumption of the new sleep state. In many cases, Windows Vista is noticeably more responsive than Windows XP on identical hardware. Windows Vista simplifies and centralizes desktop configuration management, reducing the cost of keeping systems updated.

Windows 7 (October, 2009)
Windows 7 made its official debut to the public on October 22, 2009 as the latest in the 25-year-old line of Microsoft Windows operating systems and as the successor to Windows Vista (which itself had followed Windows XP). Windows 7 was released in conjunction with Windows Server 2008 R2, Windows 7's server counterpart. Enhancements and new features in Windows 7 include multi-touch support, Internet Explorer 8, improved performance and start-up time, Aero Snap, Aero Shake, support for virtual hard disks, a new and improved Windows Media Center, and improved security.

Windows 8 (Codename, Expected Release 2012)
Windows 8 is a completely redesigned operating system that's been developed from the ground up with touchscreen use in mind as well as near-instant-on capabilities that enable a Windows 8 PC to load and start up in a matter of seconds rather than in minutes. Windows 8 will replace the more traditional Microsoft Windows OS look and feel with a new "Metro" design system interface that first debuted in the Windows Phone 7 mobile operating system. The Metro user interface primarily consists of a "Start screen" made up of "Live Tiles," which are links to applications and features that are dynamic and update in real time. Windows 8 supports both x86 PCs and ARM processors. Online media sites indicate that this version will be available in 2012, with October and Fall being the most often quoted time frame.

Microsoft Operating Systems for Servers and Mobile Devices
Aside from operating systems designed for use on personal computers (PCs) and laptops, Microsoft has also developed operating systems for services, handheld devices, and mobile phones.

Key definitions to know: server, mobile operating system, handheld device, Microsoft.

Windows Server (March 2003)
Windows Server is a series of Microsoft server operating systems. Windows servers are more powerful versions of their desktop operating system counterparts and are designed to more efficiently handle corporate networking, Internet/intranet hosting, databases, enterprise-scale messaging and similar functions. The Windows Server name made its debut with the release of Windows Server 2003 and continues with the current release, Windows Server 2008 R2, which shares its codebase with Windows 7. Windows Server 2008 R2 debuted in October 2009.

Windows Home Server ( January 2007)
Announced in January 2007, Windows Home Server (WHS) is a "consumer server" designed to use with multiple computers connected in the home. Home Server allows you to share files such as digital photos and media files, and also allows you to automatically backup your home networked computers. Through Windows Media Connect, Windows Home Server lets you share any media located on your WHS with compatible devices.

Windows CE (November 2006)
A version of the Windows operating system designed for small devices such as personal digital assistants (PDAs) (or Handheld PCs in the Microsoft vernacular). The Windows CE graphical user interface (GUI) is very similar to Windows 95 so devices running Windows CE should be easy to operate for anyone familiar with Windows 95.

Windows Mobile (April 2000)
A mobile operating system for smartphones and mobile devices from Microsoft based on the Windows CE kernel and designed to look and operate similar to desktop versions of Microsoft Windows. Windows Mobile has largely been supplanted by Windows Phone 7, although Microsoft did release, in 2011, Windows Embedded Handheld 6.5, a mobile OS compatible with Windows Mobile 6.5 that's designed for enterprise mobile and handheld computing devices.

Windows Phone (November 2010)
A mobile operating system for smartphones and mobile devices that serves as the successor to Microsoft's initial mobile OS platform system, Windows Mobile. Unlike Windows Mobile, Windows Phone 7 (also referred to as WinPhone7) is targeted more to the consumer market than the enterprise market, and it replaces the more traditional Microsoft Windows OS look and feel with a new "Metro" design system user interface. Windows Phone 7 features a multi-tab Internet Explorer Mobile Web browser that uses a rendering engine based on Internet Explorer 9 as well Microsoft Office Mobile, a version of Microsoft Office that’s tailored for mobile devices.




How Operating Systems Work

When you turn on your computer, it's nice to think that you're in control. There's the trusty computer mouse, which you can move anywhere on the screen, summoning up your music library or Internet browser at the slightest whim. Although it's easy to feel like a director in front of your desktop or laptop there's a lot going on inside, and the real man behind the curtain handling the necessary tasks is the operating system.

­Most desktop or laptop PCs come pre-loaded with Microsoft Windows. Macintosh computers come pre-loaded with Mac OS X. Many corporate servers use the Linux or UNIX operating systems. The operating system (OS) is the first thing loaded onto the computer -- without the operating system, a computer is useless.

­­­More recently, operating systems have started to pop up in smaller computers as well. If you like to tinker with electronic devices, you're probably pleased that operating systems can now be found on many of the devices we use every day, from cell phones to wireless access points. The computers used in these little devices have gotten so powerful that they can now actually run an operating system and applications. The computer in a typical modern cell phone is now more powerful than a desktop computer from 20 years ago, so this progression makes sense and is a natural development.

The purpose of an operating system is to organize and control hardware and software so that the device it lives in behaves in a flexible but predictable way. In this article, we'll tell you what a piece of software must do to be called an operating system, show you how the operating system in your desktop computer works and give you some examples of how to take control of the other operating systems around you.




Operating System Functions

At the simplest level, an operating system does two things:

It manages the hardware and software resources of the system. In a desktop computer, these resources include such things as the processor, memory, disk space and more (On a cell phone,they include the keypad, the screen, the address book, the phone dialer, the battery and the network connection).

It provides a stable, consistent way for applications to deal with the hardware without having to know all the details of the hardware.

The first task, managing the hardware and software resources, is very important, as various programs and input methods compete for the attention of the central processing unit (CPU) and demand memory, storage and input/output (I/O) bandwidth for their own purposes. In this capacity, the operating system plays the role of the good parent, making sure that each application gets the necessary resources while playing nicely with all the other applications, as well as husbanding the limited capacity of the system to the greatest good of all the users and applications.

­ The second task, providing a consistent application interface, is especially important if there is to be more than one of a particular type of computer using the operating system, or if the hardware making up the computer is ever open to change. A consistent application program interface (API) allows a software developer to write an application on one computer and have a high level of confidence that it will run on another computer of the same type, even if the amount of memory or the quantity of storage is different on the two machines.

Even if a particular computer is unique, an operating system can ensure that applications continue to run when hardware upgrades and updates occur. This is because the operating system -- not the application -- is charged with managing the hardware and the distribution of its resources. One of the challenges facing developers is keeping their operating systems flexible enough to run hardware from the thousands of vendors manufacturing computer equipment. Today's systems can accommodate thousands of different printers, disk drives and special peripherals in any possible combination.




Types of Operating Systems
Within the broad family of operating systems, there are generally four types, categorized based on the types of computers they control and the sort of applications they support. The categories are:

Real-time operating system (RTOS) - Real-time operating systems are used to control machinery, scientific instruments and industrial systems. An RTOS typically has very little user-interface capability, and no end-user utilities, since the system will be a "sealed box" when delivered for use. A very important part of an RTOS is managing the resources of the computer so that a particular operation executes in precisely the same amount of time, every time it occurs. In a complex machine, having a part move more quickly just because system resources are available may be just as catastrophic as having it not move at all because the system is busy.

Single-user, single task - As the name implies, this operating system is designed to manage the computer so that one user can effectively do one thing at a time. The Palm OS for Palm handheld computers is a good example of a modern single-user, single-task operating system.

Single-user, multi-tasking - This is the type of operating system most people use on their desktop and laptop computers today. Microsoft's Windows and Apple's MacOS platforms are both examples of operating systems that will let a single user have several programs in operation at the same time. For example, it's entirely possible for a Windows user to be writing a note in a word processor while downloading a file from the Internet while printing the text of an e-mail message.

Multi-user - A multi-user operating system allows many different users to take advantage of the computer's resources simultaneously. The operating system must make sure that the requirements of the various users are balanced, and that each of the programs they are using has sufficient and separate resources so that a problem with one user doesn't affect the entire community of users. Unix, VMS and mainframe operating systems, such as MVS, are examples of multi-user operating systems.

It's important to differentiate between multi-user operating systems and single-user operating systems that support networking. Windows 2000 and Novell Netware can each support hundreds or thousands of networked users, but the operating systems themselves aren't true multi-user operating systems. The system administrator is the only "user" for Windows 2000 or Netware. The network support and all of the remote user logins the network enables are, in the overall plan of the operating system, a program being run by the administrative user.

With the different types of operating systems in mind, it's time to look at the basic functions provided by an operating system.