Classification of Software

Classification of Software
Topic 4: Computers Classification of Software

The Software Hierarchy
We can break a computer (and its software) down into a hierarchy It shows the levels of interactivity with the hardware of the computer Higher up: Less interaction Lower down: More interaction User Application Software Achieve non-computer specific tasks Real-world activities System Software Operate / interact with hardware Computer-centred functions Specific Tasks Hardware Computers: Classification of Software

The computer is a physical device, with: Mechanics and electronics Which operate and power software And all its components come together into a single system Components of a Computer Power supply Heart Processor, Memory, Secondary Storage Brain Interfaces - I/O Devices, such as Peripherals Senses – Sight, Sound, Smell, Taste, Touch Interface Controllers Muscles and Nerves Inside the shell of a digital computer, several physical components are required to allow it to think, to compute and calculate, to remember, and to interact with you, its user. Hardware is the means by which our computers operate and power their software. Computers: Classification of Software

The physical components of a computer are hardware The programs we interact with are software They are virtual They do not exist in physical space They are constructed from 1’s and 0’s on the computer Computers: Classification of Software

The Computer Mind Operate using hardware / systems Enables App Software to perform tasks Allows user interaction / use (Filter, process, store info, learn, behave and control connected devices) … Real-world Activities Takes instructions from user, passes to System Enables users to perform tasks (Writing, Calculating, Navigating, Designing)  SYSTEM Software can be two things. Firstly, it is the mind of the computer – the means by which we operate and control the hardware of a computer. The “how”. How they filter and process and store information. How they learn, behave, and control connected devices. This mind is known as System Software, and it provides a user with a means of using / interacting with the hardware of the computer. The second kind of software is known as Application Software and this allows us, the users, to apply our computers to real-world activities. Anything we can apply our minds to, we want our computers to help us achieve. Whether it’s writing a letter, a quotation for work, a novel, completing homework, calculating a mathematical equation or an employee’s salary. Even driving is becoming an activity controlled by a specific application. Application Software allows us, the users, to apply our computers to real world problems. APPLICATION  Computers: Classification of Software

Computers: Classification of Software
System Software User Application Software Achieve non-computer specific tasks Real-world activities System Software Operate / interact with hardware Computer-centred functions Specific Tasks Let’s have a look now at System Software. Remember that System software is essential to allow us to interact with the hardware of our computers. They: Manage and control the hardware Enable app software to perform tasks Hardware Computers: Classification of Software

System Software Contains a few subsets of software Operating Systems Utility Programs Library Programs Translator Programs They each perform a very specific function on the computer Let’s take a look at them one-by-one Computers: Classification of Software

System Software: Operating Systems
Lets us keep the hardware separate/independent from the programs we run Makes hardware useable by programs (on the Application level) The user interacts with applications Applications talk to the operating system The operating systems doles out hardware resources as needed Acts as resource management for the rest of the programs The Operating system software is the most important part of System software, as it is specifically the interface between us, the users, and the hardware. Without the Operating system, users would have a very difficult time trying to communicate with the hardware in order to get it to do anything. Operating systems are designed to make communication between human and hardware easy and they do this by making use of existing devices to communicate our intentions to the hardware and show us what the computer is doing. Application software is then run on the operating system, and the operating system provides, again, an interface with the hardware. Bear in mind that applications programmed to run on a particular operating system may not be used on another. The operating system creates a platform upon which these interfaces work. Because of this there are a lot of things that the user does not see or have to worry about. The Operating System takes care of a lot of ‘behind the scenes’ operations, without which would be onerous on the user. For example, a user tells the operating system what file to delete, and the operating system tells the hardware how to delete it, where to delete it from in memory. The operating system interprets the commands and issues the hardware with instructions. Other essential resource management tasks include clearing memory, tidying up after crashed programs, even loading the right program files at the right times. Examples Include Windows, OSX, Linux distributions (Debian, Ubuntu, etc.) Computers: Classification of Software

System Software: Utility Programs
Performs very small, specific operations Lack extra functionality and interactive behaviour Helps maintain the smooth-running of the system Employed by the Operating System Utility Programs are designed to carry out a particular task or function on a computer. They are small, discrete programs, with limited operational capability. Which means that they only ever perform the jobs they were designed to do, be it formatting a hard disk, or compressing a file; deleting empty folders, defragmenting a hard drive, or catching a system error and attempting to diagnose or repair the situation. There is a single utility to carry out each of these tasks. Although Utilities lack extra functionality or interactive behaviour, their capability works towards the smooth-running of the system. The Operating System employs Utilities to maintain and configure itself and the hardware, and to keep tabs on data transmissions. Not all Utilities come with an Operating System. For example, anti-virus or spybot programs must be purchased or downloaded separately as they are supplied by companies other than that which created the Operating System. File management, Problem diagnosis & repair, System information Computers: Classification of Software

System Software: Library Programs
Centralised Repository or Catalogue Similar to Utility Programs Discrete sequences of programmed routines Collection of common functions Used by more than one software program Dynamic-Link Library Less coding, less storage, one update Library programs are similar to Utility Programs: They are small, discrete programs Perform a particular function However, unlike Utility Programs, they are not executable programs in their own right. Instead they are discrete sequences of programmed routines which perform a particular function that may be used by more than one software program. In a computer several applications access the file system to load and save files, or send files to a printer, or even cut, copy and paste text, pictures or other data. By storing the printing and file system functions as libraries, instead of including them within other programs, saves on space and time. Microsoft’s Dynamic-Link Library is one example: A library of common files that are shared by multiple, separate executable files to save the programmer time when coding, and to save space on storing the extra code. When changes are needed to the way in which a particular function, such as printing, needs to be coded, for example, due to a security update on the Operating System, only one file needs to be updated, instead of every executable that carries out that task. Data: Cut, Copy, and Paste File System: File  Open, File  Save Printing: File  Print Computers: Classification of Software

System Software: Translator Programs
Handle conversion Input: Takes program statements Translates one language into another Three types of Translators Assembler Interpreter Compiler The final type of System software is Translator software, which literally enables communication between humans and computers by translating what we want to do into a form that computers can understand. Translators take programmed code that exist in a specific programming language, in the form of instruction statements, and they translate them into a binary form that a computer will understand. Namely: Machine Code. Without this translation there can be no communication between us and the machines. There are three types of Translators: Assembler Interpreter Compiler We will cover these in greater detail a little later. Computers: Classification of Software

Application Software User Application Software Achieve non-computer specific tasks Real-world activities System Software Operate / interact with hardware Computer-centred functions Specific Tasks Let’s have a look now at Application Software. Remember that Application software is reliant upon the Operating System it is installed on. Only Application Software programmed to run on a particular Operating System will be installable. This is because the Operating System enables and manages the communication between the installed Applications and the hardware. Hardware Computers: Classification of Software

Application Software Real-world Activities Three Types of Applications
User instructs Application Application instructs System Software System Software instructs Hardware Three Types of Applications General-purpose Applications Special-purpose Applications Bespoke Applications If System Software operates within the computer world, removing all the complexity, Application Software enables us to complete real-world activities using the processing power of computers. Computers were originally designed to compute large and boring mathematical calculations. However, their everyday usage in the modern era tends to be with general day-to-day activities that used to, and still can be carried out within computers. Applications take our instructions and pass them onto the System Software for management. It is the System Software which then instructs the hardware. Application Software. falls into three categories: General-purpose Applications Special-purpose Applications Bespoke Applications Computers: Classification of Software

Application Software: General Use
Description Common set of functions Applied to many different activities Word Processing: Letters, User guides, Reports, Novels, Invoices, Flyers, Posters Spreadsheets: Manage figures, Data Collection, Stats Analysis, Generate Formulas, Output Charts and Tables General-purpose Applications are sometimes known as generic applications because they are capable of assisting users in a multitude of activities. They are often purchased in software bundles known as office suites, and their common functions can be used in many different ways. For example, a document application, such as the word processor Microsoft Word, is a text based program that allows users to create letters, user guides, reports, novels, invoices, flyers, posters, and much more. A spreadsheet application, such as Microsoft Excel, allows for the management of figures, the manipulation of statistics, the generation of formulas, and the output of charts and tables. These and the other applications that are often included in software bundles known as office suites are known as general purpose, or generic applications. Computers: Classification of Software

Application Software: Specific Use
Description Designed for one particular Activity One specific task or a set of linked tasks Accountancy: Sage, IRIS, Quicken CAD: AutoCAD, Autodesk, TurboCAD Web Browser: Internet Explorer, Firefox, Chrome, Safari Media Player: Windows Media, Quicktime, iTunes, RealPlayer, Winamp Special-purpose software, whilst purchased off the shelf like General-purpose software, is designed for a specific purpose. This means that its application has a narrow scope and it is focused on one activity alone. As with General-purpose software, Special-software has – again – been designed to replicate a real-world activity to make that real-world activity easier and faster. Be it a stock control system in a high-street store, a council’s database of road faults and repairs, the accounting package Sage, or Mozilla’s web browser, Firefox: a Special-purpose Application may only be utilised for the purpose it was designed for, and will be of no assistance in other areas. Computers: Classification of Software

Application Software: Bespoke Use
Description Commissioned / Made to order Written to suit specific client’s needs Very narrow scope of application Air Traffic Control Passport Application Support System Robot Control Smartcards Payroll system The software we’ve discussed so far has all been off-the-shelf applications: software designed to be used by lots of people in homes and businesses around the world. However, sometimes a business may want software that does a specific task, or works in a specific way, or achieves a particular outcome that no other software can. In this case a business will commission the creation of Bespoke software. This is far more expensive than buying off-the-shelf software because the burden of cost is covered by only one customer, or a consortium of customers. That software is then written as part of a development project that ascertains the client’s specific needs and tailors the application to do just that. Because of the constraints of time and cost, bespoke software is always designed and built to fulfil the minimum requirements that the user has specified, and therefore the purpose of the software cannot be applied to any other activity. One on-going development of bespoke software has been carried out by Siemens on behalf of Her Majesty’s Revenue and Customs (HMRC). Siemens have been replacing the existing passport control system with PASS (The Passport Application Support System), a project that has run for well over ten years, and cost £365m. Computers: Classification of Software

Programming Languages
Instructive Language Machine Code – Binary – 1s and 0s Computers take instructions Level Generation Paradigm History Languages Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code Second-generation 1950s – Transistors Assembly Code High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… Fourth-generation Declarative 1970s and on Prolog, SQL, HTML, Haskell System Software, Application Software, Utilities, Libraries and Translator programs have all had to be created, or programmed. This is because: Computers never do things for themselves The language of computers is nothing like the language of humans While we speak in letters and words, and even numbers. Computers are restricted to only understand the language of binary: 1s and 0s. These 1s and 0s are processed by the computer’s processor as instructions. Before we can do anything with a computer, a programmer needs to have recorded instructions for the computer. These instructions are coded using a programming language. But don’t assume that using a programming language is either easy or the end of the story. Over two-hundred years of computer and programming-language development has brought us to modern day computing. There are four established Generations of Programming Languages. A fifth does exist, but is neither consistent in its operation or established. The four generations we will cover have been developed as computers have evolved. Each subsequent generation has afforded programmers with greater flexibility and reduced complexity. Let’s have a look at the history… Computers: Classification of Software

Programming Languages: Generation 1
Level Generation Paradigm History Languages Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code Second-generation 1950s – Transistors Assembly Code High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… Fourth-generation Declarative 1970s and on Prolog, SQL, HTML, Haskell Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code Programming has been in steady development for some 200 years. Specifically, since 1801, when Joseph Marie Jacquard invented the Jacquard Loom, which used punch cards to represent the movements of the loom’s arms. Then with Charles Babbage’s proposed Difference and Analytical Engines in 1822 and 1837, which were meant to calculate polynomials and tabulate logarithms and trigonometric functions. Babbage’s work never came to fruition within his own lifetime due to the fact his machines were both hardware computers only, expensive to produce and ultimately suffered from conflicts between Babbage and his chief engineer, Joseph Clement, and a withdrawal of funding by the British government. Like Jacquard’s Loom, Babbage’s engines required punch cards for input operations, but instead of waving loom arms around, they could punch numbers onto cards to be read back in, or they would use a printer, a curve plotter, and a bell. It was only in the notes and translations by Ada Lovelace in 1842/3 however that Babbage’s machines would find their initial real use. Ada devised an algorithm which was encoded for processing by a machine, such as Babbage’s. Ada’s notes are said to be the world’s first computer program. At this time, Babbage’s design operated in base 10, or decimal. Computers: Classification of Software

Machine Code Low-level Language Electrical States: 1s and 0s (Base 2) States represent data and instructions Machine Code is lowest level of instruction No translation Instructions tell the microprocessor What data to put into registers How to manipulate data when it’s there Electricity Light = 1 = 0 A leap of 100 years and the introduction of the first computers during the late 1930s and early 1940s consolidated their basic language as machine code, or binary. That meant that they could understand and operate in base 2 (they understood 1s and 0s). This is known as Machine Code, which is the lowest level of instruction. Machine Code came about because of two things: The work of George Boole (in 1854) who developed Boolean Algebra as a springboard from Aristotle’s proposals about the truth of statements The fact the first computers used Vacuum tubes to register instructions and data. Vacuum tubes literally could only switch between on (1) and off (0). The 1 represented current flowing through the vacuum tube, and a 0 represented no current Again, the computers of the 1940s had no real means of showing users what they had computed, and at first relied upon punch cards, before the programmers could set the Vacuum tubes by hand. Machine Code was laborious to program however, and filled with errors. Teams of programmers took days to program simple tasks such as sorting lists of names. If there was one error, days would be wasted and the programmers had to start all over. The computers of the 1940s were programmed to compute ballistic firing tables, weather predictions and many other scientific uses. The first-generation languages of Machine Code are the most basic unit of instruction possible and therefore are the lowest low-level language available. Several iterations of machine code exist, because different processor families have been produced with their own machine language. As well as binary, hexadecimal coding could be used on some, but this too shares the same drawbacks. Computers: Classification of Software

Level Generation Paradigm History Languages Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code Second-generation 1950s – Transistors Assembly Code High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… Fourth-generation Declarative 1970s and on Prolog, SQL, HTML, Haskell Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code second-generation 1950s - Transistors Assembly Code Computers: Classification of Software

Assembly Language Developed in the 1950s Benefits: Slightly easier to understand, correct errors and code Bridge gap between humans and machines Mnemonic Codes One-to-one translation with Machine Code General algorithms reduce repetition of code Machine dependent (like Machine Code) Assembly languages are easier to program in than first-generation machine code, because they allow the programmer to code in words rather than the restrictive 1s and 0s. These second generation languages helped to bridge the gap between the languages of humans and machines. Although Assembly Code is no less laborious it is slightly less troubling when errors are produced. At this time computer programs were able to be stored, and therefore days were no longer needed to program them. Errors could be corrected far more easily. At the time of processing by the computer the Assembly Language had to be translated into Machine Code, which was done using an assembler. Whilst Assembly languages are structured in the same way as the bytes of machine code – one assembly instruction translates to one machine code instruction – assembly languages use mnemonic codes instead of binary values. A mnemonic is a memory aide, or way of remembering something. The mnemonics of Assembly language are abbreviated code words for certain functions, such as adding values together, storing or retrieving them from memory registers, or returning them to the user. The almost one-to-one translation of assembly mnemonics to machine code instructions allows very fast execution of code, and is still used when programming mobile phones and device drivers today. The code is cleaner and more efficient. Assembly language was not designed just for the interest of aiding clarity. Assembly language helped to begin the trend towards reducing code repetition, by creating general algorithms that could be typed in far less lines of code. Assembly Language, like Machine Code, is machine dependent because each one has been specifically designed for a particular microprocessor or CPU. For example, the Assembly Language of an Intel x86 CPU is written in “X86 Assembler”, and is a very different language to the Assembly Language used on a Motorola CPU. Computers: Classification of Software

Level Generation Paradigm History Languages Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code Second-generation 1950s – Transistors Assembly Code High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… Fourth-generation Declarative 1970s and on Prolog, SQL, HTML, Haskell Low-level Imperative second-generation 1950s - Transistors Assembly Code High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… While Low-level languages are close to the language of computers, high-level languages are close to the language of humans (they make more sense to us). High-level languages took a further decade of development and have progressed up through the 1980s. They are less reliant upon the evolution of the hardware and the programs they generate are only dependent upon instruction speed. Third-generation languages built upon the procedural structure of the low-level languages and expanded the accessibility and functionality of programming. Although they take longer to compute than the low-level languages, and lack the efficiency of code, they are centred on the usability by the programmer and not the restrictions of the machine code. Computers: Classification of Software

Developed from the 1950s onwards Real-world problems Much easier to understand, correct errors and code Bridge gap between humans and machines Algorithmic and formula-like Hides low-level functions (memory storage) General algorithms reduce repetition of code More code means Less efficient Reliability reliant on low-level coders This is an example of BASIC Third-generation languages are broadly used in multiple disciplines, from scientific and engineering, to business and production, system software, and applications. Their introduction came about to solve more types of problems, and to reduce the laborious effort required to program in assembly and machine code. Third-level languages therefore bridge the gap between the programmer and the computer by managing all the low-level functions that the code tells the computer to perform. The structure of third-generation languages requires more code than would otherwise be necessary in the lower level languages, and so one line of third-generation code is now equivalent to several machine code statements. Efficiency is lost, but because the design of third-generation languages removes all low-level functions, it removes much of the repetitive code required for low-level languages. This is the trade off. High-level languages are oriented around procedures to tell the computer how to carry out a particular task, with much of the repetition removed to the back end. The drawback is that high-level programmers are reliant upon the ability of previous coders. For example, errors in an Operating System may not crop up until a high-level application tries to utilise that code in a specific way, such as an incorrectly assigned memory location. More can go wrong in high-level languages because lower levels are controlling memory and components. Computers: Classification of Software

Level Generation Paradigm History Languages Low-level First-generation Imperative 1801 – Loom 1822 – Babbage 1940s – Vacuum Tubes Punch Cards Machine Code Second-generation 1950s – Transistors Assembly Code High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… Fourth-generation Declarative 1970s and on Prolog, SQL, HTML, Haskell Imperative High-level Third-generation 1950s and on – Home Computers Fortran, Lisp, COBOL, Pascal, C, VB, Delphi… Finally, fourth-generation languages allow for direct and faster programming in specific environments. This is due to the Declarative nature of fourth-generation languages. Fourth-generation Declarative 1970s and on Prolog, SQL HTML, Haskell Computers: Classification of Software

Developed 1970s to 1980s Declarative – “What I want” Application Development Tools English-like (Natural Languages) Problem oriented Specify relationships between objects rather than coding each object separately This generation is the one most commonly used today! Developed during the 1970s and 1980s, fourth generation languages empower programmers to change the way they talked to computers. First to third-generation languages are known as Imperative programming languages. The instructions of their code explains to the computer how to execute a function or calculation. Declarative programming languages, such as HTML and SQL explain what is computed, based upon stated facts. In databases, when using SQL, a programmer does not create code that describes how to create a table, and how to iterate through rows, and how to add, change or delete content. The programmer simply declares: I want to create this table, I want to search for this particular item, and I want to add, or change or delete this particular content. Fourth-generation languages achieve this because standard algorithms that produce those functions have been created within the language. This is the highest-level language available and is prolific in application development tools specifically because of this “What” nature. It is most like human language and focuses upon the problem at hand. Computers: Classification of Software

Low-Level vs High-Level
Pros Structured Efficient Fast execution Direct access to hardware, esp. memory Pros Removes complexity of communicating with the hardware Hides laborious and non-essential tasks Easier to understand and debug Faster to code Cons Difficult to understand Laborious to code Prone to errors Versions differ between processor families Cons Slower to compile / interpret Loss of efficiency Reliant on lower levels Computers: Classification of Software

Translating to Hardware
User Application Software Achieve non-computer specific tasks Real-world activities System Software Operate / interact with hardware Computer-centred functions Specific Tasks The further we move away from the low-level language of Machine Code, the greater the increase in the language barrier. Which is why Program Translators are necessary to translate our high-level languages down. As we touched upon earlier, in order for us, the user, to avoid the complexity of communicating directly with a computer we use an operating system. As much as we shout and scream at our computers, unless we’re using an operating system, the majority of us will never get a computer to do what we want and it will never teach us that it has feelings too. Hardware Computers: Classification of Software

Translating to Hardware
Communication with hardware Distribution of software Computer Processor Programmer Third / Fourth Gen Language Assembly Language Machine Code Assembler Compiler Object Code Interpreter This is because the language of computers is machine code. The binary language of 1s and 0s. All programs, regardless of the operating platform or the computer architecture, must be translated into machine code before it can be executed by a computer. There are three types of translators: Assembler Compiler Interpreter Both an Assembler and a Compiler take a program and translate it into machine code. However, only an Assembler can convert code programmed in assembly language to machine code, and only a compiler can compile from the high-level language a code has been programmed in to machine code. Why the names assembler and compiler? These originate from the fact that Assembly language is the most basic form of programing besides coding in machine code. So, the Assembler assembles Machine Code from the Assembly language. Remember that the structure of assembly code generally matches the structures of machine code, so the translation between the mnemonics of assembly language to binary machine code is quick and simple. A high-level language is several steps removed from machine code because it is easier to understand and program in. The drawbacks being that the code in a high-level language takes up a lot more space and processing time than machine code or assembly language. The Compiler therefore translates and optimises high-level code to create a simplified package of object code. The object code can be executed swiftly whenever it is needed. The executable program therefore does not require the presence of a compiler every time it is run. The third type of translator is an Interpreter, which, rather than compiling or assembling object code for use whenever, wherever, translates each line of code one at a time, executes that line and then moves on to the next. This is useful for debugging a program, but means that execution is slower, only the current line of code is currently interpreted (meaning we have lost the previous line) and the code always requires the program to be run through the interpreter. For the everyday programmer, the Interpreter and the Compiler make easy use of high-level languages. The Interpreter saves the need to repeatedly compile a program during debugging of the code, and the Compiler provides a ready packaged executable that cannot be interfered with by users – although program do exist to reverse object code back into their original language. Computers: Classification of Software

Compiling, Interpreting, and Assembling
There is a difference between Compiling, Interpreting, and Assembling Compiling: the original program is translated into native machine code (executed by the CPU) Interpreting: the original program is translated into an “in-between” language, which is then examined and run in various formats Assembling: translates assembly instructions into machine code – part of the Compilation process Computers: Classification of Software

Some programming languages are compiled, while other languages are interpreted Compiled Languages: C, Pascal, BASIC Interpreted Languages: Python, Java, .NET Languages Compiled languages and interpreted languages will be run differently Computers: Classification of Software

When compiling a language, we always have the before and after Before: the source code (C, for example) After: the object code The source code is the more permanent work (as we often work directly on it) When source code is compiled, it creates object code This object code is run on the hardware (CPU) Computers: Classification of Software

This object code is often what we run on a computer The executable form Most programs/applications come purely in their object code form Means we can’t change how they work They code they create stays ‘secret’ However, changes have been made recently in open source programs Programs come with object code and source code Computers: Classification of Software

When interpreting, we end up with something slightly different First, interpreting source code gives some intermediate code An example being bytecode Second, interpreting happens at runtime Source code is interpreted line-by-line while it is being run This bytecode is often executed by another program Overall making execution slower than compilation Computers: Classification of Software

Classification of Software

Similar presentations

Presentation on theme: "Classification of Software"— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Classification of Software

Similar presentations

Presentation on theme: "Classification of Software"— Presentation transcript:

Similar presentations

About project

Feedback