Polytechnic University of the Philippines

College of Tourism, Hospitality and Transportation Management

Department of Hospitality Management

SOFTWARE
(REPORT)

Presented by:
GROUP 3
Alday, Rizaldo
Batingan, Ellaine Mariane
Caande, Jaeshel Anne
Pabillare, Angelica
Peconada, Rizza
Serrato, Lemuel

Presented to:
Mr. Marc Anthony Bautista

Computer Software Definition

Software is a generic term for organized collections of computer data and instructions, often broken into
two major categories: system software that provides the basic non-task-specific functions of the computer,
and application software which is used by users to accomplish specific tasks.
System software is responsible for controlling, integrating, and managing the individual hardware
components of a computer system so that other software and the users of the system see it as a functional
unit without having to be concerned with the low-level details such as transferring data from memory to
disk, or rendering text onto a display. Generally, system software consists of an operating system and
some fundamental utilities such as disk formatters, file managers, display managers, text editors, user
authentication (login) and management tools, and networking and device control software.
Application software, on the other hand, is used to accomplish specific tasks other than just running the
computer system. Application software may consist of a single program, such as an image viewer; a small
collection of programs (often called a software package) that work closely together to accomplish a task,
such as a spreadsheet or text processing system; a larger collection (often called a software suite) of
related but independent programs and packages that have a common user interface or shared data format,
such as Microsoft Office, which consists of closely integrated word processor, spreadsheet, database, etc.;
or a software system, such as a database management system, which is a collection of fundamental
programs that may provide some service to a variety of other independent applications.
Software is created with programming languages and related utilities, which may come in several of the
above forms: single programs like script interpreters, packages containing a compiler, linker, and other
tools; and large suites (often called Integrated Development Environments) that include editors,
debuggers, and other tools for multiple languages.

2.1 Operating system

An operating system is the most important software that runs on a computer. It manages the
computer's memory and processes, as well as all of its software and hardware. It also allows you
to communicate with the computer without knowing how to speak the computer's language. Without an
operating system, a computer is useless.

The operating system's job

Your computer's operating system (OS) manages all of the software and hardware on the computer. Most
of the time, there are several different computer programs running at the same time, and they all need to
access your computer's central processing unit (CPU), memory, and storage. The operating system
coordinates all of this to make sure each program gets what it needs.

Types of operating systems

Operating systems usually come pre-loaded on any computer you buy. Most people use the operating
system that comes with their computer, but it's possible to upgrade or even change operating systems. The
three most common operating systems for personal computers are Microsoft Windows, Mac OS X,
and Linux.
Modern operating systems use a graphical user interface, or GUI (pronounced gooey). A GUI lets you use
your mouse to click icons, buttons, and menus, and everything is clearly displayed on the screen using a
combination of graphics and text.
Each operating system's GUI has a different look and feel, so if you switch to a different operating system
it may seem unfamiliar at first. However, modern operating systems are designed to be easy to use, and
most of the basic principles are the same.

2.2 Application Software

An application program (app or application for short) is a computer program designed to perform a
group of coordinated functions, tasks, or activities for the benefit of the user. Examples of an application
include a word processor, a spreadsheet, an accounting application, a web browser, a media player, an
aeronautical flight simulator, a console game or a photo editor. The collective noun application
software refers to all applications collectively. This contrasts with system software, which is mainly
involved with running the computer.
Applications may be bundled with the computer and its system software or published separately, and may
be coded as proprietary, open-source or university projects. Apps built for mobile platforms are
called mobile apps.

Classification
There are many different ways to divide up different types of application software, and several are
explained here.
Since the development and near-universal adoption of the web, an important distinction that has emerged
has been between web applications written with HTML, JavaScript and other web-native technologies
and typically requiring one to be online and running a web browser, and the more traditional native
applications written in whatever languages are available for one's particular type of computer. There has
been contentious debate in the computing community regarding web applications replacing native
applications for many purposes, especially on mobile devices such as smart phones and tablets. Web apps

have indeed greatly increased in popularity for some uses, but the advantages of applications make them
unlikely to disappear soon, if ever. Furthermore, the two can be complementary, and even integrated.
Application software can also be seen as being either horizontal or vertical. Horizontal applications are
more popular and widespread, because they are general purpose, for example word processors or
databases. Vertical applications are niche products, designed for a particular type of industry or business,
or department within an organization. Integrated suites of software will try to handle every specific aspect
possible of, for example, manufacturing or banking systems, or accounting, or customer service.
There are many types of application software:

An application suite consists of multiple applications bundled together. They usually have related
functions, features and user interfaces, and may be able to interact with each other, e.g. open each
other's files. Business applications often come in suites, e.g. Microsoft
Office, LibreOffice and iWork, which bundle together a word processor, a spreadsheet, etc.; but suites
exist for other purposes, e.g. graphics or music.

Enterprise software addresses the needs of an entire organization's processes and data flows,
across several departments, often in a large distributed environment. Examples include enterprise
resource planning systems, customer relationship management (CRM) systems and supply chain
management software. Departmental Software is a sub-type of enterprise software with a focus on
smaller organizations and/or groups within a large organization. (Examples include travel expense
management and IT Helpdesk.)

Enterprise infrastructure software provides common capabilities needed to support

enterprise software systems. (Examples include databases, email servers, and systems for managing
networks and security.)

Information worker software lets users create and manage information, often for individual
projects within a department, in contrast to enterprise management. Examples include time
management, resource management, analytical, collaborative and documentation tools. Word
processors, spreadsheets, email and blog clients, personal information system, and individual media
editors may aid in multiple information worker tasks.

Content access software is used primarily to access content without editing, but may include
software that allows for content editing. Such software addresses the needs of individuals and groups
to consume digital entertainment and published digital content. (Examples include media
players, web browsers, and help browsers.)

Educational software is related to content access software, but has the content and/or features
adapted for use in by educators or students. For example, it may deliver evaluations (tests), track
progress through material, or include collaborative capabilities.

Simulation software simulates physical or abstract systems for either research, training or
entertainment purposes.

Media development software generates print and electronic media for others to consume, most
often in a commercial or educational setting. This includes graphic-art software, desktop publishing
software, multimedia development software, HTML editors, digital-animation editors, digital audio
and video composition, and many others.[12]

Product engineering software is used in developing hardware and software products. This
includes computer-aided design (CAD), computer-aided engineering (CAE), computer language
editing and compiling tools, integrated development environments, and application programmer
interfaces.

Entertainment Software can refer to video games, screen savers, programs to display motion
pictures or play recorded music, and other forms of entertainment which can be experienced through
use of a computing device.

Applications can also be classified by computing platform such as a particular operating system, delivery
network such as in cloud computing and Web 2.0 applications, or delivery devices such as mobile
apps for mobile devices.
The operating system itself can be considered application software when performing simple calculating,
measuring, rendering, and word processing tasks not used to control hardware via command-line
interface or graphical user interface. This does not include application software bundled within operating
systems such as a software calculator or text editor.

2.3 Programming Language Software

A programming language is a formal computer language or constructed language designed to
communicate instructions to a machine, particularly a computer. Programming languages can be used to
create programs to control the behavior of a machine or to express algorithms.
The earliest known programmable machine preceded the invention of the digital computer and is the
automatic flute player described in the 9th century by the brothers Musa in Baghdad, "during the Islamic

Golden Age". From the early 1800s, "programs" were used to direct the behavior of machines such
as Jacquard looms and player pianos. Thousands of different programming languages have been created,
mainly in the computer field, and many more still are being created every year. Many programming
languages require computation to be specified in an imperative form (i.e., as a sequence of operations to
perform), while other languages use other forms of program specification such as the declarative form
(i.e. the desired result is specified, not how to achieve it).
The description of a programming language is usually split into the two components of syntax (form)
and semantics (meaning). Some languages are defined by a specification document (for example,
the C programming language is specified by an ISO Standard), while other languages (such as Perl) have
a dominant implementation that is treated as a reference. Some languages have both, with the basic
language defined by a standard and extensions taken from the dominant implementation being common.

Definitions
A programming language is a notation for writing programs, which are specifications of a computation
or algorithm. Some, but not all, authors restrict the term "programming language" to those languages that
can express all possible algorithms. Traits often considered important for what constitutes a programming
language include:

Function and target

A computer programming language is a language used to write computer programs, which involve
a computer performing some kind of computation or algorithm and possibly control external devices such
as printers, disk drives, robots, and so on. For example, PostScript programs are frequently created by
another program to control a computer printer or display. More generally, a programming language may
describe computation on some, possibly abstract, machine. It is generally accepted that a complete
specification for a programming language includes a description, possibly idealized, of a machine or
processor for that language. In most practical contexts, a programming language involves a computer;
consequently, programming languages are usually defined and studied this way. Programming languages
differ from natural languages in that natural languages are only used for interaction between people, while
programming languages also allow humans to communicate instructions to machines.

Abstractions
Programming languages usually contain abstractions for defining and manipulating data structures or
controlling the flow of execution. The practical necessity that a programming language support adequate

abstractions is expressed by the abstraction principle; this principle is sometimes formulated as a

recommendation to the programmer to make proper use of such abstractions.

Expressive power
The theory of computation classifies languages by the computations they are capable of expressing.
All Turing complete languages can implement the same set of algorithms. ANSI/ISO SQL92 and Charity are examples of languages that are not Turing complete, yet often called programming
languages.
Markup languages like XML, HTML or troff, which define structured data, are not usually considered
programming languages. Programming languages may, however, share the syntax with markup languages
if a computational semantics is defined. XSLT, for example, is a Turing complete XML dialect.
Moreover, LaTeX, which is mostly used for structuring documents, also contains a Turing complete
subset.
The term computer language is sometimes used interchangeably with programming language. However,
the usage of both terms varies among authors, including the exact scope of each. One usage describes
programming languages as a subset of computer languages. In this vein, languages used in computing that
have a different goal than expressing computer programs are generically designated computer languages.
For instance, markup languages are sometimes referred to as computer languages to emphasize that they
are not meant to be used for programming.
Another usage regards programming languages as theoretical constructs for programming abstract
machines, and computer languages as the subset thereof that runs on physical computers, which have
finite hardware resources.[24] John C. Reynolds emphasizes that formal specification languages are just as
much programming languages as are the languages intended for execution. He also argues that textual and
even graphical input formats that affect the behavior of a computer are programming languages, despite
the fact they are commonly not Turing-complete, and remarks that ignorance of programming language
concepts is the reason for many flaws in input formats.

Elements
All programming languages have some primitive building blocks for the description of data and the
processes or transformations applied to them (like the addition of two numbers or the selection of an item
from a collection). These primitives are defined by syntactic and semantic rules which describe their
structure and meaning respectively.

Syntax

Syntax highlighting is often used to aid programmers in recognizing elements of source code. The
language above is Python.
A programming language's surface form is known as its syntax. Most programming languages are purely
textual; they use sequences of text including words, numbers, and punctuation, much like written natural
languages. On the other hand, there are some programming languages which are more graphical in nature,
using visual relationships between symbols to specify a program.
The syntax of a language describes the possible combinations of symbols that form a syntactically correct
program. The meaning given to a combination of symbols is handled by semantics (either formal or hardcoded in a reference implementation). Since most languages are textual, this article discusses textual
syntax.

Programming language syntax is usually defined using a combination of regular

expressions (for lexical structure) and BackusNaur Form (for grammatical structure). Below is a simple
grammar, based on Lisp:

expression ::= atom | list

atom
::= number | symbol
number ::= [+-]?['0'-'9']+
symbol ::= ['A'-'Z''a'-'z'].*
list
::= '(' expression* ')'

This grammar specifies the following:

an expression is either an atom or a list;

an atom is either a number or a symbol;

a number is an unbroken sequence of one or more decimal digits, optionally preceded by a plus or
minus sign;

a symbol is a letter followed by zero or more of any characters (excluding whitespace); and

a list is a matched pair of parentheses, with zero or more expressions inside it.

The following are examples of well-formed token sequences in this grammar: 12345 , () and (a b c232
(1)) .
Not all syntactically correct programs are semantically correct. Many syntactically correct programs are
nonetheless ill-formed, per the language's rules; and may (depending on the language specification and
the soundness of the implementation) result in an error on translation or execution. In some cases, such
programs may exhibit undefined behaviour. Even when a program is well-defined within a language, it
may still have a meaning that is not intended by the person who wrote it.
Using natural language as an example, it may not be possible to assign a meaning to a grammatically
correct sentence or the sentence may be false:

"Colorless green ideas sleep furiously." is grammatically well-formed but has no generally
accepted meaning.

"John is a married bachelor." is grammatically well-formed but expresses a meaning that cannot
be true.

The following C language fragment is syntactically correct, but performs operations that are not
semantically defined (the operation *p >> 4 has no meaning for a value having a complex type and p>im is not defined because the value of p is the null pointer):

complex *p = NULL;
complex abs_p = sqrt(*p >> 4 + p->im);

If the type declaration on the first line were omitted, the program would trigger an error on compilation,
as the variable "p" would not be defined. But the program would still be syntactically correct, since type
declarations provide only semantic information.
The grammar needed to specify a programming language can be classified by its position in the Chomsky
hierarchy. The syntax of most programming languages can be specified using a Type-2 grammar, i.e., they
are context-free grammars. Some languages, including Perl and Lisp, contain constructs that allow
execution during the parsing phase. Languages that have constructs that allow the programmer to alter the
behaviour of the parser make syntax analysis an undecidable problem, and generally blur the distinction
between parsing and execution. In contrast to Lisp's macro system and Perl's BEGIN blocks, which may
contain general computations, C macros are merely string replacements, and do not require code
execution.

Semantics
The term Semantics refers to the meaning of languages, as opposed to their form (syntax).
The static semantics defines restrictions on the structure of valid texts that are hard or impossible to
express in standard syntactic formalisms.[3] For compiled languages, static semantics essentially include
those semantic rules that can be checked at compile time. Examples include checking that
every identifier is declared before it is used (in languages that require such declarations) or that the labels
on the arms of a case statement are distinct.[46] Many important restrictions of this type, like checking that
identifiers are used in the appropriate context (e.g. not adding an integer to a function name), or
that subroutine calls have the appropriate number and type of arguments, can be enforced by defining
them as rules in a logic called a type system. Other forms of static analyses like data flow analysis may

also be part of static semantics. Newer programming languages like Java and C# have definite assignment
analysis, a form of data flow analysis, as part of their static semantics.

Dynamic semantics
Once data has been specified, the machine must be instructed to perform operations on the data. For
example, the semantics may define the strategy by which expressions are evaluated to values, or the
manner in which control structures conditionally execute statements. The dynamic semantics (also known
as execution semantics) of a language defines how and when the various constructs of a language should
produce a program behaviour. There are many ways of defining execution semantics. Natural language is
often used to specify the execution semantics of languages commonly used in practice. A significant
amount of academic research went into formal semantics of programming languages, which allow
execution semantics to be specified in a formal manner. Results from this field of research have seen
limited application to programming language design and implementation outside academia.

Type system
A type system defines how a programming language classifies values and expressions into types, how it
can manipulate those types and how they interact. The goal of a type system is to verify and usually
enforce a certain level of correctness in programs written in that language by detecting certain incorrect
operations. Any decidable type system involves a trade-off: while it rejects many incorrect programs, it
can also prohibit some correct, albeit unusual programs. In order to bypass this downside, a number of
languages have type loopholes, usually unchecked casts that may be used by the programmer to explicitly
allow a normally disallowed operation between different types. In most typed languages, the type system
is used only to type check programs, but a number of languages, usually functional ones, infer types,
relieving the programmer from the need to write type annotations. The formal design and study of type
systems is known as type theory.

Typed versus untyped languages

A language is typed if the specification of every operation defines types of data to which the operation is
applicable, with the implication that it is not applicable to other types. For example, the data represented
by "this text between the quotes" is a string, and in many programming languages dividing a number by
a string has no meaning and will be rejected by the compilers. The invalid operation may be detected
when the program is compiled ("static" type checking) and will be rejected by the compiler with a
compilation error message, or it may be detected when the program is run ("dynamic" type checking),

resulting in a run-time exception. Many languages allow a function called an exception handler to be
written to handle this exception and, for example, always return "-1" as the result.
A special case of typed languages are the single-type languages. These are often scripting or mark-up
languages, such as REXX or SGML, and have only one data typemost commonly character strings
which are used for both symbolic and numeric data.
In contrast, an untyped language, such as most assembly languages, allows any operation to be performed
on any data, which are generally considered to be sequences of bits of various lengths. [47] High-level
languages which are untyped include BCPL, Tcl, and some varieties of Forth.
In practice, while few languages are considered typed from the point of view of type theory (verifying or
rejecting all operations), most modern languages offer a degree of typing. Many production languages
provide means to bypass or subvert the type system, trading type-safety for finer control over the
program's execution.

Static versus dynamic typing

In static typing, all expressions have their types determined prior to when the program is executed,
typically at compile-time. For example, 1 and (2+2) are integer expressions; they cannot be passed to a
function that expects a string, or stored in a variable that is defined to hold dates.
Statically typed languages can be either manifestly typed or type-inferred. In the first case, the
programmer must explicitly write types at certain textual positions (for example, at variable declarations).
In the second case, the compiler infers the types of expressions and declarations based on context. Most
mainstream statically typed languages, such as C++, C# and Java, are manifestly typed. Complete type
inference has traditionally been associated with less mainstream languages, such as Haskell and ML.
However, many manifestly typed languages support partial type inference; for example, Java and C#both
infer types in certain limited cases.[48] Additionally, some programming languages allow for some types to
be automatically converted to other types; for example, an int can be used where the program expects a
float.
Dynamic typing, also called latent typing, determines the type-safety of operations at run time; in other
words, types are associated with run-time values rather than textual expressions.[47] As with type-inferred
languages, dynamically typed languages do not require the programmer to write explicit type annotations
on expressions. Among other things, this may permit a single variable to refer to values of different types
at different points in the program execution. However, type errors cannot be automatically detected until a

piece of code is actually executed, potentially making debugging more difficult. Lisp,
Smalltalk, Perl, Python, JavaScript, and Ruby are dynamically typed.

Weak and strong typing

Weak typing allows a value of one type to be treated as another, for example treating a string as a number.
This can occasionally be useful, but it can also allow some kinds of program faults to go undetected
at compile time and even at run time.
Strong typing prevents the above. An attempt to perform an operation on the wrong type of value raises an
error. Strongly typed languages are often termed type-safe or safe.
An alternative definition for "weakly typed" refers to languages, such as Perl and JavaScript, which
permit a large number of implicit type conversions. In JavaScript, for example, the expression 2 *
x implicitly converts x to a number, and this conversion succeeds even if x is null , undefined ,
an Array , or a string of letters. Such implicit conversions are often useful, but they can mask
programming errors. Strong and static are now generally considered orthogonal concepts, but usage in the
literature differs. Some use the term strongly typed to mean strongly, statically typed, or, even more
confusingly, to mean simply statically typed. Thus C has been called both strongly typed and weakly,
statically typed.
It may seem odd to some professional programmers that C could be "weakly, statically typed". However,
notice that the use of the generic pointer, the void* pointer, does allow for casting of pointers to other
pointers without needing to do an explicit cast. This is extremely similar to somehow casting an array of
bytes to any kind of datatype in C without using an explicit cast, such as (int) or (char) .

2.3.1 Flowchart Symbols

Flowcharts use special shapes to represent different types of actions or steps in a process. Lines and
arrows show the sequence of the steps, and the relationships among them. These are known as flowchart
symbols.
The type of diagram dictates the flowchart symbols that are used. For example, a data flow diagram may
contain an Input/ Output Symbol (also known as an I/O Symbol), but you wouldn't expect to see it in
most process flow diagrams.

Over the years, as technology has evolved, so has flowcharting. Some flowchart symbols that were used
in the past to represent computer punchcards, or punched tape, have been relegated to the dustbin of
history.

More

Flowchart
Symbols

Here is

a more
comprehensive

library

of flowchart
symbols.

Start/End
Symbol
The

terminator

symbol

marks the

starting

or ending point

of the

system. It

usually

contains the

word

"Start" or

"End."

Action or Process Symbol

A box can represent a single step ("add two cups of flour"), or and entire sub-process ("make bread")
within a larger process.

Document Symbol
A printed document or report.

Multiple Documents Symbol

Represents multiple documents in the process.

Decision Symbol
A decision or branching point. Lines representing different decisions emerge from different points of the
diamond.

Input/ Output Symbol

Represents material or information entering or leaving the system, such as customer order (input) or a
product (output).

Manual Input Symbol

Represents a step where a user is prompted to enter information manually.

Preparation Symbol
Represents a set-up to another step in the process.

Connector Symbol
Indicates that the flow continues where a matching symbol (containing the same letter) has been placed.

Or Symbol
Indicates that the process flow continues in more than two branches.

Summoning Junction Symbol

Indicates a point in the flowchart where multiple branches converge back into a single process.

Merge Symbol
Indicates a step where two or more sub-lists or sub-processes become one.

Collate Symbol
Indicates a step that orders information into a standard format.

Sort Symbol
Indicates a step that organizes a list of items into a sequence or sets based on some pre-determined
criteria.

Subroutine Symbol
Indicates a sequence of actions that perform a specific task embedded within a larger process. This
sequence of actions could be described in more detail on a separate flowchart.

Manual Loop Symbol

Indicates a sequence of commands that will continue to repeat until stopped manually.

Loop Limit Symbol

Indicates the point at which a loop should stop.

Delay Symbol
Indicates a delay in the process.

Data Storage or Stored Data Symbol

Indicates a step where data gets stored.

Database Symbol
Indicates a list of information with a standard structure that allows for searching and sorting.

Internal Storage Symbol

Indicates that information was stored in memory during a program, used in software design flowcharts.

Display Symbol
Indicates a step that displays information.

Off Page
Indicates that the process continues off page.

Quick Tips for Using Flowchart Symbols

Most of the flowchart symbols shown here are for use in very specific applications, such as a data flow
diagram used for computer programming. Unless you have specialized knowledge and your diagram is
being developed for a peer group with similar knowledge, it's best to stick to basic flowchart symbols. If
more than the most basic flowchart symbols appear in your diagram, it is good practice to include a
legend or symbol key.
Most flowcharts should be built using only the Start/End and Action or Process symbols and should
follow a very basic set of best practices. Sticking with these two primary flowchart symbols is the best
way to ensure that your diagram will be easy to understand.

2.3.2 Sample Flowchart

Keyword

Optimization Flow Chart

When to Pause a Keyword

Landman "Chain of Title" Flow Chart

Input Output Flow Chart

Financial Crisis Flow Chart

Software Development Flow Chart

Order Processing Flow Chart

One Second LED Flowchart

Accounts Receivable Flow Chart

Changing a Flat Tire

Basic Flowchart Increment 3 Vector

Basic Flowchart - House Painting

Detailed Flowchart - Driving a

Stick Shift

Deployment Flowchart

Deployment Flowchart - New Product

Development

Opportunity
Flowchart -

Opportunity Flowchart - Order

Processing

Software Flowchart

Physical Flowchart