Introduction To Programming

Unit 3.4
ATHE Level 3 Diploma In Information and
Digital Technologies

NAME: Aulrich Jay P. Montesur

TUTOR: Miss Anina

Table of Content

1a) Describe how computer programming languages are used to meet business needs .... 3
1b) Explain how computer programming languages are used in different industries ........... 8
1c) Explain the characteristics of different programming languages and the common
similarities between them(LO 3.1.3.2).......................................................................... 11
1d) Explain the requirements that are needed to develop this computer programming code
................................................................................................................................. 14
1e) Explain the features of a programme environment which could be used to develop this
programme ................................................................................................................ 17
1f) Explain the range of functions and methods used in computer programming ............. 19
1g) Identify the most appropriate language to use for this program ................................. 24
1M1) An analysis of the sources of assistance to use when developing the computer
programming code ..................................................................................................... 26
3M1) An explanation of the advantages and disadvantages of programming languages.... 29
Task 2a) - Identify a problem to solve for the store, using a computer program ................ 34
Task 2b) Develop a computer programme using an appropriate Object Orientated
Programming language (OOP) that can be used by the retail store to solve the problem ... 36
Task 2c) Ensure all code within the programme is explained using comments ................. 43
5M1) a range of programming functions ....................................................................... 44
3a) Create a test plan detailing the tests to be completed.............................................. 46
3b) Carry out testing on the computer programme using a test plan ............................... 53
3c) Review and evaluate the programme based on the end results ................................. 57
Reference: ................................................................................................................. 58
1a) Describe how computer programming languages are used to meet
business needs

Explaining Computer Programming

Computer programming is basically a medium between human intentions and computer

operations. It gives us the set of rules and syntax and instructions, which define for computers,
how to do some specific operations. Programming languages act as the medium of
communication by which humans are able to instruct computers to perform functions (simple
calculations/incantations, large-scale data manipulations) written out in the form of instructions
in the language (series of commands). Just as natural language enables peoples ability to
communicate to each other, programming languages are the technologies of communication
between persons and machines in structured form that machines can understand and execute.

Why Computer Programming Is Important

Computer programming is crucial in modern business activity upon advancement of technology

because of the following reasons:

• Execution of Business Logic:

Businesses use programming languages to express their operational needs in form of
 functional software. Without programming businesses could not tailor-made their
software solutions, thus incurring unnecessary costs and inefficiencies.
• Digital Presence:
With competition coming in on the basis of technology, programming allows businesses
to claim and sustain a digital existence, which is necessary for competitiveness.
• Operational Efficiency:
Just the way an operating system organizes hardware activities to achieve almost
seamless computing, programming languages enables businesses to integrate different
applications into unified systems that run smoothly.
• Decision Making:
Product Programming allows for the processing and analysis of information thus
supporting business insights and a strategic approach.
• Innovation:
Programming languages offer the means through which businesses can install the
technological advancements and innovations.

Types of Computer Programming

Software Development for Business Needs

Business software development entails developing applications managing different operational

dimensions. Various languages such as Java, Python and C# are used — to design the software
used to automate complex business processes such as:

• Financial transactions
• Human resource management
• Logistics tracking

These programming solutions increase efficiency, cuts operational expenditure and develops the
customer services by simplifying the business processes. Each business application is an
enormous amount of programming to comprehensively grasp, and then write, complex business
rules into workable software.

Web and Mobile Applications

Web and mobile applications are key to any modern business to communicate with the
customers, sell goods in the Web and offer convenient services. Programming languages critical
to this domain are usually HTML, CSS, and JavaScript which are used for building websites,
PHP for e-commerce platforms and for mobile application development, Swift and Kotlin are
needed to be used.

These languages enable businesses to have a broader audience; to engage with customers better
through personalized recommendations and to compete effectively in the d socially skilled the
digital market. The development that these programming languages have undergone has directly
facilitated the development of the entire digital economies and revolutionized the way businesses
interfaces with consumers.

Automation of Processes

The programming languages have an important function in automating repetitive tasks thus
saving time and business using his services can allocate more time to more strategic areas.
Languages used for automation include:

• Python
• PowerShell
• Bash scripting

Automation by programming increases productivity and accuracy in such processes as data

entry; report generation; inventory control and as a result businesses operate more smoothly and
effectively. ROI with good designed automation scripts can be amazing, saving hundreds or
thousands of human work hours per annum.

Custom Software Development

Custom software development refers to designing custom-made solutions according to

formulating a business need. Unlike off-the-shelf software, custom solutions are usually
available that align perfectly with business processes, fffer competitive advantages with special
functionalities, Scale according to business growth and integrate seamlessly with existing
systems

These programming languages empower businesses to design such custom solutions which
would be impossible to acquire via standard software packages. Programming flexibility enables
programmers to iterate and improve custom software as need dictates thereby producing living
solution that mature with organization.
Data Analysis and Insights

Programming languages are critical in managing and analyzing large volumes of data which
companies use for making strategic decision. Some usually used languages from data analysis
are:

• SQL for database management

• Python and R using for carrying out data analysis and visualizing

These languages enable businesses to access such important business information like customer
records, sales transactions, and financial reports, and make them smarter decisions, business
expansion and improve operations. Insights gleaned from programmatically analyzed samples
always present patterns, and opportunities that would otherwise elude human analysts working
on smaller samples.

Mobile App Development

Mobile applications are now becoming a significant part of business strategy allowing the
creation communication channels with customers’ direct contact. This also makes providing
convenient services easier like integrating features such as push notifications and suggestions
that are personalized.

Businesses are able to develop these applications through such programming languages such as
Swift (for iOS) and Kotlin (for Android) thus help them create a competitive edge in the mobile-
first world of digital. The intelligence attained in modern mobile programming frameworks has
democratized app development, and even small businesses can develop professional quality
mobile experiences, hitherto unheard of to giant corporations.

Artificial Intelligence and Machine Learning

AI and machine learning are changing business operations in a drastic manner, programming
language playing a bigger part in the implementation thereof.

• Python
• R
• Frameworks like TensorFlow
Such technologies driven by programming enhance the business automation, customer analysis
and predictive analytics for a better bill of security and operation. They enable companies to use
data to gain insights for data driven strategies and to optimize their workflow. AI programming
is especially vivacious with new libraries and techniques constantly making their appearance
which are only expanding the boundaries in business intelligence and automation.

Financial Applications

It is important for programming languages to be used to create financial applications which

process:

• Banking operations
• Investment tracking
• Financial reporting
• Payment processing
• Risk assessment

These applications demand exact calculations, safe dealing and real time processing, all of which
are made possible with the programming languages capable of controlling complex financial
algorithm and sensitive data management. Financial programming has the requirement of
extraordinary high standards of accuracy and security because even a very small mistake can
lead to substantial monetary losses or noncompliance.

Cloud Computing Integration

Cloud computing has revolutionized the way businesses operate and allows firms to adapt the
amount of resources needed. The programming languages used in case of cloud-based solutions
are:

• Go
• Python
• JavaScript

These languages allow one to use cloud platforms such as AWS, Azure and Google Cloud thus:
 • Remote data storage
• Application hosting
• Software deployment

Cloud programming works similarly to how device drivers enable communication between
hardware and operating systems giving flexible and scalable business solutions. The rise of
‘Infrastructure as code’ practices has dramatically transformed business strategy to define,
deploy and manage an entire technology ecosystem via Code.

Conclusion
Programming languages are a necessity of modern businesses in many areas, both in software
development and automation to data management and integration of AI. Just as the fundamental
bond between hardware and software ensures that attribute-specific solutions are made to fit
individual requirements, programming languages are able to generate tailored solutions for every
need that arises out of a business.
In the digital age, a world where people and organizations are increasingly using computer codes
to do things better, business people use programming to increase the efficiency of their
programs, decrease costs involved in their services and products, improve customer experience
and only gain long-term success.
It would be impossible for business to change with technology, to innovate and expand in this
competitive digital environment without programming capabilities. As technology is going to
change, programming will become more and more central to business operations, and
programming literacy is going to be a skill more and more important for professionals in all
branches.

(alex.d, 2024; BairesDev Blog: Insights on Software Development & Tech Talent, 2022;
Edwards, 2024)

1b) Explain how computer programming languages are used in different

industries
Programming languages establish the building blocks for automated management and data
analysis and system control technology in every industrial sector of the modern world.
Organizations within particular business sectors typically choose programming languages based
on their specialist operational and technical requirements and existing practices.

Manufacturing and Production Programming Applications

The use of programming languages creates essential systems within manufacturing operations
which enhance productivity together with quality and protective features.

Programmable Logic Controllers (PLCs)

Factory floor equipment gets control signals from PLCs by using programming languages such
like the graphical language Ladder Logic that uses the diagrams of electrical circuits to write
programs that can be understood by electricians and engineers when programming automated
assembly lines.

• Structured Text functions as a Pascal-like language which provides enhanced

programming features for handling complex manufacturing operations.

The welding robots in the automotive manufacturing processes use PLCs that process commands
via ladder logic code that weld components accurately. The program processes sensor
information while handling different time steps to provide a perfect weld quality that is beyond
human capacity.

Computer Numerical Control (CNC)

G-code programming language is used by CNC machines to perform cutting and milling
operations and material shaping operations. The language allows for precise numerical control of
machine tool paths with its programming system.

Aerospace manufacturers are guided by programs that use G-code software to carve intricate
turbine blades out of metal using several axes milling machines. Thousands of tool movements
in micrometer precision are seen in the program to produce components that are beyond human
ability to be uniform.

SCADA Systems
The programming languages used by the Supervisory Control and Data Acquisition (SCADA)
system to control industrial processes include:

• Python: For data analysis and visualization

• C/C++ is the programming language used for controlling system-level controls.
• SQL: For production metrics database management.
The SCADA systems in chemical processing plants monitor hundreds of sensors by measuring
temperature and pressure and flow rate measurements. The programming languages control the
valves and pumps by automatic adjustments which prevents the dangerous conditions while
maintaining the consistency of the product.

Smart Manufacturing
A Python-based automated system manages the acquisition of sensor data from a German
beverage production line by using machine learning models to predict maintenance work. The
system identifies minor motor vibrations in order to identify failures in bearings that will happen
within fourteen days in order for maintenance teams to plan their work during downtimes instead
of causing unplanned stoppages of equipment. This approach reduces unplanned halt of
equipment to 73% and increases lifespan of equipment to 30%.

Automotive Production
A Japanese automotive company uses C++ and Python programming in order to create
collaborative robots that work with human assemblers. The program allows robots to recognize
the presence of humans while adjusting the patterns of movement and perform the repetitive
adhesive application with a precision of detail. The programming allows human staff to focus on
complex assembly work that requires skill and manual dexterity while bots perform difficult or
demanding operations to increase the operational output by 28%.

Oil and Gas

The SCADA systems operating on North Sea oil platforms use C# programming to track
thousands of data points throughout drilling operations. The system automatically adjusts the
production by analyzing equipment levels and states of wells and production metrics. The
programming of the system has failed detection protocols that identify potential malfunctions in
the equipment and runs programmed corrective measures independently. These systems raised
the resource recovery rates by 5-7% and reduced the energy used in the extraction process.

Building Engineering
The modern commercial building management system employs Python together with JavaScript
to build digital twins that produce virtual models of physical structures to predict energy
consumption and environmental conditions. Such applications adjust building schedules and
controls lighting systems and space capacity through models that learn from occupancy data as
well as climatic elements. These systems installed in big office buildings cut down between 15 to
20% of energy usage while achieving higher comfort levels with better automated environmental
management.
(Costa, 2022; Gallagher, 2020; Wambua, Jindal and Morozov, 2023; Wikipedia
Contributors, 2019)

1c) Explain the characteristics of different programming languages and

the common similarities between them(LO 3.1.3.2)

Human Readability
Programming languages become easier to understand for humans due to the inclusion of natural
language patterns through syntax and meaningful keywords and logical structures that assist
programmers to work on code together effectively. Python and Ruby serve as examples of
languages that present clean syntax along with few unnecessary symbols and boilerplate code
components which allow developers to concentrate on solution expression instead of language
difficulties.

The readability of the programming language enables collaboration between programming teams
for extensive software development through standard code reviews and knowledge sharing
mechanisms. The prime success factor in programming languages occurs when they find
equilibrium between their expressive capabilities and their simplicity thus enabling proficient
code communication for novice and expert developers within different backgrounds.

Problem-Solving Efficiency
Programming languages have distinct purposes to solve problems efficiently by providing
designed constructs and optimization features which convert human problem-solving methods
into machine instructions quickly and effectively. The power of efficiency in programming
exceeds basic execution speed because it also benefits developers through included tools and
extensive library options that create automatic solutions to common tasks and streamline
programming work.

Each programming language stands apart through its efficiency characteristics according to
purpose since C delivers top computer hardware interaction and fast execution times to the
system development sphere, yet Python prioritizes programming speed over raw machine
performance. The trade-off between various efficiency types appears in language design through
memory management since automatic garbage collection systems offered by specific languages
simplify development yet led to performance overheads yet other languages provide
programmers with direct memory control for critical performance applications.

Scalability
Programming languages provide scalability mechanisms which allow developers to replace code
repeats along with grouping components and architecture for solutions to scale from basic scripts
to sophisticated systems with controlled maintenance and performance levels. The essential
characteristic exists through modularity features including functions and classes and packages
and namespaces which create functional boundaries to handle complexity by dividing complex
problems into smaller manageable components with defined interfaces between them.

The effective languages offer an import system as well as dependency handling functionality and
version control features which permit teams to integrate external code libraries together with
stability preservation against dependencies clashes and large-scale team development
capabilities. A scalable language helps developers handle expanding complexity by
implementing patterns and practices which enable code extension through inheritance and
composition and interface definitions and generics so developers can modify existing programs
without rerouting them and can restructure software frameworks alongside requirement
evolutions for systems with prolonged lifecycles such as bank programs and manufacturing
control systems which operate across decades.

Structure and Documentation

Programmability built into languages results in proper code documentation through logical code
formatting and integrated documentation tools which improve program understanding during the
product lifecycle. Programming languages include annotation and comment functionalities which
generate machine-readable documentation that functions with development tools for auto-
completing code and demonstrating type details and auto-generating documentation.

The programming language utilizes structured components which include scope delimiters along
with indentation rules that establish visual and logical frameworks to improve navigation of large
codebases. The ability to maintain institutional knowledge about code becomes vital when
projects expand, and teams grow larger because it transforms personal code into organizational
knowledge that persists through team member changes to provide design and intent access to
future developers who need to understand or improve existing systems.

IDE Accessibility
Programming languages of today consider tooling assistance throughout their design so
developers can benefit from automated assistances through Integrated Development
Environments (IDEs). The language provides real-time code analysis and presents intelligent
suggestions and detects errors instantly and allows programmers to perform code refactoring
tools that result in faster development and fewer errors.

IDE integration between successful programming languages offers users both thorough type data
and defined project schemas as well as established compilation frameworks to assist tools in
recognizing code links and pinpointing errors before execution time and mapping component
relationships. These advanced languages such as TypeScript and C# have IDE support as their
initial priority to deliver features including type annotations and standard project structures.
These components offer essential details to development tools which enhances the augmented
programming experience by transforming IDEs into active assistants instead of basic text editors
for navigating complex codebases confidently.

Syntax Consistency

The expectations about how different constructs in programming languages behave remain
dependable because predictable grammar rules and standard syntax patterns and harmonized
operator laws minimize cognitive stress during development. Standardized grammar rules across
the programming language enable users to apply their understanding from one part to another
through the predictable operational structures which cover variable declaration and function
declaration as well as control flow commands.

Ushering elegant programming languages incorporate a minimal set of positively interacting

features that behave per the least surprise principle by offering consistent operations for similar
syntax constructs. Programming experiences improve when developers have a single obvious
method for executing operations since Python demonstrates this advantage, yet other languages
show multiple syntax options for the same goals. This design decision forces developers to
remember more exceptions, or it allows them to use fewer standard rules.

Abstraction

Abstraction in a programming language means ability to hide the complex implementation

details of the art and reveal to the user simplified interfaces or structures. This way developers
can work at the higher-level solving problems without having to worry much about every small-
time operations. Functions, classes and libraries aspects encapsulate logic and that is why code is
easier to reuse, maintain, and understand. For instance frameworks such as TensorFlow or high-
level functions in Python cover the complexity of mathematics behind it while providing
effective programming to developers.
(Reljanović, 2020; Tom Delalande, 2024; Wikipedia Contributors, 2018; Wikipedia
Contributors, 2019)

1d) Explain the requirements that are needed to develop this computer
programming code
Custom Stock Management System
The development of a custom stock management system for furniture retail stores demands
thorough examination of multiple integrated elements.

Expanded Database Requirements

The database structure serves as the fundamental base for the entire system and requires specific
design elements for furniture retail operations. A proper inventory needs to represent furniture
items with their distinct information. The product hierarchy of each sofa becomes complicated
because it includes various fabric options and color choices and configuration possibilities which
need proper modeling.

The database needs to use relational tables to link products with their variants so it can track
individual product configurations precisely. Furniture retailers need to track individual inventory
for each of their numerous product variations because they operate with extensive product lines.
The database needs to handle component-based products which can be sold either individually or
as complete sets.

The system must maintain warranty details alongside care guidelines and assembly protocols and
delivery specifications because these elements are essential for furniture retailers. The core
database design should integrate assembly and delivery scheduling elements because these
factors directly affect inventory allocation. These elements should not exist as separate systems.

Stock Entry Mechanisms

Furniture retail stock entry processes differ substantially from standard retail stock entry
procedures. The system needs to track partial shipments and component completeness because
many furniture pieces arrive in multiple packages or unassembled. The stock entry module needs
to support phased item reception while ensuring precise inventory tracking.

Floor samples create complexity because they exist as stock items yet remain unavailable for
direct sale. The system needs to differentiate between display items and inventory items and
should enable the transition of floor models to clearance inventory.
The system needs to enable staff to document damaged furniture assessments through photos and
handle supplier claims and inventory adjustments when such incidents occur.

Search and Retrieval Capabilities

Furniture sales associates perform inventory searches by applying precise criteria which match
customer needs. The search system needs to enable users to filter results by room type and
dimensions for space fitment and material type and color options and price ranges and delivery
time availability.

The system needs to display item locations through interactive maps or diagrams which show the
positions of items in warehouses and showrooms. The quick item location capability becomes
essential for large furniture warehouses because it directly affects the quality of customer
service.

The search results should display relevant associated items so customers can see matching
ottomans during sofa searches and compatible dining chairs during dining table views to help
customers complete set purchases.

Stock Allocation System

The allocation requirements for furniture differ from standard retail products because of its
unique characteristics. The time between purchase and delivery requires item reservation because
custom orders typically need weeks or months to complete. The allocation system needs to
monitor these commitments by separating physical inventory from items that are on order yet
already sold.

The system needs to handle complex delivery patterns which enable customers to receive their
complete order through multiple shipments distributed across different time periods. The system
needs to handle delivery zones together with scheduling windows and special delivery
requirements including assembly services and old furniture removal since these elements
determine stock allocation timing.

A system should monitor custom furniture manufacturing processes to show the status of
production and predict when work will complete and when materials will be used which indicate
upcoming inventory status.

Integrated Development Environment (IDE) and Java Examples

An IDE or Integrated Development Environment treats multiple standard development tools into
one interface which helps developers simplify their software development workflow. The
standard components of IDEs unify a source code editor alongside a debugger and compiler or
interpreter alongside build tools for automation and version control functionality.

Different Integrated Development Environment (IDEs) support Java development through their
efficient programming capabilities. These IDEs include:

• Eclipse operates as an open-source IDE which serves developers of Java applications

through its framework and tool plugins.
• IntelliJ IDEA combines passionate developer support for free as well as professional
support with a full-fledged commercial version offering code suggestion capability and
automated error detection and faultless Maven and Gradle integration.
• The Apache Software Foundation maintains NetBeans as an official IDE which
includes built-in tools for Java GUI development and web services and version control
systems.

Lot of development speed and reduced mistakes in big-scale software projects like a
custom stock management system are possible due to the tools offered by these IDEs
including syntax highlighting and code completion features alongside debugging tools and
refactoring assistance tools.

Thoughtful Deletion and Archiving Processes

The system needs to use a step-by-step approach to manage catalogs when furniture lines end.
The system enables discontinued item marking (which blocks new orders while keeping
warranty support visible) followed by clearance status with special pricing and final archival of
complete product information for historical purposes.
The archiving process needs to maintain complete records for warranty support and parts
replacement and customer assistance beyond active product sales. The historical records offer
useful information for future buying decisions because they contain complete performance data
about past product ranges.

Performance Optimization
The system needs to execute complex inventory calculations with high efficiency because users
check stock availability and process transactions simultaneously during peak sales periods.
System performance depends directly on database optimization and caching together with query
performance at times of high usage.
Special care must be taken when handling images because furniture products often contain
numerous high-resolution images that display various product views and surface options. The
system needs to have efficient storage and delivery systems for images to ensure smooth
performance during product visual retrieval and display.

Development and Implementation Strategy

The development of this extensive system needs a step-by-step method to tackle essential
business requirements initially and build a base for upcoming improvements. The system
development process requires continuous input from warehouse personnel and sales
representatives and delivery team members and executive staff to transform theoretical concepts
into practical solutions.
The implementation of new inventory systems in furniture retail requires special focus on change
management because technology changes frequently disrupt established workflows among staff
members. The transition period needs training programs that give individual guidance in addition
to practice sessions and immediately accessible support materials for staff.

(GeeksForGeeks, 2020; Kumar, 2023)

1e) Explain the features of a programme environment which could be

used to develop this programme
A Programming Environment for Advanced Furniture Retail Stock Management

A programming environment suitable for advanced furniture retail stock management requires
features to track complex inventory and support multiple interfaces and advanced data
management capabilities. The first step in environmental development requires choosing an
appropriate programming language. Java stands as a leading choice alongside C# and Python
but Java remains the most appropriate selection because of its combination of object-oriented
capabilities and platform flexibility and powerful execution quality.

The system enables modeling of furniture items and product categories and transactions through
objects which contain properties and behaviors. The strong typing system of Java maintains data
precision to avoid entry mistakes between text fields and numbers thus protecting inventory data
integrity.

Java suits furniture retailers whose employees use various devices among warehouses and sales
terminals because of its platform-agnostic design principle which enables "write once, run
anywhere" capability. The system supports first-rate multi-threading capabilities together with
concurrency handling features that enable real-time processing in extensive software systems.
Java environments support bytecode compilation as a performance enhancement tool that
optimizes application speed during active usage times.
Database System and Integration

The programming environment requires an advanced relational database management system

(RDBMS) among MySQL, PostgreSQL, or Microsoft SQL Server. These database systems
provide ordered data management capabilities and enforce transactional data integrity and allow
processing of diverse product variations and component successions.

Through Hibernate, PHP bridges Java programming language to relational databases with ORM
(Object-Relational Mapping) frameworks. Program development becomes faster through the
reduction of SQL redundancy and maintains object model logical coherence. The optimization of
database queries becomes an essential tool for managing large datasets because it lets you
achieve swift filter-based operations.

JavaFX for Desktop Interface Design

JavaFX (for desktop) serves as a frontend framework which supports flexible interface design
tools that enable adaptation between warehouse tablets and POS terminals. The system interface
must be designed for ease of use and quick response through inventory-specific UI libraries and
grid components. The application keeps a stable behavior through strong state management
patterns while operating across various views and inventory layers. The implementation of
accessibility standards enables all employees to use the system inclusively.

Recommended IDEs for Java Development

Java developers should use IntelliJ IDEA Eclipse or NetBeans as their Integrated Development
Environment (IDE) to access a complete set of features that enhance both productivity and code
quality. The IDE detects common programming mistakes through syntax and error highlighting
features to monitor correct Java syntax in real time. The code completion feature named
IntelliSense generates suitable suggestions which both accelerates development time and lowers
the risk of typographical errors. In addition to refactoring tools developers can safely transform
variable names and extract code segments and arrange specific areas of their codebase while
avoiding changes to program execution.

Development Tools and Version Control

The version control system through Git allows developers to work collaboratively while
retaining full track of version changes which is perfect for big team projects. Through its
debugging tools the IDE enables developers to execute code step-by-step while managing
breakpoints along with instant variable monitoring needed to identify logical errors. Developers
benefit from strong search and navigation tools when working with large codebases through
features that provide function definition location and usages and references.

GUI Design and Future-Proofing

The Scene Builder tool enables visual programming which lets developers create GUIs through
drag-and-drop operations for building complex desktop interfaces. The environment supports
future development needs of the stock management system through its extensive language
support and plugin availability which keeps pace with Java standards and libraries and
frameworks.

(GeeksForGeeks, 2020; Kumar, 2023)

1f) Explain the range of functions and methods used in computer

programming

What are Functions?

A function represents a block of code which carries out specific tasks through a defined name. A
function operates as a compact standalone program embedded inside your main program. You
can define instructions once in a function and use that function through a call whenever you need
to perform the same task repeatedly. Program efficiency improves significantly when code
duplication gets eliminated by using this method.

Functions typically:

• Accept data through parameters or arguments.

• Process data.
• Return outputs.

Functions operate through a mechanism where users need only understand their functionality and
interaction methods rather than their internal processing. Abstraction stands as a fundamental
concept which represents one of the strongest ideas in software development.

What are Methods?

In object-oriented programming methods function like functions yet they remain linked to
specific objects. A method functions as a function which becomes part of an object. Objects gain
their full functionality from this connection because they hold data components (attributes) as
well as executing behavior (methods). Together they become better at modeling real-world
entities.

A list object contains an "append" method to add items to the list while a string object provides a
"length" method to determine string length. Each method contains the unique behaviors that
define the usefulness of specific object types.

The essential characteristics of functions and methods include parameters and arguments.

1. Parameters and Arguments

Functions and methods accept their inputs through parameters or arguments. A function contains
parameters which represent variables defined in its declaration while arguments represent the
actual values supplied when the function gets executed. Functions demonstrate exceptional
versatility because they can handle different input values during each execution.

Functions allow parameters to use default values in case no arguments are supplied. The feature
enables functions to operate flexibly while providing convenience by managing absent data
elegantly.
2. Return Values

Functions and methods typically generate output results. These functions execute action
sequences while doing not return any output value. The implicit output is set to "None" or
"void." Functions operate as powerful computational units because they can generate outputs
which enables them to solve complex problems when connected in series.

3. Scope

The variables which function developers create stay confined to the specific function block. The
programming concept known as "scope" ensures different program sections avoid naming
conflicts. The correct comprehension of scope enables developers to prevent hidden bugs while
enabling them to handle extensive programs effectively.

Benefits of Functions and Methods

The comprehension of functions plus methods will offer you several advantages.

• Reusability: Fundamental code can be reused through single authoring that creates
multiple executions. Productivity levels surge while application consistency stays stable
because of this principle.
• Code Organization: Complex problems should be divided into smaller manageable
sections for the purposes of code organization. The decomposition process transforms
complex large programs into more understandable structures that become simpler to
debug.
• Abstraction: Abstract complexity helps programs through simple interfaces which mask
their internal details. Through abstraction, developers get the capability to think about
code at various specificity levels while concentrating on key elements during specific
points in time.
• Testing: Testing individual units of functionality is the main purpose of test code. This
method of selective testing builds higher confidence levels about code quality
simultaneously making continuous integration possible.
• Team Collaboration: Developers should work together on different functions at the
same time. Through functional decomposition, teams can divide work independently on
system components because it establishes proper boundaries between each segment.
Types of Functions and Methods

1. Built-in Functions

Programming languages include standard functionality through built-in functions which enable
users to find string length among other common operations. Standard language libraries use
built-in functions because they establish essential core capabilities that programmers do not need
to re-create.

2. User-defined Functions

Programmers develop these functions specifically for their application requirements.

Programmers use custom functions to make their language work for specific use cases and build
into it their individual methods for solving problems.

3. Recursive Functions

Functions use self-calls to break down complex problems into smaller versions of the same
problem. Recursive programming provides users with an elegant method to implement solutions
for hierarchical data structure traversal and divide-and-conquer algorithm execution.
4. Higher-Order Functions

The capability to work with functions lets programmers create strong programming patterns
which transform into function composition and callbacks. The key fundamental elements of
functional programming as well as reusable and modular code base have their foundation in
higher-order functions.

5. Instance Methods

These functions work directly with object data while simultaneously modifying the object state.
Through instance methods, objects become responsive to messages in otherwise dynamic and
expressive object-oriented programming.

6. Static Methods

These methods belong to a class yet they cannot access the instance data. These methods operate
on classes without using information specific to individual instances since they only serve class-
related operations. The functionality related to a class delivered by static methods operates
without object instantiation which results in improved organizational structure and better
performance.

7. Class Methods
These methods work with data at the class level while they can read and modify class attributes.
The functionality of class methods supports factory pattern creation and state control for the
entire class and its members.

(Codeacademy Team, 2017; Wikipedia, 2020; Wikipedia, 2022)

1g) Identify the most appropriate language to use for this program

Definition of Java Programming

The programming language Java was developed by Sun Microsystems before Oracle acquired it
through a purchase in a high-level object-oriented style. Java enables developers to create
applications which operate on any device that supports a Java Virtual Machine (JVM). Java finds
extensive use in enterprise systems and mobile applications and desktop applications and large-
scale business software because of its stability and scalability and security features.
Java for Furniture Retail Store Management System

I prefer Java because our furniture retail store management system will benefit from its
development with its superior dependability and performance together with extensive features
that made it an essential component in enterprise software development starting from decades
ago.

Reliable Platform for Store Management

Using Java to develop your furniture retail store management system provides a reliable solution
because this platform delivers both high performance and broad enterprise-level features that
established Java as an industry standard during several decades. The following discussion
explains how Java fits this application perfectly while presenting an implementation strategy for
required features to demonstrate how the technology addresses your business requirements.

Advantages of Java for This Project

 • Long-Term Viability
Java provides essential advantages which make it perfect for developing strong business
applications including your stock management system, while its long-term market
presence ensures your investment will stay valuable throughout multiple years.
• Cross-Platform Flexibility
Java's "write once, run anywhere" feature enables your application to function across
multiple operating systems. This provides future flexibility to the store when operating on
different platforms or planning infrastructure changes—thus saving future redevelopment
expenses.
• Object-Oriented Modeling
The object-oriented design capabilities of Java perfectly match database modeling of
furniture inventory items along with categories, suppliers, and transactions, which
ensures fully maintainable code and superior extensibility.
• Enterprise-Grade Reliability
Java provides enterprise-grade reliability by catching errors during development instead
of runtime, thus minimizing the possibility of operational crashes that could disrupt sales
and inventory management processes.

Long-Term Maintainability

The backward compatibility design principle of Java directly lowers your business expenses for
extended maintenance periods. The Java platform's updated version maintains backward
compatibility operations to let your inventory system run smoothly without needing expensive
rewrites of code during technological advancements. Your business asset inventory system needs
special attention to its longevity since you plan to use it for multiple decades.

Java programming implements high-level object-oriented design principles to create exceptional

modular systems which support business growth through system expansion. Your furniture
store's office furniture expansion demands class extension rather than complete system rewrite
because the new category depends on existing system elements. The software protection feature
lets your application adjust to business growth while maintaining safety for your investment.

Developer Abundance

Your business gains access to many experienced developers through Java programming language
selection because these developers can perform development work and maintain your system.
Java language's global success guarantees your project will always have available skilled
personnel ready to work on your tasks.

A multitude of resources about Java services including books, documentation sites, developer
forums, official documentation and more offers pre-existing solutions to standard programming
issues. Your development team can solve PDF report generation problems for monthly inventory
turns by using existing solutions rather than building new approaches. The extensive knowledge
base available in the market reduces development time while producing more reliable results.

(Edwards, 2024; GeeksForGeeks, 2020; Kumar, 2023)

1M1) An analysis of the sources of assistance to use

when developing the computer programming code

Online Blogs
Technical blogs developed by veteran developers or companies contain a detailed understanding,
best practices, and new ways to solve programming challenges. Unlike forums, the blogs present
rather complete explanations having addressed the context, arguments, and the author’s
professional insights. A lot of blogs provide well crafted tutorials who explain complicated ideas
one step at a time and are thus excellent for learning technologies or techniques.

These carefully selected resources usually contain years of experience compressed into easy
access material providing shortcut through common mistakes. Wrongly written blog posts often
highlight working examples and the snippets of code to show the actual applications of abstract
ideas thus connecting the world of academia and the world of implementation of those ideas into
practice.

The limitations of blogs are that they tend to have bias in favour of the author’s preferred
approaches or technologies. Without the interactive aspect of the forums you just cannot ask
follow up questions or request explanation of confusing points. Content can easily become
obsolete if not updated on a regular basis, especially for fast moving technologies. The quality
and accuracy indeed vary significantly in various blogs necessitating that you become
accustomed to judging the reliability of the source.

To make better use of blogs, follow well-known writers in your programming specialization. Use
them if you want to learn more about a concept as opposed to sensible solutions. Check
information against various sources to confirm that information to ensure accuracy and
determine truly best practices as opposed to personal preferences.

Online Forums
Varieties of online forums such as Stack Overflow, programming communities at Reddit, and
dedicated language forums are fantastic sources of information for programmers of all
categories. These platforms unite million accordingly worldwide and they freely share their
knowledge and experience. The question-and-answer format helps you discover the answers to
some of the particular programming problem that the other people had resolved.

Most forums have community voting systems that point out the best or elegant solutions and
save you time considering many approaches. You can seek questions and get individual attention
from experts around the world, usually in minutes or hours. This instant action feedback loop can
be very helpful if the narrow deadlines or the complicated technical barriers are set.

Nevertheless, the quality of answers can differ quite a lot from one forum to another and from
one group of users to another. Solutions can be outdated as languages and frameworks continue
to evolve which can put you on problematic implementation avenues. It is very important
understanding the context, there may be solutions, but not exactly for your case, without
adjusting them. Also, some forums have tough posting rules and cultures that can be intimidating
to new comers that are not aware of the required formats and proprieties.

For efficient use, make an extensive search for existing solutions to such problems before raising
a question. While asking questions be specific about context, code snippets relevant to your
problem, and share what you already did. First above all, instead of copying the solutions offered
up, attempt to understand the solutions, because this develops your problem-solving and
increases your mastery in the programming language or framework.

Tutors
By working with programming tutors, you have a customized support system that is provided on
a one-on-one basis that focuses on getting you to learn in a style that best suits you. This one-to-
one instruction gives you an environment where there is focus, where questions can be answered
immediately and explanations tweaked to suit your level of understanding.

A competent tutor will craft an individualized zone of proximal development for your
established knowledge and objectives so that you do not waste time mastering things you have
already mastered. The instant feedback on your code and your approach prevents the bad habits
from settling and consolidates good programming habits right away. Regularly seeing a tutor
also holds them accountable with structure that may be hard to maintain when learning on one’s
own.

Some of the main limitations of tutoring are cost – which can be an undue burden when
compared to free or low-cost options. The effectiveness of learning relies to a great extent on the
tutor’s competence in teaching, which is hard to assess before one spends time and money. Such
constraints as scheduling and availability may determine your possibility to get help when
needed the most. There is also the danger of becoming dependent on the tutor rather than
forming one’s own independent skill of problem solving.

In order to get the most out of tutoring resources, one might need assistance with difficult topics
where, on their own, they have not succeeded in understanding. And literally, come ready with
some specific questions and intent for every session to maximize value. Most importantly,
practice off on your own in between sessions to confirm what has been learned and to learn to
become self-sufficient.

(ihavezerohealth, 2023)

Working Groups
Partnerships with peers in working groups or study circles weave an atmosphere of collaborative
knowledge and difficulty resolution much like the world of development teams. These groups
provide you overview of different perspectives and approaches to solving coding challenges
which expand your scope of possible solutions. The social aspect is able to help each other and
motivate them that may be vital if one is dealing with complicated idea or tight deadline.
The working groups provide the beneficial chance to gain practice of how to explain technical
concepts to people, which makes deeper your understanding. The process of code peer review by
people and your code being reviewed by other people develops critical skills of evaluation
necessary for development of profession. To many programmers, verbalization of a problem to
the group often results in ideas they could not have come up with on their own.

Benefits of working groups include:

• Exposure to a variety of coding styles and resolution to problem situations.

• With built-in accountability and peer relationships which means motivation.
• Building communication skill foundations important for technical interaction.
• A supportive environment to challenge some of those questions which would appear too
rudimentary in a formal environment.

Indeed, group dynamics may pose a challenge at times, as long as member skill levels are vastly
different or they have different objectives. Meeting consistency with many participants may
prove difficult through scheduling difficulties. Absent a guiding mind eminent at this point, it’s
also possible that if everyone has the same misconception, misconceptions might be reinforced.
In order to increase working group efficiency, set clear goals and architecture in the beginning
itself. Identify regular assignments that change, for example, facilitator, note holder, or codes
review. Provide a safe place where people are able to ask questions of any difficulty and hold
regular code reviews to ensure that people’s abilities are improved.

Code Repositories
This applies to code repositories such as GitHub, GitLab, and BitBucket: full project codebases
and examples from developers across the world. Such platforms are home to millions of projects
from small personal tools to enterprise giants and give a look into how programming concepts
are implemented in the world’s today.

Learning how to work with carefully maintained repositories, not only do you study high-quality
code, but you also begin to spot the same style and practices, which may not be addressed in
tutorials or knowledge bases. Volunteering in open-source projects is a great experience on
working with given codebases and Paul working with other developers. The way that you are
told about your contributions can significantly speed up your progress as a programmer.

Advantages of using code repositories are as follow:

• Access to actual world implementations for different technologies and design patterns
• Capability to learn complete project frameworks instead of single code pieces
• Opportunities to take part in open-source projects as well as opportunities to receive
expert feedback
• CHange management system that allows tracking how code changes from time to time

Learning from repositories will be challenging because of the complexity of large code bases, the
quality of documentation deficiencies, and having to understand project specific contexts.
However, these challenges themselves are useful learning points that equip you for professional
development environments. (Wikipedia Contributors, 2019)

3M1) An explanation of the advantages and disadvantages of

programming languages

Advantages of Programming Languages

1. Abstraction and Problem-Solving Efficiency
Programming languages give us levels of abstraction and thus it is easy for us developers to use
simple words to express complex ideas. This is a neat approach to guarantee the programmer will
not be wasting their time and energy and focusing on the low-level details such as the memory
allocation, hardware interface or perhaps even the individual machine code instructions.
Corporate developers who use high-level languages such as Python and JavaScript do not need to
worry about the dirty work as they can concentrate on solving the iterative business problems.

The productivity, achieved by the abstraction drastically rises the productivity of the developers.
Tasks that would take hundreds of lines in the days of assembly language can often be put into
just a score of lines in the concurrent languages. This means shorter development cycles and the
ability to introduce solutions faster, and responding to the business needs more flexible.

2. Portability Across Different Platforms

To name several modern languages provide platform independence so that once written code can
run on multiple operating systems and hardware architecture at little or no cost. Such a capability
is realized by languages like Java because they support their “write once run anywhere” ability,
with virtual machines which interpret the bytecode regardless of the underlying platform.

This portability cuts down development expenses too much because there is no need to re-write
applications for specific platforms making this privilege a significant value in contemporary
computing ecosystem where software must run with ease across various devices and operating
systems.

3. Rich Ecosystems and Libraries

Traditional mature programming languages usually have thick ecosystems of libraries,
frameworks, and tools that may do a huge job in speeding up development. These prebuilt parts
deal with everyday tasks and offer solutions to common problems and this will enable the
developer to concentrate on the unique aspects of the application.

For instance, Python’s ecosystem includes: NumPy and Pandas for working with data, Django
and Flask for the web programming with the help of Python, TensorFlow and PyTorch for
learning machine. These libraries capture thousands of developer hour worth of code that has
been tested and optimised, which can be used without having to reinvent the wheel for solving
basic queries. The presence of such resources shortens development time, enhances code quality,
and allows developers to put into use complex functionality too time consuming to build starting
from scratch.

4. Community Support and Knowledge Base

Popular programming languages use lively large communities that support, share knowledge and
contribute to the further evolution of the language. Around languages such as JavaScript, Python
and Java, communities develop, creating huge resources such as tutorials, documentation, forums
and open-source projects.

Becoming the richest knowledge resource, this common base of knowledge becomes an
indispensable tool for both veteran and new developers alike. Programmers can when stuck with
challenges find solutions to recurring problems, learn best practices, read other voices on the
world, and receive directions from their peers. The strong communities also guarantee the
language continues to evolve with contracts from users, relevant even as the technology changes.
The access to skilled developers in popular languages also makes organization easier to hire and
expand its team.

5. Specialized Capabilities for Specific Domains

A large number of programming languages are intended or optimized for certain problem
domains and, therefore, provide certain special capabilities making such programs specifically
effective for certain classes of applications. These specific domain languages and features allows
developers to be productive within his/her specialization.
For example:

• R provides statistical computing with application for data analysis and visualization.
• Declaratrive syntax in SQL is perfectly suitable for database operations.
• MATLAB is exceptional at mathematical model and scientific computing.
• Swift has smart frameworks for iOS development
• Verilog is an expert in the hardware description for chip design.

Such domain-specific capabilities allow developers to write domain-specific concepts naturally,

succinctly. Tailored syntax and domain-specific operations enabling functions enhance both
development and runtime efficiency of special-purpose applications, making specific languages
clear choices for specific industries or problems.
Disadvantages of Programming Languages

1. Learning Curve and Complexity

Most strong programming languages have deep learning curves which take a lot of time and
work to achieve. Languages such as C++ and Rust provide outstanding performance capabilities
and control but require complex syntax, a chore to manage memory manually and numerous
language features that may all be overwhelming to those who are starting. The complexity is not
limited to strengths of syntax but extends to include understanding of language paradigms,
architectural pattern and ecosystem tooling.

The high cost of investment needed to meet proficiency can lead to project delays, making
training more expensive. Organizations will typically encounter difficulties onboarding new
teams whose members need to both learn the codebase and perhaps unfamiliar language
constructs. The complexity issue is especially problematic for high-turnover of developers or if
projects are such that developing teams need to be expanded in a hurry.

2. Performance Limitations

Other programming languages focus on developer productivity and convenience at the expense
of execution effectiveness, and the performance suffers from the comparison with lower-level
counterparts. Interpreted languages such as Python and Ruby are known to deliver some of the
fastest development speeds yet often slow to run compared to other compiled languages such as
C and Rust. Such performance differences are important in computationally intensive
applications, real time systems, or in constrained resource environments such as mobile
smartphones or embedded systems.

Applications that handle large amounts of data, or their response times have to be immediate,
might suffer from restrictions with regard to higher-level languages. To be sure, some problems
can be addressed with the help of optimization techniques and specifically created libraries, but
many fundamental performance characteristics often necessitate compromise or even rewriting
of performance critical components in faster languages.
3. Version Compatibility and Fragmentation
Programming languages, just like many other technologies, change over time, adding new
features, deprecating old ones and sometimes making a breaking change from one version to
another. This evolution has a compatibility challenge when maintaining earlier written code base
or developing using dependencies which target different versions of the language.

Python’s move from version 2 to 3 is, for example, a multi-year compatibility problem for the
ecosystem. Just like JavaScript, fast evolution has made transpilation and polyfill requirements
for supporting older browsers complex. This level of version fragmentation exponentially
increases maintenance overhead because developers are forced to maintain compatibility
layering or upgrade legacy code or keep track of different language versions of code at once.
Organizations with long-lived applications especially experience this pain as they try to reconcile
the uptake of new features to that of updating old systems, respectively.

4. Security Vulnerabilities and Safety Concerns

Some programming languages have no in-built protections against common security
vulnerabilities leaving all systems security on the developer’s vigilance. Many programming
languages such as C, and C++ which program to the hardware, have its own security pitfalls like
buffer overflows, memory leaks, and pointer vulnerabilities.

Not even managed languages can always be designed in a way that security becomes easier. For
example, JavaScript’s loose typing and equality rules can cause a surprise behavior to form
security holes. Even though frameworks and tools can be used to identify vulnerabilities, the
nature of language itself tends to dictate whether writing secure code is easy or difficult. Those
organizations creating security critical applications may have to invest a great deal in additional
testing, code review and skills in security, to balance the lack of security at language level.

5. Resource Consumption and Deployment Challenges

The modern programming languages and runtime environments are resource hungry, posing
deployment challenge in extreme constraint environments. Languages that have heavy runtime
requirements, GC overhead, or dependency bloat will therefore make deployment difficult in a
device with little or no memory or processing power.

For instance, Java applications usually need a full JVM installation, which means increased
installation footprint. Similarly, dynamically typed languages usually pay off their memory
efficiency at the expense of convenience features. These resource requirements are especially
troublesome in containerized environments where efficiency translates to costs, or in embedded
systems, where resources are severely limited. There is an onus on organizations to carefully
consider if a set of language’s resources fit their deployment targets, in some cases this will
require compromise between developer productivity and runtime efficiency.

Task 2a) - Identify a problem to solve for the store, using a computer
program

The Problem that Arises from the Traditional Retail Furniture Stores

Conventional retail furniture stores experience great operational difficulties which affect the
efficiencies of businesses and customer satisfaction. From the shared management system code,
there are several limitations embedded in physical stores. As more products are added, inventory
management only get more complicated and there is a hard limit of items (MAX_ITEMS = 100)
representing the limitations in the size of the showroom. After making a sale, staff must
manually update inventory records and this provides space for human error tracking stock levels.

Physical stores also function on limited hours, which limits customers’ exposure of purchasing
goods. The order process currently followed at the store requires that customers physically
appear or phone to enquire on availability before placing orders. Moreover, the scope of the
geographic is confined to local customers who can visit the store’s location thus restricting the
customer base immensely. The system also does not have any integration of methods for modes
of payments or schedule deliveries which today’s consumers expect.
From the customer’s point of view, the this-store experience is frustrating. They must go to the
site, at times only only to find that the sought-after items are out of stock. The program illustrates
that inventory availability is seen only by employees of the store making it impossible for
customers to see whether an item is available or not by calling the store. This is needless friction
in the shopping process and may mean lost sales opportunities.

The Solution: Implementing an Online Furniture Store

Through an online furniture shop, the drawbacks mentioned above could be mitigated by
changing the working procedures of the business and the way it relates to the customers. By
adopting the existing management system onto a web based platform, the store could eliminate
physical office space constraints and expand inventory beyond the present 100 item limit. This
real time inventory update would make customers always view accurate stock levels which
would avoid disappointment and enhance satisfaction.

The virtual platform would provide the 24/7 opportunity and allow the customers to search and
order the furniture any time comfortable for them. The geographic barriers would fall, thereby
broadening the customer franchise from the local buyers to the regional even national level. Top
class photos and in depth information about products can replace the necessity for physical
inspection of furniture.

Customer accounts could maintain a history of purchases and customer preferences and,
therefore, make recommendations based on earlier purchases and simplify reordering. The online
system could also incorporate sophisticated features such as ability to accept automated ordering
when stock levels fall below threshold thus minimizing the manual work currently required in
the addFurniture() and placeOrder() methods. Payment processing and delivery scheduling could
be integrated smoothly into the buying stage, thus providing a full end to end- shopping process.

For the business, an online store would be a great source for analytics regarding browsing
patterns, popular items and purchasing trends, which are impossible to pull out of a physical
shop environment. These insights can be used to make inventory decision and marketing
strategies thus increasing business performance. The search function of the current system can be
augmented with categories and price range searches and other attributes to make it possible for
customers to obtain exactly what they want.
Task 2b) Develop a computer programme using an appropriate Object
Orientated Programming language (OOP) that can be used by the retail
store to solve the problem
Object-Oriented Programming

Object-Oriented Programming, abbreviated as (OOP), is a programming paradigm that structures

code around data – or, “objects”, instead of functions/ logic. It concentrates on making reusable
modular code by understanding classes as blueprints for objects with specific attribute and
action. OOP is founded on four basic principles:

• Encapsulation where you encapsulate internal data and give controlled access.
• Inheritance where you create new classes that inherit properties from existing classes.
• Polymorphism where you can have objects that assume different forms depending on
their context.
• Abstraction: where you ‘dumb’ down the systems by creating models of classes based on
essential properties.

Introduction of the Furniture Store Program

The Furniture Store program is an inventory management system tracking and manipulating
furniture inventory. It enables users to add/delete/edit/fetch and display furniture item(s) via a
console interface. Implementations of the program are based on OOP principles with a Product
class defining the base class that encapsulates common product characteristics while a Furniture
class that inherits functionality of the furniture specific and extends the parent class. The
FurnitureStore3 class acts as the primary application that controls an array of furniture object
and via a menu-driven application the inventory can be accessed.

Product Class and Variables

The Product class is the basis for every object in the inventory of the store. It provides four
private instance variables: name (String), category (String), quantity (int), and cost (double) The
class has a constructor that takes values for all four attributes and copes a value of the object.
This constructor gives each of the Product object the important information upon creation to
have uniform state for all the inventory items.

Encapsulation Implementation

Encapsulation of the values in the Product class is done in a way that, all data variables (name,
category, quantity, and cost), are declared private and cannot be accessed directly from outside
the class. The class then intervals public getter and setter methods to each variable
(getName/setName, getCategory/setCategory etc) which gives tenable access to these attributes.
This encapsulation insures data integrity in a sense that any changes have to pass a series of
methods, which may, or may not, include validation logic. For instance, with the current
implementation, direct assignment is possible in setters, but such mechanism would easily
accommodate adding validation in future versions to help prevent negative quantities or costs.

Polymorphism Using displayInfo() Method

Polymorphism is shown by the existence of the displayInfo () method on both the classes
Product and Furniture. The base Product class has a displayInfo() class to print a formatted string
containing basic product details. The Furniture class overrides this method with its own, whereby
it prints to the screen a “Furniture Details” header and then calls the parent class
displayInfo()method using super.displayInfo(). This is demonstrated as runtime polymorphism
where the same method name reflects differently according to the object type. Calling
displayInfo() on a Furniture object causes dynamic execution from the specific overridden
version on that class.

Inheritance Using Extends from the Product to Furniture

The class Furniture inherits from the class Product by using the keyword “extends” making the
inheritances relation whereby product class has a specialized form of Furniture. With this
inheritance, the Furniture class then inherits all the attributes (name, category, quantity, cost) and
has all the methods (getters, setters, displayInfo) of the Product class without re-defining. The
parent class is constructed using super(name, category, quantity, cost) by the Furniture
constructor as it passes initialization values up the parent class. This linkage expresses the “is-a”
rule of inheritance where all Furniture objects are also Product objects making reuse of the code
and logical hierarchical organization possible.
Method for Adding Furniture Items

Users can use the addFurniture() method add items to the inventory. It first confirms whether
inventory is full to the limit (MAX_ITEMS). If space is there, it asks the user to input the
furniture name, category, quantity and cost using the scanner. After gathering this information it
triggers a new Furniture object and it assigns the created object with the given values and is
stored at inventory array at the position referred by itemCount variable, which is also
incremented. This approach deals with the possible errors of overflow of inventory and ensures
the scanner consumes the input values of various types, including newline character following
the reading of numeric values.

Method for Deleting Furniture Items

The deleteFurniture() method disburses an item from the inventory by name. It will ask the user
to input the name to delete the furniture and will search the inventory array for an item having
the same name. (Case-insensitive comparison is used). Once a match has been located, instead of
moving all the other elements forward, the method updates the dom with an efficient deletion,
replacing the found entry with the last in the array, setting the last to null, and decrease the
itemCount. It will show a proper message if no corresponding item was found. This strategy
preserves array integrity, while avoiding the cost of shifting that comes with deletion.
Method for Editing Furniture Items

The editFurniture() method modifies the information of an already existing piece of furniture. It
provides for the input of the name of the item to edit and there’s a search of the inventory for a
match. When searching for the target item, it prompts the user to insert new values for name,
category, quantity, and cost consecutively querying the object's attributes by its setter methods.
The method supports mixed input type (numbers and strings), and maintains a correct
consumption of the input buffer to avoid scanning errors. If the specific furniture item could not
be found, the method then completes without any updates, although the code does not call it out
to the user – this is the failure case of the issue.
Method for Displaying Furniture Items

The displayFurniture() method offers a view of all the inventory of furniture in stock currently.
The first thing it does is check to see if inventory is empty (itemCount is 0) and if so, it prints a
message. Otherwise it prints a header line and details of each on inventory furniture items. The
method loops through to the itemCount element within the inventory array and alternates the
displayInfo() method on each non-null object of type Furniture. This is a display of
polymorphism in action as each overridden displayInfo() method for a furniture item will be seen
when called, which then shows the furniture-specific formatting which includes the “Furniture
Details” prefix in front of the standard product information.
Method for Searching Furniture Items

The searchFurniture() method finds the inventory’s particular item with the name. It prompts the
user to input a name then loops through the inventory array comparing each furniture name with
the computed search term with a case insensitive conditions. Upon a match, it will then show a
success message and then it will display the full details of your furniture item through its
displayInfo() method. If no result is found in all the entries of inventory then it shows “not
found” message. The approach takes advantage of the enhanced for-loop to iterate more clean
through the array, and also checking for nulls to avoid NullPointerExceptions.

Main Method Implementation

The primary method acts as the application’s entrance and control point, which is a serialized
process of loops and menus, disposing of choices made by the user down to an explicit
terminating point. It presents seven options: add, delete, edit, view, search, place orders and exit.
After delivering the menu, it reads the numeric choice of the user and through a switch statement
it invokes the required method according to that choice. When the user chooses the option 7, the
program stops as System.exit(0). For every wrong input, it shows an error message and again
displays the menu. The key method controls the program’s workflow and interaction with the
user, developing a straightforward but useful console interface for the system of store
management for furniture.
Task 2c) Ensure all code within the programme is explained using
comments

Why comments are important

Comments in programming are valuable documentation tools. They turn code from a series of
steps into understandable prose, which makes programs easier to maintain, work together, and
learn about. As can be noted in the example of an application structure, such comments as "//
Constructor to initialize the product details” “// Method to display all furniture items in the
inventory,” give developers a good idea of the purpose and function of each item which, in turn,
eliminates the need for figuring out each line of the code. This is especially beneficial to have
when there are more than one programmer working on the same project, when coming back to a
codebase after a long period, or when bringing on new team members as it saves the minds and
original design decision of the first developer.
Well commented code also makes it easier to debug and to modify that code in the future simply
because programmers have an easier time locating sections relative to their problems and also
understand how changing just one module or variable can affect the system overall and that
whole integration process saves a lot of time and reduces the chances of errors when doing
maintenance or modifications on that system. Comments, as embedded training aids in
educational settings such as the shared code example, not only describe what the code does but
also why particular methods were used, thereby simplifying complex program concepts for
learners, that are able to observe not only practical implementation of the code, but as well as
rationale behind the approaches.RetryClaude lacks ability to execute the code it creates.Claude is
capable of errors. Please double-check responses.

5M1) a range of programming functions

Functions

Functions in programming commands are a set of codes given a name to do some defined
operations. They do inputs (parameters), process them, and output (optional) results. Functions
constitute the bricks of modular programming, which support code reusability and ease program
readjustment, debugging and maintenance. With functions, complex problems are divided into
smaller, more manageable parts and as a result, functioning becomes easier to read and they can
be used by various developers at various program components without interference. They build
abstraction layers for users that need to know only what a function does, but not how it does the
task. This division of concerns allows the code to stay neat and tidy while testing can also be
done easily and future modifications made easily.

Static Method

Static methods are part of the class itself not instance (object) class objects are. This can be done
directly by the class name without creating any objects, which makes them useful for utility
functions that don’t need access to instance specific data. Since there is no access to instance
variables or non static methods, static methods work independent of object state. This
independence makes static methods perfect for calculations that apply to all instances generally,
such as factory methods that return object instances and perform mathematical operations as well
as helper functions that work up input. Static method are declared with a "static" keyword and
are loaded into memory once the class is loaded and are available throughout program execution.

Getter and Setter Methods

Getter and setter methods offer controlled access to the private or protected attribute of an object,
which belongs to the implementation of encapsulation - one of main principles of object oriented
programming. Getter methods also called (accessors) fetch a value of specified property, setter
methods (mutators) change property values. The tool enables the class to control how its internal
data may be accessed and modified, by adding validation rules, format conversions or other
processing without changing the external interface. For instance, a setter can check whether a
value lie in within a certain range and then assign it to an attribute, or a getter can format data
before returning the data. Such controlled access prevents the object from being subject to
invalid changes of its inner state as well as decouples the object’s external representation from its
internal implementation.
Constructors

Constructors are unique methods invoked each time a new object is created; they initialize an
instance variable to the desired initial value and execute any setup activities required upon the
object’s creation before it can be put into use. Unlike normal methods, constructors have the
same name as the class they are in and don’t need a return type. When creating an object using
the “new” keyword the relevant constructor is auto called with the arguments passed to it.
Classes normally have a default constructor (without any arguments); besides it, there may be
other constructors with other sets of arguments to provide some flexibility for initialization.
Constructors define the object’s first state to be valid and usable. In inheritance hierarchies, it
usually happens that subclasses constructors call methods of superclasses, e.g. using super() to
initialize inherited attributes that were not initialized in the constructing subclass before the latter
implementations for their own specialized initializations.

Overloaded Method

By method overloading, multiple methods in the same class can share the same name along with
differing list of parameters that are marked by the quantity, sequence, or type of parameters.
Such a polymorphic characteristic adds value in making the code readable by the use of intuitive
consistent naming but in different use cases. The compiler selects which method implementation
the compiler calls depending on the arguments passed at the call site. For instance, a
“calculateArea” method might be overloaded with different update parameter sets as follows:
one for circles (in case of radius), another for rectangles (length and width) and one more for
triangles (base and height). Methods overloaded must have different parameter lists from each
other; It is not enough simply to have different return types for overloading. This technique
alleviates the necessity of memorizing several names for the methods calls of conceptually
similar procedures that makes the APIs more intuitive and even user-friendly.

3a) Create a test plan detailing the tests to be completed

Understanding Software Testing

Software testing represents the evaluation process which determines whether software
applications fulfill their actual requirements by detecting their gaps and errors. The execution of
programs with the purpose of detecting software bugs occurs before the product reaches its
intended end users.

Software testing accomplishes more than identifying issues because it proves that developed
software supports all specified requirements. The testing process starts by developing test cases
from requirements specifications which are subsequently run against the software.

The testing process continues throughout the entire duration of software development lifecycle.
The Agile development method implements testing directly into development instead of treating
testing as a separate post-development activity. (Wikipedia Contributors, 2018)

The Importance of Software Testing

Quality assurance activities and risk prevention strategies exist through testing which verifies
programs attain their desired quality levels and perform according to specifications. Early
detection of issues in development reduces both cost and time needed for repairs because fixing
production defects costs 100 times more than fixing issues found during early development.

Thorough software testing ensures functional quality which leads users to commit to the program
and lose trust in it due to few bugs or performance issues. Security testing detects possible data
security vulnerabilities through penetration testing which allows effective preemption of
malicious actor opportunities.

The testing process ensures software operational stability through various operational scenarios
to establish a reliable system which maintains efficiency during maintenance. The process of
testing the code base ensures high code maintainability because automated regression tests
enable developers to safely modify code systems while maintaining existing functionality
validation after updating code.

The Types of Software Testing

Functional Testing
During functional testing the checking of software specifications occurs while complete
disregard exists for implementation methods. (Pittet, 2019)

• Unit Testing
A single unit or complex function undergoes testing in unit testing framework. The
developers create unit tests that check particular procedures to ensure they deliver
expected results. Unit tests for the Furniture Store system would check that the
addFurniture() method functions properly.
• Integration Testing
Integration Testing: Examines interactions between components. The testing process
confirms that all integrated units function properly when working together. The necessary
test in our system checks how different methods collaborate to deliver the expected
results.
• System Testing
System Testing serves to confirm that the entire system fulfills its requirements. The
complete application undergoes testing through real-world simulation to verify its
functionality. The application requires complete workflow execution for testing purposes.
• Acceptance Testing
Acceptance Testing checks whether the system meets all specified acceptance
requirements. End-users conduct this testing to verify that the software fulfills their
requirements.

Non-Functional Testing
Non-functional testing evaluates system performance instead of testing individual functions to
determine how well the system operates.

• Performance Testing
Performance Testing: Evaluates system responsiveness under various loads. The testing
method helps teams locate operational limitations and system capacity issues when
systems operate under different circumstances.
• Security Testing
Testing for security purposes detects the weaknesses which potential attackers could use.
The application receives comprehensive protection tests through vulnerability evaluation
which guarantee security of sensitive data.
• Usability Testing
The assessment of user interface friendliness constitutes usability testing. The process
 requires direct observation of actual users while they use the software followed by
feedback collection.
• Compatibility Testing
A test that verifies software operation across multiple computing environments including
operating systems as well as devices.

Maintenance Testing
After system modifications maintenance testing verifies that no regressions appear while
validating the integration of new changes with the existing system framework.

Regression Testing
The purpose of Regression Testing is to verify that new changes do not create negative effects on
current system features. The process of re-executing tests checks that modified features continue
to function properly.

Test Case 1: Adding Furniture Items

The system needs to verify proper addition of new furniture items.

Test Scenarios:

• The system allows users to add new furniture items through valid data entry.
• The system attempts to add new items while the inventory reaches its maximum capacity
(MAX_ITEMS = 100).
• The system should accept an item with boundary values that includes zero quantity and
zero cost.
 • The system should reject attempts to add furniture items with negative quantity values.
• The system allows users to add multiple items which share the same name.

Expected Results:

• The system properly accepts valid items through a success notification.

• The system displays an appropriate error notification when inventory reaches its
maximum capacity.
• Boundary values are handled correctly
• The system rejects all invalid input data while displaying clear error messages to users.
• The system maintains consistent behavior when duplicate items exist.
• Internal itemCount increments correctly

Test Case 2: Deleting Furniture Items

The system must enable users to remove items effectively from inventory.

Test Scenarios:

• The system enables users to remove existing items through their names.
• The system attempts to remove an item that does not exist in the inventory.
• The system allows users to delete items from any position including the first, middle or
last positions.
• The system allows deletion through multiple name variations with different
capitalization.
• Perform operations on deleted items

Expected Results:

• The system successfully deletes existing items while displaying a confirmation message.
• The application displays "Not Found" when attempting to remove nonexistent items.
• Inventory count decreases after deletion
• Array preserves its structure and avoids creating null spaces within its data.
• Case differences don't prevent deletion
• The system handles operations on deleted items according to their intended behavior.
Test Case 3: Editing Furniture Items

The goal is to validate the correct modification of item details.

Test Scenarios:

• Users can modify all available fields within an existing item record.
• Users should modify particular fields without altering other fields.
• The system allows users to attempt editing items that do not exist.
• Users can edit items using boundary values that include zero quantity and zero cost.
• The name editing process requires different case variations of the name.

Expected Results:

• The system successfully updates all fields while displaying success messages.
• The system will display "Not found" when users try to access nonexistent furniture items.
• Users can keep their current field values when they do not modify those fields.
• Boundary values are handled correctly
• Case variations between original and edited data do not stop successful editing processes.

Test Case 4: Viewing Furniture Inventory

The goal is to verify proper item display for all products.

Test Scenarios:

• Display inventory with multiple items

• Display an empty inventory
• The system displays inventory information after users perform different operations
including addition and deletion and editing.
• The system should display currency values with two decimal points.
• The system shows a complete inventory that reaches near MAX_ITEMS limit.

Expected Results:

• The system shows all items with proper information displayed.

• The system displays "No furniture items" when inventory is empty.
• The display system shows inventory information that matches the present inventory
status.
• The system displays costs using AED currency with two decimal points.
 • Large inventories show all items without any display problems.

Test Case 5: Searching for Furniture Items

The fifth test case focuses on searching for furniture items within the application.
The goal is to confirm that the search system operates as intended.

Test Scenarios:

• The system allows users to search for existing items through their exact names.
• Search with different case variations
• Search for a non-existent item
• Search in an empty inventory
• The system should handle searches correctly when multiple items share identical names.

Expected Results:

• The system shows the correct item when performing an exact match search.
• Case-insensitive search works correctly
• When users attempt to find unavailable items the system presents "Not found" on screen.
• Appropriate message for empty inventory
• The system maintains a consistent behavior when multiple matches occur.

Test Case 6: Placing Orders for Furniture Items

The sixth test case involves placing orders for furniture items.
The system must function properly for placing orders.

Test Scenarios:

• The system allows orders with quantities that match or are lower than current stock
levels.
• Users should try to place orders that exceed the current stock availability.
• The system rejects orders when the quantity equals zero or any negative value.
• Order the exact available quantity
• Order a non-existent item
• Place order in empty inventory
Expected Results:

• The system processes valid orders to decrease inventory levels while determining
accurate costs.
• Orders exceeding stock are rejected
• Invalid quantities are rejected
• When customers order the exact amount of items available the stock quantity becomes
zero.
• Appropriate error for non-existent items
• Empty inventory handled

Test Case 7: Program Exit

Objective: Verify program exits correctly.

Test Scenarios:

• Exit program with option 7

Expected Results:

• Program terminates successfully

3b) Carry out testing on the computer programme using a

test plan

Test Case 1 Test Adding Furniture to Inventory

Expected Output Add Furniture with confirmation
Status Successful
Screenshot

Test Case 2 Test Deleting Furniture from Inventory

Expected Output Delete Furniture with confirmation
Status Successful
Screenshot

Test Case 3 Test Editing Furniture from Inventory

Expected Output Edit Furniture with confirmation
Status Successful
Screenshot

Test Case 4 Test Displaying Furniture from Inventory

Expected Output Displaying Furniture with confirmation
Status Successful
Screenshot

Test Case 5 Test Search Furniture from Inventory

Expected Output Displaying Furniture that's been searched
with confirmation
Status Successful
Screenshot

Test Case 6 Test Ordering Furniture from Inventory

 Expected Output Ordering Furniture that's been searched,
taking the amount of quantity thats been
ordered and calculating the total cost
Status Successful
Screenshot

Test Case 7 Test Exiting the Program

Expected Output Exits the program
Status Successful
Screenshot

Failed Outputs

Test Case 6 Test Search a different Furniture from

Inventory
Expected Output Displaying a different Furniture that's been
searched with confirmation
Status Failed
Screenshot

Test Case 7 Test Search a missing Furniture from

Inventory
Expected Output Displays a “Furniture not found in
inventory” Message
Status Failed
Screenshot

Test Case 8 Test Validation of proper integer for

Quantities and Amount
Expected Output Displays a “Invalid Integer” Message
 Status Failed
Screenshot

3c) Review and evaluate the programme based on the end

results
The Java program for furniture store inventory management establishes a reliable base for
inventory management yet suffers from multiple critical bugs that reduce its dependability. The
program successfully implements essential furniture store operations including inventory item
addition and deletion and editing and viewing while maintaining proper object-oriented design
through Furniture class inheritance from Product class.

The program shows successful results during basic usage which proves its functionality in
standard operations. Users can create new furniture items by entering their name along with
category information and quantity and cost values. The inventory deletion function successfully
removes items from stock after users enter the item name. Through editing users can perform
complete updates to every item attribute. Through the display function users can view all items
that remain in stock.

The program demonstrates several crucial problems when users attempt to extend its usage
beyond standard operations. The search functionality represents the most critical issue because it
includes an essential logical flaw. The search method stops its execution after checking the first
inventory item without considering whether the item matches the search parameters. The early
termination of the search process prevents users from finding any additional matching items
because the search stops after examining the first item even if other matching items exist in the
array.

The program faces critical problems when users provide input data especially when dealing with
numerical values. The program does not include sufficient validation systems to detect when
users provide text instead of numeric input. The program fails to handle errors with suitable
messages, so it likely produces runtime exceptions that result in a frustrating user experience. A
structural problem exists in the code because the editFurniture method lacks its closing bracket
which creates an overall structural issue in the program. The code demonstrates incomplete
testing in various conditions which may hide additional problems that escaped basic test cases.

Production-level code requirements for these problems require complete testing and an extensive
review session. The search functionality requires a complete redesign to achieve proper item
iteration across the entire inventory. The system needs to validate user input to provide smooth
handling of unexpected data. The program stability depends on checking all methods for correct
structure and error handling to maintain stability during unexpected usage.

The critical program flaws reduce both its reliability and usability in practical inventory
management contexts though it shows suitable design qualities and basic inventory functionality.
The resolution of these problems would convert the current functional prototype into a reliable
inventory management system that meets the needs of real furniture stores.

Reference:
alex.d (2024). What programming languages should your business be using? [online] ITC
Group. Available at: https://itcgroup.io/our-blogs/what-programming-languages-should-your-
business-be-using/ [Accessed 21 Mar. 2025].

BairesDev Blog: Insights on Software Development & Tech Talent. (2022). 6 Programming
Languages Businesses Should Use - BairesDev. [online] Available at:
https://www.bairesdev.com/blog/programming-languages-business-should-use/ [Accessed 21
Mar. 2025].

Edwards, D. (2024). Learn how programming languages can automate, optimize, and enhance
your business processes in four ways: reducing errors, improving efficiency, enabling
scalability, and facilitating innovation. [online] Linkedin.com. Available at:
https://www.linkedin.com/advice/3/how-can-programming-languages-streamline-business-yeu6c
[Accessed 21 Mar. 2025].
Costa, C.D. (2022). Top Programming Languages and Their Uses. [online] KDnuggets.
Available at: https://www.kdnuggets.com/2021/05/top-programming-languages.html [Accessed
22 Mar. 2025].

Gallagher, J. (2020). Top Programming Languages by Industry. [online] Career Karma.

Available at: https://careerkarma.com/blog/top-programming-languages-by-industry/ [Accessed
22 Mar. 2025].

Wambua, M., Jindal, R. and Morozov, M. (2023). What programming languages are used in
different industries? [online] Linkedin.com. Available at:
https://www.linkedin.com/advice/3/what-programming-languages-used-different-industries
[Accessed 20 Mar. 2025].

Wikipedia Contributors (2019). SCADA. [online] Wikipedia. Available at:

https://en.wikipedia.org/wiki/SCADA [Accessed 22 Mar. 2025].

Reljanović, J. (2020). How Similar Are Programming Languages? | HackerNoon. [online]

hackernoon.com. Available at: https://hackernoon.com/how-similar-are-programming-
languages-9an3u9z [Accessed 23 Mar. 2025].

Tom Delalande (2024). Comparing 10 programming languages. I built the same app in all of
them. [online] YouTube. Available at: https://www.youtube.com/watch?v=-MbTj8DGOP0
[Accessed 24 Mar. 2025].

Wikipedia Contributors (2018). Comparison of programming languages. [online] Wikipedia.

Available at: https://en.wikipedia.org/wiki/Comparison_of_programming_languages [Accessed
24 Mar. 2025].

Wikipedia Contributors (2019). Programming language. [online] Wikipedia. Available at:

https://en.wikipedia.org/wiki/Programming_language [Accessed 24 Mar. 2025].

GeeksForGeeks (2020). Introduction to Java. [online] GeeksforGeeks. Available at:

https://www.geeksforgeeks.org/introduction-to-java/ [Accessed 25 Mar. 2025].
Kumar, A. (2023). What is Object-Oriented Programming and Why is it Useful? [online]
Emeritus Online Courses. Available at: https://emeritus.org/blog/coding-what-is-object-oriented-
programming/ [Accessed 25 Mar. 2025].

Codeacademy Team (2017). Methods and Functions. [online] Codecademy. Available at:
https://www.codecademy.com/article/fwd-js-methods-functions [Accessed 26 Apr. 2025].

Wikipedia. (2020). Method (computer programming). [online] Available at:

https://en.wikipedia.org/wiki/Method_(computer_programming) [Accessed 26 Mar. 2025].

Wikipedia. (2022). Function (computer programming). [online] Available at:

https://en.wikipedia.org/wiki/Function_(computer_programming) [Accessed 26 Mar. 2025].

Pittet, S. (2019). The different types of testing in Software. [online] Atlassian. Available at:
https://www.atlassian.com/continuous-delivery/software-testing/types-of-software-testing
[Accessed 29 Mar. 2025].

Wikipedia Contributors (2018). Agile software development. [online] Wikipedia. Available at:
https://en.wikipedia.org/wiki/Agile_software_development [Accessed 29 Mar. 2025].

And, T. (2024). Programming languages are the backbone of the modern digital world, serving
as the building blocks for software development. Each programming language comes with its
unique set of advantages and disadvantages, catering to different needs and preferences of
developers. [online] Linkedin.com. Available at: https://www.linkedin.com/pulse/advantages-
disadvantages-each-programming-aeczf [Accessed 16 Apr. 2025].

Ashraf, N. (2023). What Is a Programming Language? An Introduction to Coding | ProfileTree.

[online] ProfileTree Web Design and Digital Marketing. Available at:
https://profiletree.com/what-is-a-programming-language/ [Accessed 16 Apr. 2025].

Bello, A. (2023). Benefits of Programming Languages. [online] Amorserv.com. Available at:

https://amorserv.com/insights/benefits-of-programming-languages [Accessed 17 Apr. 2025].
ihavezerohealth (2023). Tutoring Computer Science: Programming - ihavezerohealth - Medium.
[online] Medium. Available at: https://medium.com/@michallahcim01/tutoring-computer-
science-programming-b49a933ae3c2 [Accessed 17 Apr. 2025].

Wikipedia Contributors (2019). GitHub. [online] Wikipedia. Available at:

https://en.wikipedia.org/wiki/GitHub [Accessed 18 Apr. 2025].