To install click the Add extension button. That's it.

The source code for the WIKI 2 extension is being checked by specialists of the Mozilla Foundation, Google, and Apple. You could also do it yourself at any point in time.

Kelly Slayton
Congratulations on this excellent venture… what a great idea!
Alexander Grigorievskiy
I use WIKI 2 every day and almost forgot how the original Wikipedia looks like.
Live Statistics
English Articles
Improved in 24 Hours
Added in 24 Hours
What we do. Every page goes through several hundred of perfecting techniques; in live mode. Quite the same Wikipedia. Just better.

From Wikipedia, the free encyclopedia

A diagram showing how the user interacts with application software on a typical desktop computer.The application software layer interfaces with the operating system, which in turn communicates with the hardware. The arrows indicate information flow.
A diagram showing how the user interacts with application software on a typical desktop computer.The application software layer interfaces with the operating system, which in turn communicates with the hardware. The arrows indicate information flow.

Computer software, or simply software, is a collection of data or computer instructions that tell the computer how to work, in contrast to the physical hardware from which the system is built, that actually performs the work. In computer science and software engineering, computer software is all information processed by computer systems, programs and data. Computer software includes computer programs, libraries and related non-executable data, such as online documentation or digital media. Computer hardware and software require each other and neither can be realistically used on its own.

At the lowest level,[clarification needed] executable code consists of machine language instructions supported by an individual processor—typically a central processing unit (CPU) or a graphics processing unit (GPU). A machine language consists of groups of binary values signifying processor instructions that change the state of the computer from its preceding state. For example, an instruction may change the value stored in a particular storage location in the computer—an effect that is not directly observable to the user. An instruction may also invoke one of many input or output operations, for example displaying some text on a computer screen; causing state changes which should be visible to the user. The processor executes the instructions in the order they are provided, unless it is instructed to "jump" to a different instruction, or is interrupted by the operating system. As of 2015, most personal computers, smartphone devices and servers have processors with multiple execution units or multiple processors performing computation together, and computing has become a much more concurrent activity than in the past.

The majority of software is written in high-level programming languages that are easier and more efficient for programmers to use because they are closer than machine languages to natural languages.[1] High-level languages are translated into machine language using a compiler or an interpreter or a combination of the two. Software may also be written in a low-level assembly language, which has strong correspondence to the computer's machine language instructions and is translated into machine language using an assembler.

YouTube Encyclopedic

  • 1/5
    355 058
    551 030
    5 428
    343 181
    148 036
  • Software Engineering: Crash Course Computer Science #16
  • Fastest way to become a software developer
  • Failing to Fail: The Spiderweb Software Way
  • Computer Science vs Software Engineering - Which One Is A Better Major?
  • How To Crack A Software Using Ollydbg 2017 Latest


Hi, I’m Carrie Anne, and welcome to CrashCourse Computer Science! So we’ve talked a lot about sorting in this series and often code to sort a list of numbers might only be ten lines long, which is easy enough for a single programmer to write. Plus, it’s short enough that you don’t need any special tools – you could do it in Notepad. Really! But, a sorting algorithm isn’t a program; it’s likely only a small part of a much larger program. For example, Microsoft Office has roughly 40 millions lines of code. 40 MILLION! That’s way too big for any one person to figure out and write! To build huge programs like this, programmers use a set of tools and practices. Taken together, these form the discipline of Software Engineering – a term coined by engineer Margaret Hamilton, who helped NASA prevent serious problems during the Apollo missions to the moon. She once explained it this way: “It’s kind of like a root canal: you waited till the end, [but] there are things you could have done beforehand. It’s like preventative healthcare, but it’s preventative software.” INTRO As I mentioned in episode 12, breaking big programs into smaller functions allows many people to work simultaneously. They don’t have to worry about the whole thing, just the function they’re working on. So, if you’re tasked with writing a sort algorithm, you only need to make sure it sorts properly and efficiently. However, even packing code up into functions isn’t enough. Microsoft Office probably contains hundreds of thousands of them. That’s better than dealing with 40 million lines of code, but it’s still way too many “things” for one person or team to manage. The solution is to package functions into hierarchies, pulling related code together into “objects”. For example, car’s software might have several functions related to cruise control, like setting speed, nudging speed up or down, and stopping cruise control altogether. Since they’re all related, we can wrap them up into a unified cruise control object. But, we don’t have to stop there, cruise control is just one part of the engine’s software. There might also be sets of functions that control spark plug ignition, fuel pumps, and the radiator. So we can create a “parent” Engine Object that contains all of these “children” objects. In addition to children *objects*, the engine itself might have its *own* functions. You want to be able to stop and start it, for example. It’ll also have its own variables, like how many miles the car has traveled. In general, objects can contain other objects, functions and variables. And of course, the engine is just one part of a Car Object. There’s also the transmission, wheels, doors, windows, and so on. Now, as a programmer, if I want to set the cruise control, I navigate down the object hierarchy, from the outermost objects to more and more deeply nested ones. Eventually, I reach the function I want to trigger: “Car, then engine, then cruise control, then set cruise speed to 55”. Programming languages often use something equivalent to the syntax shown here. The idea of packing up functional units into nested objects is called Object Oriented Programming. This is very similar to what we’ve done all series long: hide complexity by encapsulating low-level details in higher-order components. Before we packed up things like transistor circuits into higher-level boolean gates. Now we’re doing the same thing with software. Yet again, it’s a way to move up a new level of abstraction! Breaking up a big program, like a car’s software, into functional units is perfect for teams. One team might be responsible for the cruise control system, and a single programmer on that team tackles a handful of functions. This is similar to how big, physical things are built, like skyscrapers. You’ll have electricians running wires, plumbers fitting pipes, welders welding, painters painting, and hundreds of other people teeming all over the hull. They work together on different parts simultaneously, leveraging their different skills. Until one day, you’ve got a whole working building! But, returning to our cruise control example… its code is going to have to make use of functions in other parts of the engine’s software, to, you know, keep the car at a constant speed. That code isn’t part of the cruise control team’s responsibility. It’s another team’s code. Because the cruise control team didn’t write that, they’re going to need good documentation about what each function in the code does, and a well-defined Application Programming Interface -- or API for short. You can think of an API as the way that collaborating programmers interact across various parts of the code. For example, in the IgnitionControl object, there might be functions to set the RPM of the engine, check the spark plug voltage, as well as fire the individual spark plugs. Being able to set the motor’s RPM is really useful, the cruise control team is going to need to call that function. But, they don’t know much about how the ignition system works. It’s not a good idea to let them call functions that fire the individual spark plugs. Or the engine might explode! Maybe. The API allows the right people access to the right functions and data. Object Oriented Programming languages do this by letting you specify whether functions are public or private. If a function is marked as “private”, it means only functions inside that object can call it. So, in this example, only other functions inside of IgnitionControl, like the setRPM function, can fire the sparkplugs. On the other hand, because the setRPM function is marked as public, other objects can call it, like cruise control. This ability to hide complexity, and selectively reveal it, is the essence of Object Oriented Programming, and it’s a powerful and popular way to tackle building large and complex programs. Pretty much every piece of software on your computer, or game running on your console, was built using an Object Oriented Programming Language, like C++, C# or Objective-C. Other popular “OO” languages you may have heard of are Python and Java. It’s important to remember that code, before being compiled, is just text. As I mentioned earlier, you could write code in Notepad or any old word processor. Some people do. But generally, today’s software developers use special-purpose applications for writing programs, ones that integrate many useful tools for writing, organizing, compiling and testing code. Because they put everything you need in one place, they’re called Integrated Development Environments, or IDEs for short. All IDEs provide a text editor for writing code, often with useful features like automatic color-coding to improve readability. Many even check for syntax errors as you type, like spell check for code. Big programs contain lots of individual source files, so IDEs allow programmers to organize and efficiently navigate everything. Also built right into the IDE is the ability to compile and run code. And if your program crashes, because it’s still a work in progress, the IDE can take you back to the line of code where it happened, and often provide additional information to help you track down and fix the bug, which is a process called debugging. This is important because most programmers spend 70 to 80% of their time testing and debugging, not writing new code. Good tools, contained in IDEs, can go a long way when it comes to helping programmers prevent and find errors. Many computer programmers can be pretty loyal to their IDEs though - but let’s be honest. VIM is where it’s at. Providing you know how to quit. In addition to coding and debugging, another important part of a programmer's job is documenting their code. This can be done in standalone files called “read-me’s” which tell other programmers to read that help file before diving in. It can also happen right in the code itself with comments. These are specially-marked statements that the program knows to ignore when the code is compiled. They exist only to help programmers figure out what’s what in the source code. Good documentation helps programmers when they revisit code they haven’t seen for awhile, but it’s also crucial for programmers who are totally new to it. I just want to take a second here and reiterate that it’s THE WORST when someone parachutes a load of uncommented and undocumented code into your lap, and you literally have to go line by line to understand what the code is doing. Seriously. Don’t be that person. Documentation also promotes code reuse. So, instead of having programmers constantly write the same things over and over, they can track down someone else’s code that does what they need. Then, thanks to documentation, they can put it to work in their program, without ever having to read through the code. “Read the docs” as they say. In addition to IDEs, another important piece of software that helps big teams work collaboratively on big coding projects is called Source Control, also known as version control or revision control. Most often, at a big software company like Apple or Microsoft, code for projects is stored on centralized servers, called a code repository. When a programmer wants to work on a piece of code, they can check it out, sort of like checking out a book out from a library. Often, this can be done right in an IDE. Then, they can edit this code all they want on their personal computer, adding new features and testing if they work. When the programmer is confident their changes are working and there are no loose ends, they can check the code back into the repository, known as committing code, for everyone else to use. While a piece of code is checked out, and presumably getting updated or modified, other programmers leave it alone. This prevents weird conflicts and duplicated work. In this way, hundreds of programmers can be simultaneously checking in and out pieces of code, iteratively building up huge systems. Critically, you don’t want someone committing buggy code, because other people and teams may rely on it. Their code could crash, creating confusion and lost time. The master version of the code, stored on the server, should always compile without errors and run with minimal bugs. But sometimes bugs creep in. Fortunately, source control software keeps track of all changes, and if a bug is found, the whole code, or just a piece, can be rolled back to an earlier, stable version. It also keeps track of who made each change, so coworkers can send nasty, I mean, helpful and encouraging emails to the offending person. Debugging goes hand in hand with writing code, and it’s most often done by an individual or small team. The big picture version of debugging is Quality Assurance testing, or QA. This is where a team rigorously tests out a piece of software, attempting to create unforeseen conditions that might trip it up. Basically, they elicit bugs. Getting all the wrinkles out is a huge effort, but vital in making sure the software works as intended for as many users in as many situations as imaginable before it ships. You’ve probably heard of beta software This is a version of software that’s mostly complete, but not 100% fully tested. Companies will sometimes release beta versions to the public to help them identify issues, it’s essentially like getting a free QA team. What you don’t hear about as much is the version that comes before the beta: the alpha version. This is usually so rough and buggy, it’s only tested internally. So, that’s the tip of the iceberg in terms of the tools, tricks and techniques that allow software engineers to construct the huge pieces of software that we know and love today, like YouTube, Grand Theft Auto 5, and Powerpoint. As you might expect, all those millions of lines of code needs some serious processing power to run at useful speeds, so next episode we’ll be talking about how computers got so incredibly fast. See you then.



An outline (algorithm) for what would have been the first piece of software was written by Ada Lovelace in the 19th century, for the planned Analytical Engine. However, neither the Analytical Engine nor any software for it were ever created.

The first theory about software—prior to creation of computers as we know them today—was proposed by Alan Turing in his 1935 essay On Computable Numbers, with an Application to the Entscheidungsproblem (decision problem).

This eventually led to the creation of the academic fields of computer science and software engineering. Both fields study software and its creation. Computer science is the theoretical study of computer and software (Turing's essay is an example of computer science), where as software engineering is the application of engineering and development of software.

However, prior to 1946, software was not yet the programs stored in the memory of stored-program digital computers, as we now understand it. The first electronic computing devices were instead rewired in order to "reprogram" them.


On virtually all computer platforms, software can be grouped into a few broad categories.

Purpose, or domain of use

Based on the goal, computer software can be divided into:

  • Application software
    which is software that uses the computer system to perform special functions or provide entertainment functions beyond the basic operation of the computer itself. There are many different types of application software, because the range of tasks that can be performed with a modern computer is so large—see list of software.
  • System software
    which is software that directly operates the computer hardware, to provide basic functionality needed by users and other software, and to provide a platform for running application software.[2] System software includes:
    • Operating systems
      which are essential collections of software that manage resources and provides common services for other software that runs "on top" of them. Supervisory programs, boot loaders, shells and window systems are core parts of operating systems. In practice, an operating system comes bundled with additional software (including application software) so that a user can potentially do some work with a computer that only has one operating system.
    • Device drivers
      which operate or control a particular type of device that is attached to a computer. Each device needs at least one corresponding device driver; because a computer typically has at minimum at least one input device and at least one output device, a computer typically needs more than one device driver.
    • Utilities
      which are computer programs designed to assist users in the maintenance and care of their computers.
  • Malicious software or malware
    which is software that is developed to harm and disrupt computers. As such, malware is undesirable. Malware is closely associated with computer-related crimes, though some malicious programs may have been designed as practical jokes.

Nature or domain of execution

  • Desktop applications such as web browsers and Microsoft Office, as well as smartphone and tablet applications (called "apps"). (There is a push in some parts of the software industry to merge desktop applications with mobile apps, to some extent. Windows 8, and later Ubuntu Touch, tried to allow the same style of application user interface to be used on desktops, laptops and mobiles.)
  • JavaScript scripts are pieces of software traditionally embedded in web pages that are run directly inside the web browser when a web page is loaded without the need for a web browser plugin. Software written in other programming languages can also be run within the web browser if the software is either translated into JavaScript, or if a web browser plugin that supports that language is installed; the most common example of the latter is ActionScript scripts, which are supported by the Adobe Flash plugin.
  • Server software, including:
  • Plugins and extensions are software that extends or modifies the functionality of another piece of software, and require that software be used in order to function;
  • Embedded software resides as firmware within embedded systems, devices dedicated to a single use or a few uses such as cars and televisions (although some embedded devices such as wireless chipsets can themselves be part of an ordinary, non-embedded computer system such as a PC or smartphone).[3] In the embedded system context there is sometimes no clear distinction between the system software and the application software. However, some embedded systems run embedded operating systems, and these systems do retain the distinction between system software and application software (although typically there will only be one, fixed, application which is always run).
  • Microcode is a special, relatively obscure type of embedded software which tells the processor itself how to execute machine code, so it is actually a lower level than machine code. It is typically proprietary to the processor manufacturer, and any necessary correctional microcode software updates are supplied by them to users (which is much cheaper than shipping replacement processor hardware). Thus an ordinary programmer would not expect to ever have to deal with it.

Programming tools

Programming tools are also software in the form of programs or applications that software developers (also known as programmers, coders, hackers or software engineers) use to create, debug, maintain (i.e. improve or fix), or otherwise support software.

Software is written in one or more programming languages; there are many programming languages in existence, and each has at least one implementation, each of which consists of its own set of programming tools. These tools may be relatively self-contained programs such as compilers, debuggers, interpreters, linkers, and text editors, that can be combined together to accomplish a task; or they may form an integrated development environment (IDE), which combines much or all of the functionality of such self-contained tools. IDEs may do this by either invoking the relevant individual tools or by re-implementing their functionality in a new way. An IDE can make it easier to do specific tasks, such as searching in files in a particular project. Many programming language implementations provide the option of using both individual tools or an IDE.



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

  • Platform software
    The Platform includes the firmware, device drivers, an operating system, and typically a graphical user interface which, in total, allow a user to interact with the computer and its peripherals (associated equipment). Platform software often comes bundled with the computer. On a PC one will usually have the ability to change the platform software.
  • Application software
    Application software or Applications are what most people think of when they think of software. Typical examples include office suites and video games. Application software is often purchased separately from computer hardware. Sometimes applications are bundled with the computer, but that does not change the fact that they run as independent applications. Applications are usually independent programs from the operating system, though they are often tailored for specific platforms. Most users think of compilers, databases, and other "system software" as applications.
  • User-written software
    End-user development tailors systems to meet users' specific needs. User software include spreadsheet templates and word processor templates. Even email filters are a kind of user software. Users create this software themselves and often overlook how important it is. Depending on how competently the user-written software has been integrated into default application packages, many users may not be aware of the distinction between the original packages, and what has been added by co-workers.


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

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

Quality and reliability

Software quality is very important, especially for commercial and system software like Microsoft Office, Microsoft Windows and Linux. If software is faulty (buggy), it can delete a person's work, crash the computer and do other unexpected things. Faults and errors are called "bugs" which are often discovered during alpha and beta testing. Software is often also a victim to what is known as software aging, the progressive performance degradation resulting from a combination of unseen bugs.

Many bugs are discovered and eliminated (debugged) through software testing. However, software testing rarely—if ever—eliminates every bug; some programmers say that "every program has at least one more bug" (Lubarsky's Law).[4] In the waterfall method of software development, separate testing teams are typically employed, but in newer approaches, collectively termed agile software development, developers often do all their own testing, and demonstrate the software to users/clients regularly to obtain feedback. Software can be tested through unit testing, regression testing and other methods, which are done manually, or most commonly, automatically, since the amount of code to be tested can be quite large. For instance, NASA has extremely rigorous software testing procedures for many operating systems and communication functions. Many NASA-based operations interact and identify each other through command programs. This enables many people who work at NASA to check and evaluate functional systems overall. Programs containing command software enable hardware engineering and system operations to function much easier together.


The software's license gives the user the right to use the software in the licensed environment, and in the case of free software licenses, also grants other rights such as the right to make copies.

Proprietary software can be divided into two types:

  • freeware, which includes the category of "free trial" software or "freemium" software (in the past, the term shareware was often used for free trial/freemium software). As the name suggests, freeware can be used free, although in the case of free trials or freemium software, this is sometimes only true for a limited period of time or with limited functionality.
  • software available for a fee, often inaccurately termed "commercial software", which can only be legally used on purchase of a license.

Open source software, on the other hand, comes with a free software license, granting the recipient the rights to modify and redistribute the software.


Software patents, like other types of patents, are theoretically supposed to give an inventor an exclusive, time-limited license for a detailed idea (e.g. an algorithm) on how to implement a piece of software, or a component of a piece of software. Ideas for useful things that software could do, and user requirements, are not supposed to be patentable, and concrete implementations (i.e. the actual software packages implementing the patent) are not supposed to be patentable either—the latter are already covered by copyright, generally automatically. So software patents are supposed to cover the middle area, between requirements and concrete implementation. In some countries, a requirement for the claimed invention to have an effect on the physical world may also be part of the requirements for a software patent to be held valid—although since all useful software has effects on the physical world, this requirement may be open to debate. Meanwhile, American copyright law was applied to various aspects of the writing of the software code.[5]

Software patents are controversial in the software industry with many people holding different views about them. One of the sources of controversy is that the aforementioned split between initial ideas and patent does not seem to be honored in practice by patent lawyers—for example the patent for Aspect-Oriented Programming (AOP), which purported to claim rights over any programming tool implementing the idea of AOP, howsoever implemented. Another source of controversy is the effect on innovation, with many distinguished experts and companies arguing that software is such a fast-moving field that software patents merely create vast additional litigation costs and risks, and actually retard innovation. In the case of debates about software patents outside the United States, the argument has been made that large American corporations and patent lawyers are likely to be the primary beneficiaries of allowing or continue to allow software patents.

Design and implementation

Design and implementation of software varies depending on the complexity of the software. For instance, the design and creation of Microsoft Word took much more time than designing and developing Microsoft Notepad because the latter has much more basic functionality.

Software is usually designed and created (aka coded/written/programmed) in integrated development environments (IDE) like Eclipse, IntelliJ and Microsoft Visual Studio that can simplify the process and compile the software (if applicable). As noted in a different section, software is usually created on top of existing software and the application programming interface (API) that the underlying software provides like GTK+, JavaBeans or Swing. Libraries (APIs) can be categorized by their purpose. For instance, the Spring Framework is used for implementing enterprise applications, the Windows Forms library is used for designing graphical user interface (GUI) applications like Microsoft Word, and Windows Communication Foundation is used for designing web services. When a program is designed, it relies upon the API. For instance, if a user is designing a Microsoft Windows desktop application, he or she might use the .NET Windows Forms library to design the desktop application and call its API's functions like Form1.Close() and Form1.Show()[6] to close or open the application, and write the additional operations him/herself that it needs to have. Without these APIs, the programmer needs to write these functionalities entirely themselves. Companies like Oracle and Microsoft provide their own APIs so that many applications are written using their software libraries that usually have numerous APIs in them.

Data structures such as hash tables, arrays, and binary trees, and algorithms such as quicksort, can be useful for creating software.

Computer software has special economic characteristics that make its design, creation, and distribution different from most other economic goods.[specify][7][8]

A person who creates software is called a programmer, software engineer or software developer, terms that all have a similar meaning. More informal terms for programmer also exist such as "coder" and "hacker" – although use of the latter word may cause confusion, because it is more often used to mean someone who illegally breaks into computer systems.

Industry and organizations

A great variety of software companies and programmers in the world comprise a software industry. Software can be quite a profitable industry: Bill Gates, the co-founder of Microsoft was the richest person in the world in 2009, largely due to his ownership of a significant number of shares in Microsoft, the company responsible for Microsoft Windows and Microsoft Office software products - both market leaders in their respective product categories.

Non-profit software organizations include the Free Software Foundation, GNU Project and Mozilla Foundation. Software standard organizations like the W3C, IETF develop recommended software standards such as XML, HTTP and HTML, so that software can interoperate through these standards.

Other well-known large software companies include Oracle, Novell, SAP, Symantec, Adobe Systems, Sidetrade and Corel, while small companies often provide innovation.

See also


  1. ^ "Compiler construction". Archived from the original on 2 November 2013.
  2. ^ "System Software". The University of Mississippi. Archived from the original on 30 May 2001.
  3. ^ "Embedded Software—Technologies and Trends". IEEE Computer Society. May–June 2009. Archived from the original on 28 October 2013. Retrieved 6 November 2013.
  4. ^ "scripting intelligence book examples". Archived from the original on 6 November 2015.
  5. ^ Gerardo Con Díaz, "The Text in the Machine: American Copyright Law and the Many Natures of Software, 1974–1978,” Technology and Culture 57 (October 2016), 753–79.
  6. ^ "MSDN Library". Archived from the original on 11 June 2010. Retrieved 14 June 2010.
  7. ^ v. Engelhardt, Sebastian (2008). "The Economic Properties of Software". Jena Economic Research Papers. 2 (2008–045.). Archived from the original on 5 January 2016.
  8. ^ Kaminsky, Dan (1999). "Why Open Source Is The Optimum Economic Paradigm for Software". Archived from the original on 22 May 2012.

External links

This page was last edited on 10 October 2018, at 03:20
Basis of this page is in Wikipedia. Text is available under the CC BY-SA 3.0 Unported License. Non-text media are available under their specified licenses. Wikipedia® is a registered trademark of the Wikimedia Foundation, Inc. WIKI 2 is an independent company and has no affiliation with Wikimedia Foundation.