Home About us Products Services Contact us Bookmark
:: wikimiki.org ::
Computer Science

Computer science

Computer science, an academic discipline (abbreviated CS or compsci), is a body of knowledge generally about computer hardware, software, computation and its theory. The discipline itself includes, but is not limited to, the fundamentals of computer languages, operating systems and mathematical foundations of computer science. The study of these fundamentals may lead to a wide variety of topics, such as algorithms, formal grammars, programming languages, program design, artificial intelligence and computer engineering. There exist a number of technical definitions of computer science. The status of computer science as a science is often challenged, typically arguing that it is more like mathematics and that it does not follow the scientific method, however these facts are not unanimously accepted. In popular language, the term computer science is often confusingly used to denominate anything related to computers.

History of computer science

Evolutionary

Before the 1920s, computers were human clerks that performed calculations. They were usually under the lead of a physicist. Many thousands of computers were employed in commerce, government, and research establishments. Most of these computers were women, and they were known to have a degree in calculus. After the 1920s, the expression computing machine refered to any machine that performed the work of a human computer, especially those in accordance with effective methods of The Church-Turing Thesis. The thesis states that a mathematical method is effective if it could be set out as a list of instructions able to be followed by a human clerk with paper and pencil, for as long as necessary, and without ingenuity or insight. Machines that computed with discrete values became known as the analog kind. They used machinery that represented discrete numeric quantities, like the angle of a shaft rotation or difference in electrical potential. Digital machinery, in contrast to analog, were able to render a state of a numeric value and store each individual digit. Digital machinery used difference engines or relays before the invention of faster memory devices. The phrase computing machine gradually gave away, after the late 1940s, to just computer as the onset of electronic digital machinery became common. These computers were able to perform the calculations that were performed by the previous human clerks. Since the values stored by digital machines were not bound to physical properties like the analog device, a logical computer, based on digital equipment, was able to do anything that could be described "purely mechanical." Alan Turing, known as the Father of Computer Science, invented such a logical computer, also known as a Turing Machine, that evolved into the modern computer from the tasks performed by the previous human clerks. These new computers were also able to perform non-numeric computations, like music. Computability, by logical computers, began a science by being able to make evident which was not explicitly defined into ordinary sense more immediate.

Academic discipline

Computer science has roots in electrical engineering, logic, mathematics, and linguistics. In the last third of the 20th century computer science emerged as a distinct discipline and developed its own methods and terminology. Originally, CS was taught as part of mathematics or engineering departments, for instance at the University of Cambridge in England and at the Gdansk University of Technology in Poland, respectively. Cambridge claims to have the world's oldest taught qualification in computing. The first computer science department in the United States was founded at Purdue University in 1962, while the first college entirely devoted to computer science was founded at Northeastern University in 1982. Most universities today have specific departments devoted to computer science, while some conjoin it with engineering, with applied mathematics, or other disciplines. Most research in computer science has focused on von Neumann computers or Turing machines (computation models that perform one small, deterministic step at a time). These models resemble, at a basic level, most real computers in use today. Computer scientists also study other models of computation, which includes parallel machines and theoretical models such as probabilistic, oracle, and quantum computers.

Careers

Some of the potential careers for those who study computer science are listed below:

Demographics


- Nearly half of all computer programmers held a bachelor’s degree in 2002; about 1 in 5 held a graduate degree. [http://www.bls.gov/oco/ocos110.htm]
- Computer programmer employment is expected to grow much more slowly than that of other computer specialists.
- Education requirements range from a 2-year degree to a graduate degree. [http://www.bls.gov/oco/ocos042.htm]
- Employment, other than computer programmer, is expected to increase much faster than the average as organizations continue to adopt increasingly sophisticated technologies.

Sub-disciplines of computer science

Computer Science has a number of major sub-fields which can be classified by a number of means (for example the [http://www.acm.org/class/1998/overview.html ACM classification system]).

Algorithms

The study of algorithms is aimed at creating techniques that will enable a computer to perform a certain task in an efficient manner. An algorithm is a set of well-defined instructions for accomplishing some task, often explained by analogy with a culinary recipe. Algorithms are often implemented in software, and advancing the state of the art in algorithms is responsible for many of the most spectacular successes in computing. An algorithms specialist may come up with methods to accomplish new tasks, but just as often, they will work on improving the efficiency of an existing algorithm. These improvements can come in "time" (the length of time it takes for the algorithm to work) and "space" (the amount of computer memory the algorithm consumes. The field of algorithms is highly formal and many things can be proved about a given algorithm (using complexity theory), including roughly how long it will take to complete, as compared to the size of its input (the number of options it must consider). One interesting open question in algorithms concerns the complexity classes P and NP, and whether or not P = NP. If it does, then a whole range of seemingly difficult algorithms can in theory be performed quickly.

Data structures

A data structure is a way to store data so that it can be remembered and retrieved efficiently. A well-designed data structure means that an algorithm can be performed using as little memory space and time as possible. Some data structures are very simple: the simplest is an array which is simply a numbered list of items. Since the memory of a computer is usually modelled as an array (of bytes), this is also one of the most important data structures in computer science. For example, strings of text are usually modelled as arrays. But there are many other data structures such as linked lists, trees, hash tables and many others that are quite different but critical to the science. Type theory classifies data at a most basic (mathematical) level into different types, such as integers, complex numbers, strings, etc. and deals with how those types can interact. Abstract data types, at a more concrete level, deal with how types and data structures are used in software programming.

Listing of sub-disciplines

Computer science is closely related to a number of fields. These fields overlap considerably, though important differences exist:

Major fields of importance for computer science

See also


- Benchmark
- Computer jargon
- Computer numbering formats
- Computer slang
- Computing
- Data acquisition
- European Association for Theoretical Computer Science
- IEEE John von Neumann Medal
- Internet
- List of algorithms
- List of basic computer science topics
- List of computer science conferences
- List of computing topics
- List of data structures
- List of open problems in computer science
- List of publications in computer science
- List of prominent pioneers in computer science
- Multimedia
- Online computations and algorithms
- Sensor network
- Turing Award (ACM)

External links


- [http://www.dmoz.org/Computers/Computer_Science/ Open Directory Project: Computer Science]
- [http://www.techbooksforfree.com/science.shtml Downloadable Science and Computer Science books]
- [http://liinwww.ira.uka.de/bibliography/ Collection of Computer Science Bibliographies]
- [http://www.geocities.com/tablizer/science.htm Belief that title "science" in "computer science" is inappropriate] Category:Computer science ko:컴퓨터 과학 ja:情報工学 simple:Computer science th:วิทยาการคอมพิวเตอร์

Computer hardware

Computer hardware is the physical parts of a computer, as distinguished from the computer software or computer programs and data that operate within the hardware. The hardware of a computer is infrequently changed, in comparison with software and data which are "soft" in the sense that they are readily created, modified or erased on the computer. Firmware is special software that rarely, if ever, needs to be changed and so is stored on hardware devices such as read-only memory (ROM) where it is not readily changed (and therefore is "firm" rather than just "soft"). Most computer hardware is not seen by normal users as it is enclosed as embedded systems in automobiles, microwave ovens, electrocardiograph machines, compact disc players, and many other household appliances. Personal computers, the computer hardware familiar to the most people, form only a small minority of computers (about 0.2% of all new computers produced in 2003) Market statistics.

Personal computer hardware

A typical personal computer consists of a case or chassis in desktop or tower shape and the following parts:
- Motherboard or system board with slots for expansion cards and holding parts including:
  - Central processing unit (CPU)
  - Random Access Memory (RAM) - for program execution and short term data storage, so the computer doesn't have to take the time to access the hard drive to find something. More RAM can contribute to a faster PC.
  - Buses :
    - PCI bus
    - PCI-E or AGP bus
    - ISA bus (outdated)
    - USB
- Power supply - a case that holds a transformer, voltage control and fan
- Storage controllers of IDE, SATA, SCSI or other type, that control hard disk, floppy disk, CD-ROM and other drives; the controllers sit directly on the motherboard (on-board) or on expansion cards
- Video display controller that produces the output for the computer display
- Computer bus controllers (parallel, serial, USB, FireWire) to connect the computer to external peripheral devices such as printers or scanners
- Some type of a removable media writer:
  - CD - the most common type of removable media, cheap but fragile.
    - CD-ROM Drive
    - CD Writer
  - DVD
    - DVD-ROM Drive
    - DVD Writer
    - DVD-RAM Drive
  - Floppy disk
  - Zip drive
  - Tape drive - mainly for backup and long-term storage
- Internal storage - keeps data inside the computer for later use.
  - Hard disk - for medium-term storage of data.
  - Disk array controller
- Sound card - translates signals from the system board into analog voltage levels, and has terminals to plug in speakers.
- Networking - to connect the computer to the Internet and/or other computers
  - Modem - for dial-up connections
  - Network card - for DSL/Cable internet, and/or connecting to other computers.
- Other peripherals In addition, hardware can include external components of a computer system. The following are either standard or very common.
- Input or Input devices
  - Text input devices
    - Keyboard
  - Pointing devices
    - Mouse
    - Trackball
  - Gaming devices
    - Joystick
    - Gamepad
  - Image, Video input devices
    - Image scanner
    - Webcam
  - Audio input devices
    - Microphone
- Output or Output devices
  - Image, Video output devices
    - Printer
    - Monitor
  - Audio output devices
    - Speakers

See also


- E-waste
- Computer architecture
- legacy system
- Open hardware
- optical computer
- DNA computer
- History of computing hardware
- Origins of computer terms

Wiki links


- [http://www.themodwiki.org TheModWiki.org]
- [http://wiki.debian.net/index.cgi?Hardware DebianWiki: Hardware]

External links


- [http://www.dmoz.org/Computers/Hardware/Technical_Evaluations_and_Product_Reviews/ Hardware review sites]
- [http://www.corelimits.com Your source for computer news and reviews]
- [http://www.tomshardware.com Another source for computer news and reviews]
- [http://www.dmoz.org/Computers/Hardware/ Computer Hardware Directory @ dmoz]
- [http://www.elook.org/computing/hardware.htm Definition of hardware at eLook Computing Reference]
- [http://www.webopedia.com/TERM/H/hardware.html Definition of Computer hardware @ Webopedia]
- [http://www.tech-forums.net Computer Discussion Forums]
- Comp Category:Digital electronics ko:컴퓨터 하드웨어 ms:Perkakasan komputer ja:ハードウェア simple:Hardware th:อุปกรณ์คอมพิวเตอร์

Computation

In computer science, a computation is the evolution over time of a computer. However, the meaning of the word computer should be understood in a large sense, since it doese not restrict to a digital computer. A typical example of a physical computation is the evolution over time of a digital computer. Other examples of physical computations are derived from quantum computers or molecular computers. In computer science, which is sometimes described as the discipline that studies computations, mathematical models of computers are defined; a typical model is the Turing machine. In this context, a computation thus becomes a mathematical object: the evolution over time of a Turing machine. The sub-field of computer science which studies mathematical models of computations is called the theory of computation.

History

The word computation has an archaic meaning (from its latin ethymologycal roots), but the word has come back in use with the arising of a new scientific discipline: computer science.

Theory of computation

The theory of computation is the branch of computer science that deals with whether and how efficiently problems can be solved on a computer. The field is divided into two major branches: computability theory and complexity theory, but both branches deal with formal models of computation. In order to perform a rigorous study of computation, computer scientists work with a mathematical abstractions of computers called a model of computation. There are several formulations in use, but the most commonly examined is the Turing machine. A Turing machine can be thought of as a desktop PC with an infinite memory capacity, though it can only access this memory in small discrete chunks. Computer scientists study the Turing machine because it is simple to formulate, can be analyzed and used to prove results, and because it represents what many consider the most powerful possible "reasonable" model of computation. While the infinite memory capacity might be considered an unphysical attribute, for any problem actually solved by a Turing machine the memory used will always be finite, so any problem that can be solved on a Turing machine could be solved on a desktop PC which has enough memory installed.

Computability theory

Computability theory deals primarily with the question of whether a problem is solvable at all on a computer. The halting problem is one of the most important results in computability theory, as it is an example of a concrete problem that is both easy to formulate and impossible to solve using a Turing machine. Much of computability theory builds on the halting problem result. Computability theory is closely related to the branch of mathematical logic called recursion theory, which removes the restriction of studying only models of computation which are close to physically realizable. Many mathematicians who study recursion theory will refer to it as computability theory. There is no real difference between the fields other than whether a researcher working in this area has his or her office in the computer science or mathematics department.

Complexity theory

Complexity theory considers not only whether a problem can be solved at all on a computer, but also how efficiently the problem can be solved. Two major aspects are considered: time complexity and space complexity, which are respectively how many steps does it take to perform a computation, and how much memory is required to perform that computation. In order to analyze how much time and space a given algorithm requires, computer scientists express the time or space required to solve the problem as a function of the size of the input problem. For example, finding a particular number in a long list of numbers become harder as the list of numbers grows larger. If we say there are n numbers in the list, then if the list is not sorted or indexed in any way we may have to look at every number in order to find the number we're seeking. We thus say that in order to solve this problem, the computer needs to perform a number of steps that grows linearly in the size of the problem. To simplify this problem, computer scientists have adopted Big O notation, which allows functions to be compared in a way that ensures that particular aspects of a machine's construction do not need to be considered, but rather only the asymptotic behavior as problems become large. So in our previous example we might say that the problem requires O(n) steps to solve. Perhaps the most important open problem in all of computer science is the question of whether a certain broad class of problems denoted NP can be solved efficiently. This is discussed further at Complexity classes P and NP.

Other formal definitions of computation

Aside from a Turing machine, other equivalent (See: Church-Turing thesis) models of computation are in use. ;lambda calculus: A computation is an initial lambda expression (or two if you want to separate the function and its input) plus a finite sequence of lambda terms, each deduced from the preceding term by one application of Beta reduction. ;recursive functions: a computation is be a recursive function, i.e. its defining sequence, any input value(s) and a sequence of recursive functions appearing in the defining sequence with inputs and outputs. Thus, if in the defining sequence of a recursive function f(x) the functions g(x) and h(x,y) appear, then terms of the form 'g(5)=7' or 'h(3,2)=10' might appear. Each entry in this sequence needs to be an application of a basic function or follow from the entries above by using composition, primitive recursion or mu recursion. For instance if f(x)=h(x,g(x)), then for 'f(5)=3' to appear, terms like 'g(5)=6' and 'h(3,6)=3' must occur above. The computation terminates only if the final term gives the value of the recursive function applied to the inputs. ;markov algorithm: a string rewriting system that uses grammar-like rules to operate on strings of symbols. In addition to the general computational models, some simpler computational models are useful for special, restricted applications. Regular expressions, for example, are used to specify string patterns in UNIX and in some programming languages such as Perl. Another formalism mathematically equivalent to regular expressions, Finite automata are used in circuit design and in some kinds of problem-solving. Context-free grammars are used to specify programming language syntax. Non-deterministic pushdown automata are another formalism equivalent to context-free grammars. Primitive recursive functions are a defined subclass of the recursive functions. Different models of computation have the ability to do different tasks. One way to measure the power of a computational model is to study the class of formal languages that the model can generate; this leads to the Chomsky hierarchy of languages.

Further reading


- Part Two: Computability Theory, chapters 3–6, pp.123–222.
- Hein, James L: Theory of Computation. Sudbury, MA: Jones & Bartlett, 1996. A gentle introduction to the field, appropriate for second-year undergraduate computer science students.
- Hopcroft, John E., and Jeffrey D. Ullman: Introduction to Automata Theory, Languages, and Computation. Reading, MA: Addison-Wesley, 1979. One of the standard references in the field.
- Taylor, R. Gregory: Models of Computation. New York: Oxford University Press, 1998. An unusually readable textbook, appropriate for upper-level undergraduates or beginning graduate students.
- Hartley Rogers, Jr, Theory of Recursive Functions and Effective Computability, MIT Press, 1987, ISBN 0-262-68052-1 (paperback)
- [http://www.cis.upenn.edu/~giorgi/cl.html Computability Logic]: A theory of interactive computation. The main web source on this subject.
-

Computer languages

A computer language is a language used by, or in association with, computers. Often, the term is used synonymously with programming language, but in general a computer language need not be a programming language. It is understood that markup languages like HTML are generally not held to be programming languages, but they are computer languages. In general, as with any other kind of language, a computer language is created wherever there is a need to communicate some information from one entity to another. Programming languages foster the communication of programs among programmers and computers; markup languages communicate the formatting or structure of documents among humans and computers; and so on.

Examples

Computer languages can be classified into several kinds, including but not limited to the following:
- Programming languages :For history and taxonomy see [http://hopl.murdoch.edu.au The Encyclopedia of Programming Languages]
- Specification languages
- Query language (e.g. SQL, XQuery)
- Markup languages (typically used for producing documents)
- Transformation languages (e.g., XSLT)
- Communication protocols for networks
- Category:Computer science Es:Lenguaje informático

Operating systems

In computing, an operating system (OS) is the system software responsible for the direct control and management of hardware and basic system operations. Additionally, it provides a foundation upon which to run application software such as word processing programs, web browsers and others. Network operating system and firmware are other types of operating systems.

Introduction

Early computers lacked operating systems. A human operator would manually load and run programs. When programs were developed to load and run other programs, it was natural to draw their name from the human job they replaced. Most current usage of the term "operating system" today, by both popular and professional sources, refers to all the software that is required in order for the user to manage the system and to run third-party application software for that system. That is, the common understanding includes not only the low-level "kernel" that interacts directly with the hardware, but also libraries required by applications as well as basic programs to manipulate files and configure the system. The exact delineation between the operating system and application software is not precise, however, and is occasionally subject to controversy. For example, one of the key questions in the United States v. Microsoft antitrust trial was whether Microsoft's Internet Explorer web browser was part of its Windows operating system or if it was a separable piece of application software. As another example, the GNU/Linux naming controversy is, in part, due to disagreement about the relationship between the Linux kernel and the Linux operating system. The lowest level of any operating system is its kernel, the first layer of software loaded into computer memory when it starts up. As the first software layer, all other software that gets loaded after it depends on this software to provide them with various common core services. These common core services include, but are not limited to: disk access, memory management, task scheduling, and access to other hardware devices. Like the term "operating system" itself, the question of what exactly should form the "kernel" is subject to some controversy—with various camps advocating "microkernels", "monolithic kernels", and so on—with debates over whether things like file systems should be included in the kernel.

System Calls

System calls are operations/services that are requested by applications from the operating system. As noted on the System Call page, "System calls often use a special machine code instruction which causes the processor to change mode (e.g. to "supervisor mode" or "protected mode")."

Common core services

As operating systems evolve, ever more services are expected to be common core. Since the 1990s, OS's have often been required to provide network and Internet connectivity. They may be required to protect the computer's other software from damage by malicious programs, such as viruses. The list of common core services is ever expanding. Programs communicate with each other through application programming interfaces, similar to how humans interact with programs through user interfaces. This is especially true between application programs and the OS. The OS's common core services are accessed by application programs through the OS's APIs. Thus an OS enables the communication between hardware and software. CPU scheduling is also a main function of the operating system. See also: POSIX

Today's operating systems

Firstly, there is a distinction between console OS's, using only the keyboard for input, such as DOS, and the modern visual OS's, focusing on the mouse and using a GUI (sometimes implemented as a shell around the former). Secondly, which OS can be used often depends on the hardware architecture, most specifically the CPU that is used, with only Linux and BSD running on almost any architecture. In the past there have been many types of OS's, but starting in the 1990's the choice for personal computers has come to be largely restricted to the Microsoft Windows family and the Unix-like family, of which Linux is becoming the major representative. Mainframe computers and embedded systems use a variety of different operating systems, many with no direct connection to Windows or Unix, but mostly closer to Unix than Windows.
- Personal computers
  - IBM PC compatible - smaller Unix-variants, like Linux and BSD, and Microsoft Windows
  - Apple Macintosh - Mac OS X, Linux and BSD
- Mainframes - Unix variants, Microsoft Windows and a score of other OS's, mostly related to Unix
- Embedded systems - a variety of dedicated OS's, and limited versions of Linux or other OS's

Unix-like systems

Embedded system.]] The Unix-like family is a diverse group of operating systems, with several major sub-categories including System V, BSD, and Linux. The name "Unix" is a trademark of The Open Group which licenses it for use to any operating system that has been shown to conform to the definitions that they have cooperatively developed. The name is commonly used to refer to the large set of operating systems which resemble the original Unix. Unix systems run on a wide variety of machine architectures. They are used heavily as server systems in business, as well as workstations in academic and engineering environments. Free software Unix variants, such as Linux and BSD, are increasingly popular. They have made inroads on the desktop market as well, particularly with "user-friendly" Linux distributions such as Ubuntu Linux. Some proprietary Unix variants like HP's HP-UX and IBM's AIX are designed to run only on that vendor's proprietary hardware. Others, such as Solaris, can run on both proprietary hardware and on commodity x86 PCs. Apple's Mac OS X, a BSD variant derived from NeXTSTEP and FreeBSD, has replaced Apple's earlier (non-Unix) Mac OS in a small but dedicated market, in the process becoming the most popular proprietary Unix system. Over the past several years, free Unix systems have supplanted proprietary ones in many markets. For instance, scientific modeling and computer animation were once the province of SGI's IRIX. Today, they are dominated by Linux-based clusters.

Microsoft Windows

IRIX The Microsoft Windows family of operating systems originated as a graphical layer on top of the older MS-DOS environment for the IBM PC. Modern versions are based on the newer Windows NT core that first took shape in OS/2. Windows runs on 32- and 64-bit Intel and AMD computers, although earlier versions also ran on the DEC Alpha, MIPS and PowerPC architectures (and there was work in progress to make it work also on the SPARC architecture). Today, Windows is a popular desktop operating system, enjoying a near-monopoly of around 90% of the worldwide desktop market share. It is also widely used on low-end and mid-range servers, supporting applications such as web servers and database servers. In recent years, Microsoft has spent significant marketing and R&D money to demonstrate that Windows is capable of running any enterprise application (see the TPC article).

Other operating systems

Mainframe operating systems, such as IBM's z/OS, and embedded operating systems such as QNX, eCos, and PalmOS, are usually unrelated to Unix and Windows, except Windows CE, Windows NT Embedded 4.0 and Windows XP Embedded which are related to Windows and several
- BSDs and Linux distributions tailored for the requirements of an embedded system. Older operating systems which are still used in niche markets include the Windows-like OS/2 from IBM; VMS from Hewlett-Packard (formerly DEC); Mac OS, the non-Unix precursor to Apple's Mac OS X; RISC OS, which is specifically designed to run on ARM processor architectures; and AmigaOS, the first graphical user interface (GUI) based operating system with advanced multimedia capabilities available to the general public. Research and development of new kinds of operating systems is an active subfield of computer science. Microsoft Singularity is a research project to develop an operating system with better memory protection.

Examples of operating systems


- Mac OS
- Microsoft Windows
- Unix (including BSD and its derivatives, and "unix-like" OSes such as Linux and GNU)
- yellowTAB Zeta, based on BeOS
- DOS (and its fore-runner CP/M) For more examples, see the list of operating systems.

Classifications and terminology

: An operating system is conceptually broken into three sets of components: a user interface (which may consist of a GUI and/or a command line interpreter or "shell"), low-level system utilities, and a kernel--which is the heart of the operating system. As the name implies, the shell is an outer wrapper to the kernel, which in turn talks directly to the hardware. Hardware <-> Kernel <-> Shell <-> Applications | | +----------+ 1 2 3 In some operating systems the shell and the kernel are completely separate entities, allowing you to run varying combinations of shell and kernel (e.g. UNIX), in others their separation is only conceptual. Kernel design ideologies include those of the monolithic kernel, microkernel, hybrid kernel(modified micro kernel) and exokernel. Many of the major commercial systems such as UNIX, Windows (dos based), and Linux use a monolithic approach, some systems use a microkernel (such as in AmigaOS, QNX, and BeOS) and others like Apple's Mac OS X and Microsoft Windows NT line use the hybrid approach. The microkernel approach is also very popular among research operating systems. Both approaches have produced successful systems and have their advantages. Many embedded systems use ad hoc exokernels.

See also

General topics


- Operating systems category
- History of operating systems
- List of operating systems
- Comparison of operating systems
- Operating systems timeline
- Important publications in operating systems

Other topics


- Monolithic Kernel – Microkernel – Exokernel – Virtual machine – System call
- Asymmetric and Symmetric Multiprocessing (SMP) – Clustering – Distributed computing
- Real-time operating system – Time-sharing – Multitasking – Embedded system – Single-user – Multi-user
- Orthogonally persistent capabilities versus access control lists
- Object-oriented operating system
- Disk operating systems
- Hard disk drive partitioning
- LiveCD OS (Gnoppix and Knoppix Linux).
- Operating system advocacy
- OS-tan (Personification of operating systems)
- [http://opensource.eu.com/colinux Open Colinux - Running Linux inside Windows]

External links


- [http://www.world-os.com World-Os.com a website dedicated the operating system]
- [http://dmoz.org/Computers/Software/Operating_Systems/ Operating systems at dmoz.org]
- [http://cliki.tunes.org/Operating%20Systems Operating systems at TUNES] - wiki with reviews of operating systems
- [http://www.cbi.umn.edu/iterations/haigh.html Multics History] and the history of operating systems
- [http://www.elook.org/computing/operating-system.htm operating system at elook.org] - explains what an operating system is and provides various examples
- [http://mega-tokyo.com/osfaq2/ The "Write Your Own Operating System" OS Developer FAQ]
- [http://computer.howstuffworks.com/operating-system.htm How OSs Work]
- [http://www.groovyweb.uklinux.net/index.php?page_name=Operating%20system%20programming Operating System Programming] - tutorials and source code
- [http://www.osdata.com Operating Systems Technical Comparison]
- [http://www.osdcom.info/ OSDEV Community] - Amateur OS Development
- [http://www.osdever.net/ BonaFide OS Development] - resource for operating system developers
- [http://www.oshistory.net/ OS History] - Historic timeline of Non-Unix OS Developments
- Humor: [http://www.webaugur.com/bibliotheca/field_stock/os-airlines.html If OS's Were Airlines] zh-min-nan:Chok-gia̍p hē-thóng als:Betriebssystem ko:운영 체제 ms:Sistem pengoperasian ja:オペレーティングシステム simple:Operating system th:ระบบปฏิบัติการ

Formal grammar

In computer science a formal grammar is an abstract structure that describes a formal language precisely, i.e., a set of rules that mathematically delineates a (usually infinite) set of finite-length strings over a (usually finite) alphabet. Formal grammars are so named by analogy to grammar in human languages. Formal grammars fall into two main categories: generative and analytic.
- A generative grammar, the most well-known kind, is a set of rules by which all possible strings in the language to be described can be generated by successively rewriting strings starting from a designated start symbol. A generative grammar in effect formalizes an algorithm that generates strings in the language.
- An analytic grammar, in contrast, is a set of rules that assume an arbitrary string to be given as input, and which successively reduce or analyze that input string yielding a final boolean, "yes/no" result indicating whether or not the input string is a member of the language described by the grammar. An analytic grammar in effect formally describes a parser for a language. In short, an analytic grammar describes how to read a language, whereas a generative grammar describes how to write it.

Generative grammars

A generative grammar consists of a set of rules for transforming strings. To generate a string in the language, one begins with a string consisting of only a single "start" symbol, and then successively applies the rules (any number of times, in any order) to rewrite this string. The language consists of all the strings that can be generated in this manner. Any particular sequence of legal choices taken during this rewriting process yields one particular string in the language, and if there are multiple different ways of generating a single string, then the grammar is said to be ambiguous. For example, assume the alphabet consists of 'a' and 'b', the start symbol is 'S' and we have the following rules: : 1. S \longrightarrow aSb : 2. S \longrightarrow ba then we start with "S", and can choose a rule to apply to it. If we choose rule 1, we replace 'S' with 'aSb' and obtain "aSb". If we choose rule 1 again, we replace 'S' with 'aSb' and obtain "aaSbb". This process is repeated until we only have symbols from the alphabet (i.e., 'a' and 'b'). Finishing off our example, if we now choose rule 2, we replace 'S' with 'ba' and obtain "aababb", and are done. We can write this series of choices more briefly, using symbols: S \longrightarrow aSb \longrightarrow aaSbb \longrightarrow aababb. The language of the grammar is the set of all the strings that can be generated using this process: \left \.

Formal definition

In the classic formalization of generative grammars first proposed by Noam Chomsky in the 1950s, a grammar G consists of the following components:
- A finite set N of nonterminal symbols.
- A finite set \Sigma of terminal symbols that is disjoint from N.
- A finite set P of production rules where a rule is of the form :: string in (\Sigma \cup N)^ \longrightarrow string in (\Sigma \cup N)^ :(where ^ is the Kleene star and \cup is union) with the restriction that the left-hand side of a rule (i.e., the part to the left of the \longrightarrow) must contain at least one nonterminal symbol.
- A symbol S in N that is indicated as the start symbol. Usually such a formal grammar G is simply summarized as the quad-tuple (N, \Sigma, P, S). The language of a formal grammar G = (N, \Sigma, P, S), denoted as \boldsymbol(G), is defined as all those strings over \Sigma that can be generated by starting with the start symbol S and then applying the production rules in P until no more nonterminal symbols are present.

Example

For these examples, formal languages are specified using set-builder notation. Consider, for example, the grammar G with N = \left \, \Sigma = \left \, P consisting of the following production rules : 1. S \longrightarrow aBSc : 2. S \longrightarrow abc : 3. Ba \longrightarrow aB : 4. Bb \longrightarrow bb and the nonterminal symbol S as the start symbol. Some examples of the derivation of strings in \boldsymbol(G) are:
- \boldsymbol \longrightarrow (2) abc
- \boldsymbol \longrightarrow (1) aB\boldsymbolc \longrightarrow (2) a\boldsymbolbcc \longrightarrow (3) aa\boldsymbolcc \longrightarrow (4) aabbcc
- \boldsymbol \longrightarrow (1) aB\boldsymbolc \longrightarrow (1) aBaB\boldsymbolcc \longrightarrow (2) a\boldsymbolBabccc \longrightarrow (3) aaB\boldsymbolbccc\longrightarrow (3) aa\boldsymbolBbccc \longrightarrow (3) aaaB\boldsymbolccc \longrightarrow (4) aaa\boldsymbolbccc \longrightarrow (4) aaabbbccc (where the used production rules are indicated in brackets and the replaced part is each time indicated in bold). It is clear that this grammar defines the language \left \ where a^ denotes a string of n a's. Thus, the entire language consists of any positive number of 'a's, followed by the same number of 'b's followed by the same number of 'c's. Generative formal grammars are identical to Lindenmayer systems (L-systems), except that L-systems are not affected by a distinction between terminals and nonterminals, L-systems have restrictions on the order in which the rules are applied, and L-systems can run forever, generating an infinite sequence of strings. Typically, each string is associated with a set of points in space, and the "output" of the L-system is defined to be the limit of those sets.

The Chomsky Hierarchy

When Noam Chomsky first formalized generative grammars in the 1950s, he classified them into four types now known as the Chomsky hierarchy. The difference between these types is that they have increasingly strict production rules and can express fewer formal languages. Two important types are context-free grammars and regular grammars. The languages that can be described with such a grammar are called context-free languages and regular languages, respectively. Although much less powerful than unrestricted grammars, which can in fact express any language that can be accepted by a Turing machine, these two restricted types of grammars are most often used because parsers for them can be efficiently implemented. For example, for context-free grammars there are well-known algorithms to generate efficient LL parsers and LR parsers.

Context-free grammars

In context-free grammars, the left hand side of a production rule may only be formed by a single non-terminal symbol. The language defined above is not a context-free language, but for example the language \left \ (any positive number of 'a's followed by the same number of 'b's) is, as it can be defined by the grammar G2 with N=\left \, \Sigma=\left \, S the start symbol, and the following production rules: : 1. S \longrightarrow aSb : 2. S \longrightarrow ab

Regular grammars

In regular grammars, the left hand side is again only a single non-terminal symbol, but now the right-hand side is also restricted: It may be nothing, or a single terminal symbol, or a single terminal symbol followed by a non-terminal symbol, but nothing else. (Sometimes a broader definition is used: one can allow longer strings of terminals or single non-terminals without anything else, making languages easier to denote while still defining the same class of languages.) The language defined above is not regular, but the language \left \ (any positive number of 'a's followed by any positive number of 'b's, where the numbers may be different) is, as it can be defined by the grammar G3 with N=\left \, \Sigma=\left \, S the start symbol, and the following production rules: : 1. S \longrightarrow aA : 2. A \longrightarrow aA : 3. A \longrightarrow bB : 4. B \longrightarrow bB : 5. B \longrightarrow \epsilon In practice, regular grammars are commonly expressed using regular expressions.

Regular vs. Context-Free Languages

Aside from the differences in production rules required to generate the two languages, the key high-level difference between \left \ (context-free) and \left \ (regular) is the specification that the number of 'a's and the number of 'b's must be equal in the context-free language. Thus, any automaton attempting to recognize the context-free language must necessarily keep track of more information than one that is attempting to recognize the regular language. The latter does not have to count the number of 'a's or 'b's, just to make sure there are more than zero of each. For more detail, see context-free language and regular language.

Other forms of generative grammars

Many extensions and variations on Chomsky's original hierarchy of formal grammars have been developed more recently, both by linguists and by computer scientists, usually either in order to increase their expressive power or in order to make them easier to analyze or parse. Of course these two goals tend to be at odds: the more expressive a grammar formalism is, the harder it is to analyze or parse using automated tools. Some forms of grammars more recently developed include:
- Tree-adjoining grammars increase the expressiveness of conventional generative grammars by allowing rewrite rules to operate on parse trees instead of just strings.
- Affix Grammars and attribute grammars allow rewrite rules to be augmented with semantic attributes and operations, useful both for increasing grammar expressiveness and for constructing practical language translation tools. A yearly conference is devoted to formal grammars: [http://www.formalgrammar.tk]

Analytic grammars

Though there is a tremendous body of literature on parsing algorithms, most of these algorithms assume that the language to be parsed is initially described by means of a generative formal grammar, and that the goal is to transform this generative grammar into a working parser. An alternative approach is to formalize the language in terms of an analytic grammar in the first place, which more directly corresponds to the structure of a parser for the language. Examples of analytic grammar formalisms include the following:
- [http://languagemachine.sourceforge.net The Language Machine] directly implements unrestricted analytic grammars. Substitution rules are used to transform an input to produce outputs and behaviour. The system can also produce a diagram, the lm-diagram which shows what happens when the rules of an unrestricted analytic grammar are being applied.
- Top-down parsing language (TDPL): a highly minimalist analytic grammar formalism developed in the early 1970s to study the behavior of top-down parsers.
- Parsing expression grammars (PEGs): a more recent generalization of TDPL designed around the practical expressiveness needs of programming language and compiler writers.
- Link grammars: a form of analytic grammar designed for linguistics, which derives syntactic structure by examining the positional relationships between pairs of words.

See also


- Concrete syntax tree
- Abstract syntax tree
- Ambiguous grammar Category:Formal languages ja:形式文法

Programming language

A programming language or computer language is a standardized communication technique for expressing instructions to a computer. It is a set of syntactic and semantic rules used to define computer programs. A language enables a programmer to precisely specify (but see Genetic Programming) what data a computer will act upon, how these data will be stored/transmitted, and what actions will be taken under various circumstances.

Features of programming language

Each programming language can be thought of as a set of formal specifications concerning syntax, vocabulary, and meaning. These specifications usually include:
- Data Types
- Data Structures
- Instruction and Control Flow
- Design Philosophy
- Compilation and Interpretation Most languages that are widely used, or have been used for a considerable period of time, have standardization bodies that meet regularly to create and publish formal definitions of the language, and discuss extending or supplementing the already extant definitions.

Data types

Internally, all data in modern digital computers are stored simply as zeros or ones (binary). The data typically represent information in the real world such as names, bank accounts and measurements and so the low-level binary data are organized by programming languages into these high-level concepts. The particular system by which data are organized in a program is the type system of the programming language; the design and study of type systems is known as type theory. Languages can be classified as statically typed languages, and dynamically typed languages. Statically typed languages can be further subdivided into languages with manifest types, where each variable and function declaration has its type explicitly declared, and type-inferred languages. It is possible to perform type inference on programs written in a dynamically typed language, but it is entirely possible to write programs in these languages that make type inference infeasible. Sometimes dynamically typed languages are called latently typed. With statically typed languages, there usually are pre-defined types for individual pieces of data (such as numbers within a certain range, strings of letters, etc.), and programmatically named values (variables) can have only one fixed type, and allow only certain operations: numbers cannot change into names and vice versa. Most mainstream statically typed languages, such as C, C++, C#, Java and Delphi, require all types to be specified explicitly; advocates argue that this makes the program easier to understand, detractors object to the verbosity it produces. Type inference is a mechanism whereby the type specifications can often be omitted completely, if it is possible for the compiler to infer the types of values from the contexts in which they are used -- for example, if a variable is assigned the value 1, a type-inferring compiler does not need to be told explicitly that the variable is an integer. There are however many different uses for integers; it might e.g. make sense in a program to prevent inadvertent adding of a phone number to the number of apples in a box. Therefore some languages such as Ada allow defining different kinds of incompatible integers; this is called strong typing. Type-inferred languages can be more flexible to use, particularly when they also implement parametric polymorphism. Examples of type-inferring languages are Haskell, MUMPS and ML. Dynamically typed languages treat all data locations interchangeably, so inappropriate operations (like adding names, or sorting numbers alphabetically) will not cause errors until run-time -- although some implementations provide some form of static checking for obvious errors. Examples of these languages are APL, Objective-C, Lisp, Smalltalk, JavaScript, Tcl, Prolog, Python, and Ruby. Strongly typed languages do not permit the usage of values as different types; they are rigorous about detecting incorrect type usage, either at runtime for dynamically typed languages, or at compile time for statically typed languages. Ada, Java, ML, and Oberon are examples of strongly typed languages. Weakly typed languages do not strictly enforce type rules or have an explicit type-violation mechanism, often allowing for undefined behavior, segmentation violations, or other unsafe behavior if types are assigned incorrectly. C, assembly language, C++, and Tcl are examples of weakly typed languages. Note that strong vs. weak is a continuum; Java is a strongly typed language relative to C, but is weakly typed relative to ML. Use of these terms is often a matter of perspective, much in the way that an assembly language programmer would consider C to be a high-level language while a Java programmer would consider C to be a low-level language. Note that strong and static are orthogonal concepts. Java is a strongly, statically typed language. C is a weakly, statically typed language. Python is a strongly, dynamically typed language. Tcl is a weakly, dynamically typed language. But beware that some people incorrectly use the term strongly typed to mean strongly, statically typed, or, even more confusingly, to mean simply statically typed--in the latter usage, C would be called strongly typed, despite the fact that C doesn't catch that many type errors and that it's both trivial and common to defeat its type system (even accidentally). Aside from when and how the correspondence between expressions and types is determined, there's also the crucial question of what types the language defines at all, and what types it allows as the values of expressions (expressed values) and as named values (denoted values). Low-level languages like C typically allow programs to name memory locations, regions of memory, and compile-time constants, while allowing expressions to return values that fit into machine registers; ANSI C extended this by allowing expressions to return struct values as well (see record). Functional languages often restrict names to denoting run-time computed values directly, instead of naming memory locations where values may be stored, and in some cases refuse to allow the value denoted by a name to be modified at all. Languages that use garbage collection are free to allow arbitrarily complex data structures as both expressed and denoted values. Finally, in some languages, procedures are allowed only as denoted values (they cannot be returned by expressions or bound to new names); in others, they can be passed as parameters to routines, but cannot otherwise be bound to new names; in others, they are as freely usable as any expressed value, but new ones cannot be created at run-time; and in still others, they are first-class values that can be created at run-time.

Data structures

Most languages also provide ways to assemble complex data structures from built-in types and to associate names with these new combined types (using arrays, lists, stacks, files). Object oriented languages allow the programmer to define data-types called "Objects" which have their own intrinsic functions and variables (called methods and attributes respectively). A program containing objects allows the objects to operate as independent but interacting sub-programs: this interaction can be designed at coding time to model or simulate real-life interacting objects. This is a very useful, and intuitive, functionality. Languages such as Python and Ruby have developed as OO (Object oriented) languages. They are comparatively easy to learn and to use, and are gaining popularity in professional programming circles, as well as being accessible to non-professionals. It is commonly thought that object-orientation makes languages more intuitive, increasing the public availability and power of customized computer applications.

Instruction and control flow

Once data has been specified, the machine must be instructed how to perform operations on the data. Elementary statements may be specified using keywords or may be indicated using some well-defined grammatical structure. Each language takes units of these well-behaved statements and combines them using some ordering system. Depending on the language, differing methods of grouping these elementary statements exist. This allows one to write programs that are able to cover a variety of input, instead of being limited to a small number of cases. Furthermore, beyond the data manipulation instructions, other typical instructions in a language are those used for control flow (branches, definitions by cases, loops, backtracking, functional composition).

Design philosophy

For the above-mentioned purposes, each language has been developed using a special design or philosophy. Some aspect or another is particularly stressed by the way the language uses data structures, or by which its special notation encourages certain ways of solving problems or expressing their structure. Since programming languages are artificial languages, they require a high degree of discipline to accurately specify which operations are desired. Programming languages are not error tolerant; however, the burden of recognizing and using the special vocabulary is reduced by help messages generated by the programming language implementation. There are a few languages which offer a high degree of freedom in allowing self-modification in which a program re-writes parts of itself to handle new cases. Typically, only machine language, Prolog, PostScript, and the members of the Lisp family (Common Lisp, Scheme) provide this capability. In MUMPS language this technique is called dynamic recompilation; emulators and other virtual machines exploit this technique for greater performance.

Compilation and interpretation

There are, broadly, two approaches to execute a program written in a given language. These approaches are known as compilation, done by a program known as a compiler; and interpretation, done by an interpreter. Some programming language implementations support both interpretation and compilation. An interpreter parses a computer program and executes it directly. One can imagine this as following the instructions of the program line-by-line. In contrast, a compiler translates the program into machine code -- the native instructions understood by the computer's processor. The compiled program can then be run by itself. Compiled programs usually run faster than interpreted ones, because the overhead of understanding and translating the programming language syntax has already been done. However, interpreters are frequently easier to write than compilers, and can more easily support interactive debugging of a program.

History of programming languages

The development of programming languages, unsurprisingly, follows closely the development of the physical and electronic processes used in today's computers. Programming languages have been under development for years and will remain so for many years to come. They got their start with a list of steps to wire a computer to perform a task. These steps eventually found their way into software and began to acquire newer and better features. The first major languages were characterized by the simple fact that they were intended for one purpose and one purpose only, while the languages of today are differentiated by the way they are programmed in, as they can be used for almost any purpose. And perhaps the languages of tomorrow will be more natural with the invention of quantum and biological computers. Charles Babbage is often credited with designing the first computer-like machines, which had several programs written for them (in the equivalent of assembly language) by Ada Lovelace. In the 1940s the first recognizably modern, electrically powered computers were created. Some military calculation needs were a driving force in early computer development, such as encryption, decryption, trajectory calculation and massive number crunching needed in the development of atomic bombs. At that time, computers were extremely large, slow and expensive: advances in electronic technology in the post-war years led to the construction of more practical electronic computers. At that time only Konrad Zuse imagined the use of a programming language (developed eventually as Plankalkül) like those of today for solving problems. Subsequent breakthroughs in electronic technology (transistors, integrated circuits, and chips) drove the development of increasingly reliable and more usable computers. The first widely used high level programming language was Fortran, developed during 1954–57 by an IBM team led by John W. Backus. It is still widely used for numerical work, with the latest international standard released in 2004. A [http://www.levenez.com/lang/history.html Computer Languages History] graphic shows a timeline from Fortran in 1954. Dennis Ritchie and Brian Kernighan developed the C programming language, initially for DEC PDP-11 in 1970. Later with lead of Bjarne Stroustrup the programming language C++ appeared in 1985 as an Object oriented language vertically compatible with C. Sun Microsystems released Java in 1995 which became very popular as an introductory programming language taught in universities. Microsoft presented the C# programming language in 2001 which is very similar to C++ and Java. There are many, many other languages (cf. List of programming languages).

Classifications of programming languages


- Array
- Aspect-oriented
- Assembly
- Concatenative
- Concurrent
- Curly-bracket
- Data-structured
- Dataflow
- Declarative
- Domain-specific
- Dynamic
- Educational
- Esoteric
- Functional
- General-purpose
- Imperative
- Interface description
- Logic
- Multiparadigm
- Object-oriented
  - Prototype-based
- Pattern directed invocation
- Procedural
- Quantum
- Reflective
- Scripting
- Synchronous
- Visual
- Lists of all programming languages
  - Alphabetical
  - Categorical
  - Chronological
  - Generational

Formal semantics

The rigorous definition of the meaning of programming languages is the subject of formal semantics.

See also


- Computer language
- Compiler
- Interpreter
- Binding
- Hello world program, examples of a simple program in many different programming languages
- Software engineering and List of software engineering topics
- Lists of computer syntax patterns
- Reserved word
- Keyword (Computer)
- Programming language dialect
- :Category:Programming languages

External links


- [http://merd.sourceforge.net/pixel/language-study/syntax-across-languages/ Syntax Patterns for Various Languages]
- Wikisource Source Code Examples
- [http://www.99-bottles-of-beer.net/ 99 Bottles of Beer] - One program written in 813 different programming languages
- [http://dmoz.org/Computers/Programming/Languages/ Open Directory - Computer Programming Languages]
- [http://ixpubs.com/ixg/comp_lang_quik_ref.html Computer Languages Quick Reference Chart]
- [http://www.levenez.com/lang/history.html Computer Languages History graphical chart]
- [http://ixpubs.com/ixg/comp_lang_ref.html Instant Expert - Computer Language Reference]
- [http://cgibin.erols.com/ziring/cgi-bin/cep/cep.pl Dictionary of Programming Languages]
- [http://www.techbookreport.com/ProgIndex.html TechBookReport - Programming] - Book and software reviews on all aspects of programming and programming languages.
- [http://www.computer-books.us/ Computer-Books.us] - A collection of programming books available for free download.
- [http://people.ku.edu/~nkinners/LangList/Extras/langlist.htm The Language List] - A catalog of claimed about 2 500 language entries
- Category:Computer languages ja:プログラミング言語 th:ภาษาโปรแกรม

Computer program

A computer program or software program (usually abbreviated to "a program") is a step-by-step list of instructions written for a particular computer architecture in a particular computer programming language. A layman equivalent example would be writing a step-by-step list of instructions in English instructing a human how to make a Peanut butter and jelly sandwich (the human being the specific architecture). More often than not, computer programs are compiled or assembled into non-human readable format. Executable uncompiled programs are referred to as scripts.

Terminology

The term "program" specifically refers to the blocks of instruction code that are loaded into memory for execution by an interpreter. (See Program Execution below.) In comparison, the term "software" refers to the computer program and any resources related to it. This would include static data, components (plugins), configuration files, and so on. These resources are usually bundled together into a software package to be distributed. Software programs (collections of programs and related resources) are most frequently referred to as applications by end-users, as most users are focused on the abilities of application software (application programs) rather than system software. (Users see things differently than programmers.) Note: The British English spelling programme is, for the most part, no longer used to refer to computer programs, as most internationally-used computing terms use the words (and spelling conventions) adopted in the U.S..

Program Execution

A modern day computer program is loaded into memory (usually by the operating system), interpreted and then executed ("run") instruction by instruction until "program termination", either with success or through computer error. Some primitive types of computers ran instructions encoded in various ways, an example would be punch cards. Before a computer can execute any sort of program (including the operating system which is also a program) the computer hardware must be initialized. This is done by a piece of software stored on programmable memory chips installed by the manufacturer called the BIOS. The BIOS will attempt to initialize the boot sequence making the computer ready for miscellaneous program execution.

Programs vs Data

A program has been defined. Data can be defined as information that is to be processed by some program. When the entire scope of a computer system is taken into account, there are regions where the distinction between the two is not so evident. CPUs sometimes have a set of smaller instructions that control the computer's hardware, data can contain a program that is executed (see Scripting programming language), programs can be written to create another program; all of which making the comparison largely one of perspective. Some deny that the distinction between program and data is useful altogther. Writing a program to generate a computer program is called metaprogramming. One application of this is have a program generate code according to a certain given data set. A single program might not easily be able to account for all the different aspects of the given data. Analysing the data to create a program that can handle all the aspects might prove easier. Lisp is an example of a language that provides strong support for this aspect of programming. The weights stored in a neural network are a form of data. It is precisely these weights that, combined with the topology of the network, define the network's behavior. It is unclear what the values of these weights actually represent or whether these weights can be programmed. This and other questions pertaining to artificial intelligence further test the comparison between program and data.

Programming

Creating a computer program is the iterative process of implementing new source code (or simply just "code") and testing, analyzing and refining the newly implemented code for syntax and semantic errors. One who practices this skill is referred to as a computer programmer. Since the evolution of computers is so rapid, the tasks of a computer programmer have become more diverse giving rise to different classes of computer programmers, each with a more specialized task. Two examples are a software developer and a systems architect. The lengthy process of computer programming is now referred to as "software development" or software engineering. The latter becoming more popular due to the increasing maturity of the discipline. (see Debate over who is a software engineer) Hence, a contemporary computer programmer can refer to a specialist in one area of computer programming or to the general mass of programmers working for a software company who implement the bulk of the code in large scale software. A group of programmers working for a software company maybe assigned a lead programmer and a project manager to oversee project development and deadlines. Large scale software usually undergoes a lengthy design phase by a system architect before actual development and cowboy coding is frowned upon. Two other forms of modern day approaches are team programming where each member of the group has equal say in the development process except for one person who guides the group through discrepancies. These groups tend to be around 10 people to keep the group manageable. The second form is referred to as "peer programming" or pair programming. See Process and methodology for the different aspects of modern day computer programming.

Algorithms

A formal methodology to solve a particular problem usually combined with a study of different degrees of performance constitute an algorithm. Algorithms can be purely theoretical or implemented by a computer program. Where theoretical algorithms are usually classified in categories according to complexity , implemented algorithms are usually profiled to test routines for efficiency. Note that although an algorithm can be theoretically performant, it can be poorly implemented wasting valuable computer resources. (see Algorithmic information theory for more information)

Example of a program (source code)

The supplied code is a small program in assembly language written for a virtual computer . The example shows a selection of instructions with the corresponding address in memory where each instruction will be placed. These addresses are not static, see memory management. Accompanying each instruction is the generated (by compilation) object code that coincides with the virtual computer's architecture (or ISA). For more examples, see the hello world program.

See also


- Turing machine
- Programming language
- Computer software
- Programmer
- Source code
- Extreme Programming
- Operating system
- Programming paradigm
- Firmware / Device driver
- Polyglot program

Bibliography


- Miles J. Murdocca & Vincent P. Heuring (2000). Principles of Computer Architecture. Prentice-Hall, Inc. ISBN 0-201-43664-7
- [http://iiusaedu.com/~murdocca/POCA Principles of Computer Architecture] (POCA) – ARCTools virtual computer available for download to execute referenced code, accessed August 24, 2005
- J.Glenn Brookshear (1989). Theory of Computation, Formal Languages, Automata, and Complexity. The Benjamin/Cummings Publishing Co.Inc. ISBN 0-8053-0143-7

External links


- [http://www.webopedia.com/TERM/P/program.html Definition of Program @ Webopedia]
- [http://www.Agtivity.com/computer_program.htm Definition of Computer program @ Agtivity]
- [http://wombat.doc.ic.ac.uk/foldoc/foldoc.cgi?query=software Definition of Software @ FOLDOC] Category:Computer science Category:Software
- ja:プログラム (コンピュータ) ko:프로그램 simple:Computer program th:โปรแกรม

Artificial intelligence

Artificial intelligence (AI) is defined as intelligence exhibited by an artificial entity. Such a system is generally assumed to be a computer. Although AI has a strong science fiction connotation, it forms a vital branch of computer science, dealing with intelligent behavior, learning and adaptation in machines. Research in AI is concerned with producing machines to automate tasks requiring intelligent behavior. Examples include control, planning and scheduling, the ability to answer diagnostic and consumer questions, handwriting, speech, and facial recognition. As such, it has become a scientific discipline, focused on providing solutions to real life problems. AI systems are now in routine use in economics, medicine, engineering and the military, as well as being built into many common home computer software applications and video games.

Schools of thought

AI divides roughly into two schools of thought: Conventional AI and Computational Intelligence (CI). Conventional AI mostly involves methods now classified as machine learning, characterized by formalism and statistical analysis. This is also known as symbolic AI, logical AI, neat AI and Good Old Fashioned Artificial Intelligence (GOFAI). (Also see semantics.) Methods include:
- Expert systems: apply reasoning capabilities to reach a conclusion. An expert system can process large amounts of known information and provide conclusions based on them. Clippy the Microsoft Office paperclip is an example. As the user types, Clippy recognizes certain traits and makes suggestions.
- Case based reasoning
- Bayesian networks Computational Intelligence involves iterative learning of connectionist system parameter tuning, based on empirical data. This is also known as non-symbolic AI, scruffy AI or soft computing. Methods are:
- Neural networks: systems with very strong pattern recognition capabilities.
- Fuzzy systems: techniques for reasoning under uncertainty, has been widely used in modern industrial and consumer product control systems.
- Evolutionary computation: applies biologically inspired concepts such as populations, mutation and survival of the fittest to generate increasingly better solutions to the problem. These methods most notably divide into evolutionary algorithms (e.g. genetic algorithms) and swarm intelligence (e.g. ant algorithms). However, hybrid intelligent systems have given rise to connectionist expert systems which try to combine these two groups, generating expert inference rules through neural network.

History

Main article: History of artificial intelligence Early in the 17th century, René Descartes proposed that bodies of animals are nothing more than complex machines. Blaise Pascal created the first mechanical digital calculating machine in 1642. Charles Babbage and Ada Lovelace worked on programmable mechanical calculating machines. Bertrand Russell and Alfred North Whitehead published Principia Mathematica, which revolutionaized formal logic. Warren McCulloch and Walter Pitts published "A Logical Calculus of the Ideas Immanent in Nervous Activity" in 1943 laying foundations for neural networks. The 1950s were a period of active efforts in AI. John McCarthy coined the term "artificial intelligence" in the first conference devoted to the subject. He also invented the Lisp programming language. Alan Turing introduced the "Turing test" as a way of operationalizing a test of intelligent behavior. Joseph Weizenbaum built ELIZA, a chatterbot implementing Rogerian psychotherapy. During the 1960s and 1970s, Joel Moses demonstrated the power of symbolic reasoning for integration problems in the Macsyma program, the first successful knowledge-based program in mathematics. Marvin Minsky and Seymour Papert publish Perceptrons, demonstrating limits of simple neural nets and Alain Colmerauer developed the Prolog computer language. Ted Shortliffe demonstrated the power of rule-based systems for knowledge representation and inference in medical diagnosis and therapy in what is sometimes called the first expert system. Hans Moravec developed the first computer-controlled vehicle to autonomously negotiate cluttered obstacle courses. In the 1980s, neural networks become widely used with the backpropagation algorithm, first described by Paul John Werbos in 1974. The 1990s marked major achievements in many areas of AI and demonstrations of various applications. Most notably Deep Blue, a chess-playing computer, beat Garry Kasparov in a famous match in 1997. DARPA stated that the costs saved by implementing AI methods for scheduling units in the first Gulf War have repaid the US government's entire investment in AI research since the 1950s.

Philosophy

Main article: Philosophy of artificial intelligence The weak AI vs. strong AI debate is still a hot topic amongst AI philosophers. This involves philosophy of mind and the mind-body problem. Most notably Roger Penrose in his book