What is Computational Thinking?

Computational thinking is the thought processes involved in formulating problems so their solutions can be
represented as computational steps and algorithms, and it consist of 3 main components, decomposition,
pattern recognition and pattern generalisation and abstraction.
Decomposition
Decomposition is the breaking down of complex problems into small manageable parts to make it easier to
understand/solve. For instance, a real-life example of decomposition can be math: when learning math, you
decompose the subject into topics which makes it easy for you to learn as now you can learn one by one.
Another example is when you are doing your chores: you firstly make a to-do list where you have all your tasks
listed vertically (most often) that you must do by the end of the day. Decomposition is broken down in the
following stages:
Firstly, you need to identify and describe the problems and the processes; here, you briefly list down the
problems and the processes using the same language that matches the problem. For example, if you’re
dealing with financial issues, use appropriate financial terms. Therefore, this tells that you must be familiar
with the language of whichever problem you’re dealing with.
Secondly, you break down problems and processes into recognisable steps; at this point, you will decompose
complex problems into a series of small manageable problems which can then later be reassembled together
correctly. There is no limit on the level of decomposition, so you may carry on decomposing until it’s easy for
you to understand. An example we can refer this to, is an employee’s net pay. So, for instance, if you need to
calculate weekly wage for the employee, you must follow these steps: at first, you calculate how many hours a
week does the employee work (e.g., 40 hrs). Then, you calculate how much they get paid per hour (e.g., £10).
You then proceed to also calculate how many additional hours they work (e.g., 3 hrs). Later, you multiply the
numbers to find the weekly pay (=£430). Then u take out the tax, national insurance and pension (optional)
from the weekly pay which will give the final payslip of the employee.
Thirdly, you describe the problems and process as a set of structured steps. Here, you will need to explain the
problems/process that you decomposed. This means it should be straightforward enough to be understood by
others.
Lastly, you communicate the key features of the problems and processes to others. In this last stage, you’ll
need to discuss the problems/process to others. This may also include other experts or clients. The benefit of
this process is that they may help you sort through the problem and see the situation more clearly. And once
you have decomposed the complex problem, you can then start to look at the steps involved to see if there is
any repeating pattern.
For example, one of the most common programming languages between programmers,
python, one of the main steps in designing a parallel program, is to break the problem
into discrete chunks (decomposition), that can be distributed to multiple tasks so they
can work on the problem simultaneously.
Advantages
One advantage of using decomposition is the significant change of complex problem
broken down into small “chunks”, which are much easier to understand. This is useful as
it allows many programmers who need to solve down programming problem. This also
saves their time which is also an advantage as it increases productivity. A key example
to support this statement is the development of games. For instance, if the programmer
is making a Tic-Tac-Toe game, they will need to break down the different win possibilities
a player can go through. Then, they’ll need to logically solve that problem by going
through the different steps the user (player) goes through.
Another advantage of using decomposition is the enhance understanding. This means
that not only it will be relatively easy to solve, but you will also have an understanding of
the overall system. This allows you to have a greater picture and greater understanding
and the individual components of the system you’re making. A key example to support
this statement is the divide and conquer method. This is where a problem is divided into
smaller subproblems. Then, each subproblem is solved individually, and at the end, the
solutions are combined to solve the original problem. This is an example of
decomposition in algorithm design.
In addition, another advantage of decomposition is the improvement of robustness,
which makes it easier to test individual parts of the system. By doing this, the system
will be enhanced after the tests, which decreases the chances of human error. A key
example to support this statement is the testing of systems. For instance, a database.
Here, the individual parts of the database, such as macros, are tested with different
values making sure that the system is working correctly. This may take up a long time,
but it is important as it minimised human error.
Disadvantages
However, on the other hand, a disadvantage of decomposition is that the programmer needs to fully
understand the problem he´s trying to solve because otherwise he will end up writing a code that it is not
specific to the problem. For instance, if the programmer is designing a game, with key data such as in-game
currency, and he doesn’t know how the currency work, it will most likely end up with some errors as the
programmer doesn’t understand the logic of the game, and how he actually needs to program the game the
way it should actually work.
Another disadvantage is that the different programmers of a team working on the code need to have a really
good team working or the codes written won´t fit properly making the output poor. This is because not every
programmer has the same level of skills as the other, meaning that one programmer needs the help of the
other, so that it will increase the productivity, and it will also produce a good output. A key example to
support this statement is the development of a website for big companies. This is because both front-end and
back-end programmers need to have a good communication between each other, so that they can produce a
good output.
Furthermore, another disadvantage of decomposition is the requirement of effective planning. This means
that a poorly planned decomposition will result in a poor output, and also resulting in the problems still being
complex. A key example to support this statement is the development of a game. For instance, if the
programmer is making a Tic-Tac-Toe game with a poorly planned decomposition plan, the game will end up
crashing as soon it’s executed. This could include things such as the system not recognising an integer as a
string due to the lack effective planning done by the programmer.
Pattern Recognition
Pattern recognition is the ability for a machine learning algorithm to automatically recognise patterns and
regularities in the same problem. This data can be anything from text and images, sounds and other.
Identifying these patterns can make problem solving much easier. For example, when doing the laundry, and
drying off the socks, you use pattern recognition to match the socks to each other. Another example is when
we recognise the traffic light turning yellow: we are aware that the pattern of the traffic lights in the area that
the turn lanes for cross-traffic will be green first, followed by straight cross-traffic, then turn lanes in our
direction, and finally our light will go green. In addition, pattern recognition is broken down in the following
stages:
Firstly, you need to identify common elements or features in problems or systems; here, you first examine the
problem to understand it before proceeding and solving it. You list the elements/features that exist in each,
and you highlight those which exist in multiple places. These will be recognised as patterns. For example, you
want to search for a student in a school, and to do you would need to use a searching algorithm (e.g., binary
search).
Secondly, you identify and interpreter common differences between processes/problems; here, you repeat
the same steps you have done in stage one. So, you understand the problem/s, find common differences in
the problem. For example, when taking the register, one system might simply record present and absent.
Another system might record, present, planned absence, unplanned absence and late. And lastly, list elements
or feature that exist in each and highlight those which are unique. These will be recognised as patterns.
Thirdly, you identify individual elements within the problem. This means that you will need to examine the
problem, identify the inputs, processes and outputs that are present. For example, when marking a student,
the character entered against the student's name could be '/' or ‘P’ to show that he’s present. Or ‘\’ & ‘N’ to
show that he was absent. This data will be saved in a database and the output will be a percentage showing
the attendance of each student.
Fourthly, you describe patterns that have been identified; once you identified the patterns, you can now
describe it.
Lastly, make predictions based on identified patterns, meaning once you identified a pattern, you can now
guess whether it can be reused in your existing program or in another program.
For example, Python, which consists of multiple libraries which can be readily imported
and used in applications involving recognizing patterns and processing images.
Furthermore, the patterns can be printed by using simple for loops or by matching it with
a particular pattern.
Advantages
An advantage of pattern recognition is the automation and efficiency. This is because
patterns are spotted easily and quickly because they are constantly seen, which
becomes much easier to identify through muscle memory. A key example to support this
statement is the traffic light. This is because we may recognise that an upcoming timed
traffic light has turned yellow. This is also because we are aware that the pattern of the traffic
lights in the area that the turn lanes for cross-traffic will be green first, followed by straight cross-traffic, then
turn lanes in our direction, and finally our light will go green.
In addition, another advantage of pattern recognition is the efficient problem solving, which helps the
programmer have a greater picture and understanding of the system. This is because by recognising patterns
in data, programmers can identify similarities and commonalities across different problems. By having this, it
allows the programmers to develop organised strategies which are applied in different contexts. A key
example to support this statement is after doing the laundry. This is because pattern recognition will be used
to pair the matching socks.
Furthermore, another advantage is the capability to recognize and assess repetitive patterns in data or code,
enabling developers to make better decisions. Programmers are able to develop algorithms and models that
can identify and analyse similar patterns within vast amounts of data by acknowledging patterns, ultimately
leading to time and effort saved. The ability to recognize patterns is especially valuable in areas like machine
learning and artificial intelligence. For instance, in image recognition, pattern recognition algorithms can learn
to recognize certain objects or traits in images, allowing for tasks like facial recognition, object detection, and
self-driving cars.
Disadvantages
One possible drawback of utilizing pattern recognition in programming is the potential for overfitting.
Overfitting happens when a pattern recognition algorithm gets too focused on recognizing certain patterns in
the training data and struggles to perform well on new, unseen data. This may result in incorrect forecasts or
categorizations. In machine learning, when a pattern recognition algorithm is trained on a limited and skewed
dataset, it might learn to identify patterns unique to that dataset but struggle when faced with different new
data sources. Overfitting in practical applications of pattern recognition algorithms is still a significant concern
despite the use of methods like cross-validation, regularization, and feature selection to reduce its impact.
Another disadvantage of utilizing pattern recognition in programming is the risk of obtaining imprecise
outcomes. You could encounter incorrect results known as false positives, where the algorithm mistakenly
detects a pattern that does not exist. There is also the possibility of false negatives, in which the algorithm
overlooks a pattern that actually exists. This could result in incorrect decisions or actions being taken based on
those findings. For example, in a spam prevention system, incorrect identifications could result in important
emails being labelled as spam, while incorrect omissions could allow real spam emails to go unnoticed. Finding
a middle ground between incorrect positive and incorrect negative results is important for trustworthy and
efficient pattern recognition algorithms.
A downside of utilizing pattern recognition in coding is the risk of biased results. The reason for this is because
pattern recognition algorithms are trained on the current data, which signifies that they have the potential to
pick up on and strengthen biases that are already present within that data. For example, a facial recognition
algorithm that is mainly trained on data from one race or gender, could have difficulties identifying or
categorizing individuals from marginalized groups. This may result in biased treatment or prejudice in different
scenarios, like recruitment procedures or police activities. Addressing and reducing biases in pattern
recognition algorithms is essential to guaranteeing fair and equitable results for everyone.
Pattern generalisation and abstraction
Abstraction is the process of displaying only the essential information and hiding the details. This is useful as it
allows the programmer to use a feature without having to know exactly how it works as the irrelevant
information is now removed with the use of abstraction. A real life of example of abstraction is a car: when
turning on the car, you don’t need to know how the engine is getting started as it is irrelevant information.
Pattern generalisation when links between patterns are identified. For example, you might want to search for
students in a class, or who are being taught by a specific teacher.
In addition, pattern generalisation and abstraction are divided into two sections:
Firstly, you need to identify the information required to solve the problem. You can get this by
 Knowing what information, you need
 Knowing the reason for it
 Knowing the format in which you need the information in
 Knowing the currency of the information to not delay the information
Secondly, you need to abstract the irrelevant information to solve the identified problem. You can do this by
 Knowing the irrelevant information
 Knowing the purpose if why you extracted this information
For example, in python, when you write in your codes, the program automatically removes all the irrelevant
information, such as, how the CPU complies from a high-level language to a low-level language which matches
the program so it can understand.
Advantages
One advantage of using abstraction is that it makes complex systems easy to use. This is because abstraction
enables developers to conceal superfluous aspects and concentrate on the vital elements of a system.
Programmers can develop reusable modules and libraries that are easy to understand and use by others by
forming abstract representations of real-world objects or concepts. In object-oriented programming, a class
serves as a representation of a tangible thing from the real world, containing its characteristics and actions.
This enables developers to generate various copies of the class, each symbolizing a distinct object with its
individual traits. Through abstraction, developers are able to produce code that is more modular,
maintainable, and scalable, ultimately leading to time and effort savings during the development stage.
Another benefit of incorporating abstraction into programming is the enhanced ability to reuse and maintain
code. Programmers can save time and effort by using existing code instead of starting from scratch, through
abstracting complex functionality into reusable modules or classes. In game development, developers use
abstraction to create broad game mechanics that can be applied to various levels or scenarios in a game. This
not only reduces the development time but also makes it easier to update or change the game without
affecting the entire codebase. Abstraction helps in developing code that is modular, well-organized, and easier
to understand, debug, and maintain in the long run.
Another benefit is that it aids in simplifying the complexity of the code. Programmers can concentrate on the
higher-level design and functionality of their code by removing unneeded details. This helps to enhance the
clarity, flexibility, and troubleshoot the code. Abstraction in game hacking, for instance, enables the distinction
between the hacking logic and the particular game mechanics. In this manner, you can focus on utilizing the
hacking methods without getting overwhelmed by the complexities of the game. Abstraction makes the
development process easier and encourages writing code that is easier to understand and manage.
Disadvantages
Although abstraction can make code easier to comprehend and upkeep, it can also add extra abstract layers
that might not be needed or could cause confusion. This could result in decreased performance or higher
memory consumption. In some cases, excessively abstracting can lead to longer execution times as a result of
having to handle and navigate through numerous abstraction layers. Moreover, poorly designed or
implemented abstractions can lead to increased difficulty in debugging and troubleshooting the code.
Maintaining a harmony between abstraction and simplicity is crucial for writing code that is efficient and easy
to manage.
Another disadvantage of using abstraction in programming is the limited control and flexibility. Programmers
may sacrifice the opportunity to adjust or perfect certain elements of their code by removing low-level details.
This could pose a challenge in situations where performance or particular features are important. When
dealing with demanding hardware applications or real-time systems, abstraction layers can create extra work
that limits the performance you want to reach. In such cases, it might be required to use a more hands-on and
detailed method to have better management of the code and how it runs. It's crucial to thoughtfully assess the
trade-offs between abstraction and control in accordance with the project's precise needs.
Another drawback of abstraction is its potential to result in a diminished comprehension of the fundamental
system. When simplifying intricate details, programmers might become disconnected from the fundamental
mechanisms of the code and the underlying ideas. This can create difficulties when trying to identify and fix
problems that come up. If a bug arises in a module that is highly abstracted, it may be challenging to pinpoint
the root cause without delving into the underlying code, especially if the programmer is not acquainted with
it. Finding a middle ground between abstraction and comprehension is crucial for efficient problem-solving
and sustaining manageable code.
Use of software applications
Software applications are software specifically designed to carry out specific tasks, problems and fulfil user’s
needs. Furthermore, there are many ways to classify the applications, for example, by the software license, by
the computer platform or by use. A popular use of software application category is gaming;
Videogames can be used to entertain, educate or help to recover from trauma. For instance, Call of Duty is a
popular example of videogame. However, it is vital to also look after yourself, as too much gaming can cause
mental issues (e.g., depression), physical issues (e.g., obesity), aggression, lack of motivation, etc...
Another example of software application category is Entertainment. Such applications help user relax and
enjoy various forms of media, like music, video, books, etc... The following list will show some popular
examples of entertainment applications: Apple iTunes, Microsoft Media Player, BBC iPlayer, etc... Although
this seems fine, it is essential to not get addicted as too much of it can result in lack of social isolation.
Another example of software application category is Productivity. Such applications like spreadsheets,
databases, word processors, etc... help workers complete task more efficiently. Some popular examples of
productivity are Microsoft Office, Adobe Office and Google Drive. A positive effect of this is that it improves
productivity, greater efficiency, new problem-solving techniques and reduced costs.
Another example of software application category is Information store and Management. This sort of
application store and manage data safely and allows quick retrieval, mostly through the Internet. Some
popular examples are Dropbox, iCloud and Google Drive. This is a benefit for the user as their information is
safely stored, so they won’t have to worry about data loss and.

Preferred Application Areas

Different programming languages specialise in different application areas, the inferior list
will show specific famous programming languages specialised in certain field.
C language: C is considered to be a general-purpose-language which focuses on
different sectors such as banking applications, operating systems, videogames
development, etc… also C language is specialised on games as it is better for
machine code so most of videogames use C language etc… But C language is
overstanding on controlling external elements of hardware because the system
demands a low level of controlling hardware. As mentioned before C language is
used for the development and creation of videogames for any popular platform
such as PC or console. This language is popular in games because the code is
broken down into logical fragments which makes the code easy and to understand
and reuse it leading to an effective creation/development. Also, this language
contains a particular feature identified as Microsoft´s XNA, this feature is essential
for the game development as it provide unique tools for videogames to create and
develop the best version of it. Some advantages of this language is that the code
is easier to write, also this language has a rich library which provides with a lot of
useful codes that programmers can apply into their software, another advantage is
that the code is executed rapid because it normally uses less codes than other
programming languages and that also means that the process of compilation
takes less time. However, a drawback of C is that there is no garbage collection
which leads to invalid codes sometimes, also in C there is no namespace present,
so it makes the code a little bit complex. This language is important in software
development, specially in the gaming industry because it has a great impact on
 the software qualities and so this language should be developing even more to
offer the include the beast features inside a software.

Java: Java is specialised on website development and mobile applications the code
in this language is useful for different devices as it uses a method to approach
those devices which is write the code once and run it everywhere, also its ability to
move the computer systems easily from one to another makes a reason why this
language has a high demand and Java has a generic and compact code so that
different devices can support the code. Advantages of Java can be that this
programming language is easier to move from one system to another which is
beneficial especially for businesses, also java Is easy to learn because is a high
programming language and so therefore this also means it is easier to debug,
additionally this language is object orientated which means that the programmer
can reuse codes saving time and effort. Disadvantages is this language are that it
needs to go through compiler for the CPU, therefore this may mean that a code
can be longer than expected taking space in memory, another drawback is that
Java provides a poor graphical user interface (GUI) so that means when creating a
software, a programmer can´t depend on Java for GUI as this language is not
developed for complex GUI. Java has a great impact on software development as it
allows to the programmer to move easily from one system to another and so this
is crucial as this determines why Java succeeds.

PHP: This language is used to create server-side applications for businesses in e-

tail and e-commerce, the advantage of this language is that the source code of the
program is available to the public allowing them to download and read the source
code. Another benefit is that applications related to PHP can be downloaded
rapidly because this programming language requires of low level of internet
speed. Additionally, this language has a powerful library which can be used by
programmer to code. A Drawback of PHP is that because the source-code is open
that makes the PHP insecure, another limitation of this language is that when
more tools and features are used inside the program, the program will offer less
performance reducing the speed and efficiency.

Objective C: Objective C main purpose is to create application for portable Apple

devices IOS devices, examples of this company devices can be iPhone, iPad, iMac,
etc… this language is the preferred by Apple company because this language has
existed for many years providing to the company a great quantity of codes to work
with. Also, this language is compatible with C and C+ and furthermore Objective C
has a stable code. However, a disadvantage of this language is that the syntax of
this language is complex to understand as it is different from any others
languages, also a minority of programmers are interested in Objective C language
because it is hard lo learn. Overall Objective C is also important in software
development because it is the main language that iOS devices use.

Features & Characteristics of Programming Languages

When executing the code, the computer compiles all that coding script and turns it into binary as it is much
easier for CPU to understand. Although it is fast and efficient in executing, it took a relatively long time to
create such complicated applications. By time, newer low-level & high-level programming languages were
developed.
Low-level language is hard to learn, it’s typed in hexadecimals, and it takes much longer to write it down.
However, it executes very quickly as it is the closest language to the binary and allows the CPU to understand
it better.
High-level language is easy to learn as it is mostly English, and it takes a much shorter time to write down than
low-level language. However, it takes much longer type by the CPU to execute as it must compile the whole
coding script and can take a lot of time.
The picture below shows an example of low-level programming (left side) and high-level language (right side),
and clearly shows how much harder one language is from the other.

Although low-level language is long and stressful, they can also be fun and creative. This is because you can
use them to create your own programs, games, or applications that run on the bare metal of the computer.
You can also use them to modify existing programs, such as reverse engineering, patching, or hacking.
On the other hand, high-level language can be used for a wide variety of applications, including web
development, scientific computing, data analysis, artificial intelligence, and video game development.
Furthermore, they produce code that is easier to debug, code that can be shifted and allows for the use of
more flexible program development tools.

Paradigms
In programming, paradigms are different ways a programming language can be organised. Multiple
programming languages can belong to different paradigms. For instance, Visual Basic .NET is relying on classes
such as buttons, labels and forms which represent the basic of the Microsoft Windows operating system.
Below is a table I made listing the different languages, their level, strength/weaknesses and any possible
application you can make with the languages
Procedural
Procedural programming are programming models which are taken from structured programming, based
upon the concept of calling procedure. The main purpose of this, is to help a device perform tasks, and it's one
of the languages programmers use most often as they are often the first one learnt by a programmer. They are
written in a set of well-defined steps which solve a bunch of problem, for example, a simple calculation in C#.
For example, to develop a simple Bank Account App procedurally, you need to create an account for an
individual (account), get an account to deposit or withdraw funds (get account, deposit, withdraw). Procedural
have a bunch of sub routines like functions and procedures and then these can be called from the main
progam. Furthermore, on one hand, the advantages of procedural programming are that it’s excellent for
general-purpose programming, simplicity of code and less demanding on memory use. On the other hand, the
disadvantages of procedural programming are that the program code is harder to write when procedural
programming is written down, the procedural code is often not reusable, which may pose the need to recreate
the code if is needed to use in another application and it’s difficult to relate with real-world objects.
Object-Oriented (OO)
Object-oriented programming is based on the concept of objects. In object-oriented, objects are created from
classes which are usually based on real-world things (e.g., bank accounts, products, customers, etc...). Each
class acts as encapsulation: they contain programming data structures, or objects, which are defined, each
with its own properties or attributes. each object can also contain its own procedures or methods. In addition,
the programmer creates individual interaction between different objects, so they can solve problems. Also,
because each class exists differently, they can be easily adapted to contemplate changes in the real world,
without negatively effecting the whole solution. An example we can consider object-oriented programming is
to a car. A car has a model name, a colour, a year in which it was manufactured, an engine size and so on. We
would therefore create a car object with the name, colour, engine size and year as attributes. The advantages
of OOP are re-usability, which means reusing some facilities rather than building them again and again, data
redundancy, code maintenance, security, better productivity and many more. Whereas on the other hand, the
disadvantages of OOP are steeper learning curve, potential performance overhead, memory consumption,
lower execution efficiency, and complex designs.
Encapsulation: Bundling of data with the methods uses by the programmer to operate
on that data, it is used frequently in a form of classes as then the code will be easier to
reuse for the programmer which can save him time at the time when creating a class of
“something”. The attributes are set to private so it helps with keeping data secure and
through set and get methods you can use them in the class.
Inheritance: Method where the programmer can acquire features and behaviors /
attributes and methods from another class in order to share the same attributes and
change it a little bit to create a new data in the same class if the programmer wants.

Event-driven (ED)
Event-Driven is a programming paradigm in which the program is committed by any event triggered from the
user action, which can be from mice and keyboards. Unlike, procedural, which follows step-by-step, this
typically works non-sequentially with the user able to select operations they want to perform. Some examples
of programming languages that are event-driven are Microsoft Visual Basic .NET, Python, Ruby and Java.
Developers typically focus on programming events handlers, which are codes that specifies the action
triggered by a listener. A listener is a process that waits for a certain event to occur. For example, when a
file>open menu is clicked, a file open dialog will appear. In addition, the advantages of ED are that it enhances
the performance, maintainability, and adaptability of software applications. Whereas on the other hand, the
disadvantage is the complexity, debugging and troubleshooting challenges and difficulties with monitoring.
Machine
Machine programming is about automating the development and maintenance of software. It’s the numeric
codes for the operations that a particular computer can execute. Machine code is also the elemental language
of computers. It is read by the computer's central processing unit (CPU), is composed of digital binary numbers
and looks like a very long sequence of zeros and ones. Therefore, the code must be written for a specific CPU
family, for example, Intelx86 (32-bit) or x6 (64-bit). The advantages of machine programming are that it runs
very fast as no translation is required from the CPU. Also, it’s easy to organise, easy file access, helpful tools
and much more. On the other hand, the disadvantages are that it has limited understandings, vulnerability to
errors and can replace one’s job.
Below is an example of machine code whose function is generic for all M controllers will return
True in case of forced IOs:

Markup
Markup programming language is a text encoding system that consists of symbols inserted in text documents
to control its structure, formatting, or the relationship between its parts. They are mainly used to structure
and format text and other content on a webpage, and it includes programming languages such as HTML and
XML. The advantages of markup language are the cost efficient of the program, the ease to learn, flexibility
and easy to read. Whereas on the other hand, the disadvantages are the complexity in document structure,
limited security and the lengthy code for complex webpages. Also, Markup is a form of language used to
specify the content formatting of a document in a structured manner using specific tags. For example, in
HTML, <p> is used to show the start and end of a paragraph.
Below is an example of <p>
Scripting
Scripting is a way of delivering instructions to a computer (or group of computers), as with all forms of
programming. The instructions in question not only tell a computer what to do but when and how to do it, as
well. Also, it is primarily used to automate tasks for websites and web applications while using an existing
program, and it includes programming languages such as Perl, JavaScript, Ruby and PHP. The advantages of
scripting languages are that most network administrators know how to script, it’s free and each operating
system has a built-in scheduler, which is also free. Whereas on the other hand, the disadvantages are that
typically the lack the coding standards followed by developers. Not all scripts are created equal. Their
structure can wildly vary from one developer to the next, and they can be very hard to read and understand.
An example of scripting language is Perl and Ruby, which are often sued to automate system processes on a
computer by linking and executing tasks that may have been run separately by another user.
For instance, the picture below is an example of scripting languages as if statement, are considered as
conditional statements, therefore, comes in the scripting language

Programming Languages Constructs

Programming language constructs are the base and foundation necessary to create and
develop any program. These tools can be used in several ways and
techniques/paradigms can be applied to solve any problem given to the programmer.
One thing to mention is that when the programmer learns the bases of one programming
languages, he will detect similarities with other programming languages meaning that
the user will have a better knowledge of distinct languages leading to ease when
programming. Codes are the main structure to program, different languages provide
different structures and functions. There are three main elements inside the coding that
make the foundation of the program and are necessary in order to have an effective
code.
Command Words
Command word are one of the main codes to make the foundation of a programming
language, the purpose of this feature is to perform a unique specific task set by a single
word. Command word cannot be manipulated, and the programmer can only set one
single task for each command word. For example, “insert a text box”. These words are
reserved words that assign instructions to an object, for example in VB.NET
programming objects are created in the Graphical User Interface and the objects are
labeled with command words such as LBL for label, CMD for button, STR for string (text),
etc… For every language the coding and purpose of command word can vary a little bit
however as the programmer gains more experience with distinct programs, he will spot
similarities related to command words. Some of the operating systems doesn´t offer user
interface therefore in that type of systems the programmer must write the command
code inside a designated line in the display panel. An advantage of command words is
that the programmer will have a better control of his coding and he will be able to code
faster as he will know into which object to code, also by the command the object is
limited to perform only a certain task, therefore this will ensure that no errors are made.
However, a drawback is that programmer must know precisely every command word so
that they assign in properly and not make any errors.
Identifiers
Identifiers are names of codes set inside the program (stored in the computer RAM) to
fulfill a task. Most of the programming languages use a range of different identifiers to
set their program, however there are 2 of them that are easy to use and understand,
also, these 2 identifiers are the most common used in programming.
Variable: Identifier that representing values that can be changed while running
the program
Constant: Identifier that remain with the same values while the program is
running
As stated before, Identifiers are names that the programmer sets to the different
elements these elements are types, functions, variables, labels, etc… An example can be
when a user is inputting some personal information, the field data of birth is a variable.
The reason of that is because every user will have a different date of birth, therefore
there will be stored a range of different information making this fields variable to store
different data. On the other hand, a clear example of constant is when welcoming a user
into a webpage. As constants are not expected to change the user can welcome a user in
a page by typing “Hello dear customers” this string will remain the same for all of the
users as its purpose is to display a single string. Advantages of identifiers is that the
programmer will know straight what is inside the code, therefore if the programmer
wants to manipulate some data it will be easier to identify it and to avoid any error,
another benefit is that if other developer are working on the same program identifiers
will make the task easier for that programmers as they will understand the code better.
Additionally, identifiers follow a strict rule such as data of birth which will have a format
of a NN/NN/NNNN so the programmer ensures that no misleading data is inputted by the
user avoiding problems later on. A limitation of identifiers is that they should be named
properly and remembered by the programmer otherwise in the coding stage it would be
a time consuming to figure out the identifier name. However as stated before this is
extremely important in software development as it will make the code process easier for
every developer, additionally identifiers will help to find bugs quickly which is beneficial
for developers.
Creating Identifiers
When a programmer considers creating an identifier inside the program, he must add
two factors in the programming language to have a “effective” identifier. The
programmer should declare a name and a data type for the constant or the variable.
The programmer needs to select the correct data type for the information he wants to
input, for example for a name the programmer should chose short text as a data type.
Furthermore, an important factor is the name given to the identifier, it needs to be a
specific and sensible name as it will be used afterwards to code, and it will be shown to
the user e.g., to store data about the user´s date of birth the identifier should be named
as “Date of Birth”, so it needs to have an appropriate name. However, the programmer
must take care with the name he selects for the identifiers because some names are
restricted as they are stored in a language for a particular, but it depends on which
programming language. Additionally, while creating an identifier the programmer needs
to take care with the coding as the syntax has its requirements. The main requirement is
that all new identifiers must have the first character as a non-digit. Also, another
element which the programmer needs to take care is with the letters case. For example,
in C compiler the language detects uppercase and lowercase as a distinct character so
this can be positive, but it also has its drawback as the programmer may not know about
this and he will encounter an error. An example of case sensitivity is shown below.

Case-sensitivity: Process when a programming language detects differences between

upper and lower case. For example, if a word is expected to be in lower case and some
character is in upper case, an error will appear helping the programmer to fix the bug.

Naming Conventions
Conventions are recommendations specific for programming languages, these
recommendations include methods of how to write the programming language
effectively, programming styles, etc… for examples recommendation that conventions
can offer in programming styled can be functional programming, modular programming
and object orientated programming. A lot of naming conventions are used nowadays
however the are some popular conventions that are used by most programmers.
Advantages of naming conventions are that by using recommendation the code is easier
to read and understand which improves the consistency in within a team which is crucial
in software development, also depending on the program naming conventions can have
a text with some rules (shown below) so it makes it easier for the user to write the
appropriate information. However, a drawback is that the programmer can make a
mistake and name the convention with an existing name, therefore when he starts to
code he will find 2 different elements with the same name which can lead to problems
later on. Despite that human error, naming conventions are useful in software
development because they reduce the need of understand the code fully and so
developers can focus on other bugs affecting the program critically rather than some
syntax or string saving a great amount of time.
For example, to store the shoes size of a person in C#:
Naming Convention Example Characteristic
Snakecase int person_size; Words are in lowercase
linked by an underscore
character
Camelcase int personSize; First letter must be
lower case and upper
case needs to be
applied in the initial
letter of a successive
word.
Pascalcase int PersonSize; Words are delimited by
capital letters

Local and Global Variables

When programming, a programmer needs to think about the local and global variables
inside the program. A global variable is a variable that can be applied anywhere in the
code, and they can be used in any function, additionally this variable can be reused
anywhere in the program as it can be applied anywhere. On the other hand, local
variables are variables that are only applied in a specific function inside the code,
therefore local variables are restricted to be used unless inside a specific block of code.
The functions of these variables is to store information and be able to manipulate them
when the program is running. For example, when coding the value “1” can be assigned
as a first name and value “2” can be assigned as surname, therefore during the
execution of the program the statements 1+2 Is replaced by first name+surname giving
the full name of the individual. An advantage of a global variable is that the programmer
should only declare the variable one time outside the sub and then he will be able to use
it anywhere in the program, another benefit is that global variables have to capacity to
store constant values as it will keep the values with consistency, additionally the global
variable can be accessed from any function in the program saving time to the
programmer and making the coding stage more productive, however a drawback is that
the programmer can end up with too many global variables affecting the overall storage
of the computer. On the other hand, advantages of local variables are that the values
will always remain the same even if the program is running, also the programmer can
name all the local variables with the same name as the variables will only be recognized
by the function they are declared in, therefore if all the local variables share the same
function then there is no need to have different names making the coding easier for the
programmer. However, a drawback of local variables is that the debugging process is
complex so it will be time consuming. Overall, are needed in software development as it
makes the code easier to read and understand by the descriptive names, also these
fields are where the information will be retained in and extracted for the user, so it is a
must to have variables.

Data Types
A good programming language will always have a range of data types for the code. The
main purpose of data types is to tell the computer how to interpret a certain value, this
is advantageous for the programmer as it avoids errors when data is inputted and also it
gives the value that the programmer expects. Data type will store the value defined by
the programmer, overall, in most languages the common data types are:
Character: This data type stores only a single value, an example can be the initial
of someone’s name (characters are any letters, digits, punctuation marks, or blank
spaces). Memory usage of 1 byte.
String: This data type stores a certain quantity of characters, an example can be
the full name of a person. Memory usage of 1 byte per character. Written as str in
code
Integer: This data stores a whole number avoiding decimal, e.g., Age of people.
Memory usage of 2-4 bytes. Written as Int in code
Real: Real (also known as floating point) stores number with decimals, an example
can be the exact profit of a company in a year. Memory usage of 4-8 bytes.
Boolean: these are values given by the program which stores 2 types of
information, true or false. Memory usage of 1 byte. Written as bool in code
Long: Data type used for large integers such as pi number. Written as Lng in code
Date: Used to store information about date and time, and example can be when in
the systems it asks you about you full date of birth, 00/00/0000 commonly in this
format. Written as dat in code
Single: To store decimal numbers such as Pi Number, written as sng in code
Additionally, there are some other rules besides data types that can be applied to
acquire a more accurate response and reducing the error, for example applying the
maximum of field size or a range between the allowed values. As distinct programming
languages support the use of data types all language has a different style to apply the
data types. The image below shows different styles of applying data types in different
popular languages. Advantages of data types are that they define the size of the
variable, therefore this will allow to the programmer to keep a track of his storage saving
space in the hardware. Another benefit is that as the data is assigned to a format such
as number or string, that will keep the data accurate and will avoid errors later on,
additionally variables will help to understand and to code in an effective way as variables
store the information and they can be extracted whenever the program wants. However,
a drawback of data types is that as the data needs to be precise so that will take more
time to the program to run it therefore it will affect the performance of the software,
specially if the software is running in a hardware with a low RAM. Therefore, data types
are essential in software development due to its accuracy, developers will set to a data
to collect only a certain type of information so the program will be mostly free from
errors, and therefore spotting bugs will also be easier.

Principles of computer programming that are applied to produce software

applications
Abstraction
In C++, abstraction is defined through classes and objects. This is because classes act as
a blueprint for the objects, establishing their attributes. By using methods that interact
with objects whilst hiding the internal compiling, developers can abstract their code.
In JavaScript, abstraction is used through functions and callbacks. These allow
developers to reuse the same code elsewhere without the need to write it again.
In .NET, abstraction is defined through the interface. This is because when using
interfaces, developers can create datatypes that are used with no errors, allowing
greater flexibility and control over the code.
Modularity
In C++, modularity is achieved through various ways, one is namespaces. These allow
the programmers to group related code together to prevent any naming conflicts. In
addition, you can also add classes to namespaces, to distinguish them from other
namespaces, even if they have the same name.
Similarly, in JavaScript, modularity is achieved through many ways. One example is
CommonJS. CommonJS is a system module that allows the programmer to create files for
separate modules and put them where they’re needed.
Furthermore, in .NET, modularity is achieved through libraries and packages. These built-
in features allow the developers to break their code into small modules, which can be
easily shared with other applications.
Encapsulation
In C++, encapsulation is used to bundle data. By doing this, it allows better control over
the access to data and behaviour.
In JavaScript, encapsulation is used to restrict certain properties and methods. This helps
data keep safe and secure.
In .NET, is used involving properties and provide controlled access to it. By doing this,
and defining properties, the programmer can enforce constraints on data.
Inheritance
In C++, inheritance is used by defining classes. In addition, depending on the level of
access, the access specifier can either be public, private or protected.
In JavaScript, encapsulation is achieved through the use of objects and properties. This
helps reduce dependency and protects the internal state of objects.
In .NET, encapsulation is achieved through the use of access modifiers such as public,
private, protected, and internal. This helps maintain the integrity of the program,
preventing unathorised access.
Testing & Debugging
In C++, testing and debugging is done through a combination of tools and techniques.
For instance, debugging tools, which involve the testing of individual units.
Similarly, in JavaScript, testing and debugging is done through the use of tools and
techniques. For example, console.log() is a built-in feature that allows developers to print
out the code they want, making sure that it’s working correctly.
Also, in .NET, testing and debugging is done through the use of tools. For example, the
debug tool allows the programmer to set a break where they want the program to stop
working. By doing this, they can go through each line of code.
Comparing & Contrasting Programming Languages

Loops
Loops is a sequence of instructions set by the programmer that is continually iterated
(repeated) until a specific condition is achieved. The purpose of loops is that allows to
the programmer to repeat a process several times without having to write the same
commands (code) again to perform a task. Commonly there are 3 types of Loops that are
used in the code, next loops, do loops (some languages use a different name for this
type of loop), and while loops. The advantages of loops is that reduces the chance of
bugs in code as there is less code written and makes the code more readable, another
benefit if loops is that the code is reusable, therefore the programmer does not need to
write the same code over again saving time. However, a drawback of loops is that it is
common to write a loop that never ends so this infinite loop will present the same
outcome multiple times, additionally another limitation is that it takes more time to the
compiler to translate the code. Loops are extremely important in software development
because it allows to shorten a long code into a smaller fragment of code, for example to
store data in a system of workers, the system can be written in hundred lines of code
doing the same thing, however a loop can shorten the code saving a lot of time and a lot
of storage.
 Next loops: execute a set of statements if the values of a variable are successive
until a limit of a value is reached.
 Do Loops: Executes a block of code once and then the block will be executed if a
Boolean condition is met at the end of the block.
 While Loops: To repeat/iterate a certain block of code until a specific condition is
achieved
This example shows how Loops are written in 2 different programming languages ().
VB.NET C#
Pre-test Loops: Pre-test Loops:
While c < 10 Do Until c = 10 // no "until" keyword
while (c < 10)
 c += 1 c += 1 c++;
End While Loop

For c = for (c = 2; c <= 10; c += 2)

Do While c < 10
2 To 10 Step 2 Console.WriteLine(c);
c += 1
Console.WriteLine(c)
Loop
Next
Post-test Loop:
Post-test Loops:
do
Do Do c++;
c += 1 c += 1 while (c < 10);
Loop While c < 10 Loop Until c = 10

' Array or collection looping // Array or collection looping

Dim names As String() = {"Fred", "Sue", string[] names = {"Fred", "Sue", "Barney"};
"Barney"} foreach (string s in names)
For Each s As String In names Console.WriteLine(s);
Console.WriteLine(s)
Next
// Breaking out of loops
' Breaking out of loops int i = 0;
while (true) {
Dim i As Integer = 0
if (i == 5)
While (True)
break;
If (i = 5) Then Exit While i++;
i += 1 }
End While
// Continue to next iteration
for (i = 0; i <= 4; i++) {
' Continue to next iteration if (i < 4)
For i = 0 To 4 continue;
If i < 4 Then Continue For Console.WriteLine(i); // Only prints 4
Console.WriteLine(i) ' Only prints 4 }
Next

As shown in this example, in VB.NET the meaning of the code is that while c is less than
10 add a value +1 to C this loop will do so until it reaches 10. On the other hand, in C#
there is the same loop going on but in a different method, as shown in the table in C#
there is C++ that means the same as .NET it simply adds one to the value of C while C is
less than 10. Secondly, there is an array collection looping. In VB.NET the code shows
that for each S in string names the string must be collected, therefore in that case it will
only appear one name but in C# this is written differently, in this case some of the code
is written inside brackets and foreach is written joined which is how the program detects
the command. The next section is about breaking Loops, as shown in the example if I is
equal to 5 the loop will be broken, there is a little difference between the languages in
VB.NET the command to break the loop is to write Exit While, but in C# the command
to break the loop is simply break;. Finally, there is a section which shows how to
continue a loop, firstly it is stated that for i the values are 0 to 4 and there is an IF
statement which shows that if the value i Is less than 4 the loop will iterate otherwise it
will be stopped. The same applies for C# however it Is written in a more complex way
and it is written in 3 lines which can be a little bit confusing.
Functions
A function is a fragment of code carrying out a specific task that can be reused multiple
times in the program rather than writing the code over again. Benefits of functions is
that allows to programmers to decompose a problem and assign each function a
particular task, another benefit is that the block of code can be used as much as the
programmer wants once the code is defined and functions make programs more
manageable and easier to understand, also it will take less time to code so that means
that the cost of the project will be less. However, a drawback is that in functions
variables are used and when more functions are added, more variables are added as
well leading to more memory usage and less overall performance. This has a great
impact in software development because the problem can be broken down in different
parts and so these parts can be delivered to different developers in order to code better
therefore the outcome will be positive. There are 4 types of functions which are,
 Functions with arguments and return values
 Functions with arguments and without return values
 Functions without arguments and return values
 Function without arguments and without return values
The table shows an example of how functions are written in 2 different programming
languages.
VB.NET C#
' Pass by value (in, default), reference // Pass by value (in, default), reference
(in/out), and reference (out) (in/out), and reference (out)
Sub TestFunc(ByVal x As Integer, ByRef y void TestFunc(int x, ref int y, out int z) {
As Integer, ByRef z As Integer) x++;
x += 1 y++;
y += 1 z = 5;
z=5
}
End Sub

int a = 1, b = 1, c; // c doesn't need

Dim a = 1, b = 1, c As Integer ' c set to
zero by default initializing
TestFunc(a, b, c) TestFunc(a, ref b, out c);
Console.WriteLine("{0} {1} {2}", a, b, c) ' Console.WriteLine("{0} {1} {2}", a, b,
1 25 c); // 1 2 5

' Accept variable number of arguments // Accept variable number of arguments

Function Sum(ByVal ParamArray nums As int Sum(params int[] nums) {
Integer()) As Integer int sum = 0;
Sum = 0 foreach (int i in nums)
For Each i As Integer In nums sum += i;
Sum += i return sum;
Next }
End Function ' Or use Return statement
like C#
int total = Sum(4, 3, 2, 1); // returns 10
Dim total As Integer = Sum(4, 3, 2, 1) '
returns 10 /* C# 4.0 supports optional parameters.
Previous versions required function
' Optional parameters must be listed overloading. */
last and must have a default value void SayHello(string name, string prefix =
Sub SayHello(ByVal name As "") {
String, Optional ByVal prefix As String = "") Console.WriteLine("Greetings, " + prefix +
 Console.WriteLine("Greetings, " & prefix & " " + name);
" " & name) }
End Sub
SayHello("Strangelove", "Dr.");
SayHello("Strangelove", "Dr.")
SayHello("Mom");
SayHello("Mom")

As shown in this example, in VB.NET 1 will add into the value of x and y and z is equal to
5, in C# is written in a different method such as x++, the symbols ++ have the same
meaning as the VB.NET code it shows that 1 must add into the value x or y. There are
variables set before starting with the function which are a and b as a Integer, there is a
little difference between the 2 languages of how to set up the variables, in .NET the
programmer must start with DIM as it is the command that the program recognizes as a
data type and after inputting the values the code must be closed stating what that data
type must be, in this case the variables are set as an Integer, but in C# it is written in a
simpler way, “int” means integer and after int the programmer only needs to write the
variables for each value. The function is simply saying that add the numbers as an
Integers and for each Integer in the value of i add 1, in both languages there is a
difference in how the function ends. In VB.NET to end the functions the programmer can
simply write “End Function” however in C# is a bit different as to end the function it
needs to be written “return sum”

Declaring Variables – Data Types

A variable is a value that can change depending on the conditions or on the information
set in the program, it helps to the programmer to understand better, remember and use
the information in the program. Benefits of data types are that store specific data
avoiding any errors in the program, another benefit is that they define the size of the
variable so there will be no wasted memory, but a disadvantage is that the variable
takes storage as it needs a space to be stored in the memory. This is really important in
software programming as they are used to store information and extract whenever is
needed. There are main variables used by programming languages which are:
 Int: To store integer values
 Double/Single: Store decimal numbers
 Char: Stores single characters
 String: Stores text
 Boolean: Stores values with 2 states such as true and false
The table shows how variables are declared in the program
VB.NET C#
Value Types Value Types
Boolean bool
Byte, SByte byte, sbyte
Char char
Short, UShort, Integer, UInteger, Long, short, ushort, int, uint, long, ulong
ULong float, double
Single, Double decimal
Decimal DateTime (not a built-in C# type)
Date (alias of System.DateTime) structs
structures enumerations
enumerations
Reference Types
Reference Types
objects
objects
string
String
arrays arrays
delegates delegates

Initializing Initializing
Dim correct As Boolean = True bool correct = true;
Dim b As Byte = &H2A 'hex or &O52 for byte b = 0x2A; // hex
octal object person = null;
Dim person As Object = Nothing string name = "Dwight";
Dim name As String = "Dwight" char grade = 'B';
Dim grade As Char = "B"c DateTime today =
Dim today As Date = #12/31/2010 12:15:00 DateTime.Parse("12/31/2010 12:15:00
PM# PM");
Dim amount As Decimal = 35.99@
decimal amount = 35.99m;
Dim gpa As Single = 2.9!
float gpa = 2.9f;
Dim pi As Double = 3.14159265
Dim lTotal As Long = 123456L double pi = 3.14159265; // or
Dim sTotal As Short = 123S 3.14159265D
Dim usTotal As UShort = 123US long lTotal = 123456L;
Dim uiTotal As UInteger = 123UI short sTotal = 123;
Dim ulTotal As ULong = 123UL ushort usTotal = 123;
uint uiTotal = 123; // or 123U
Nullable Types ulong ulTotal = 123; // or 123UL
Dim x? As Integer = Nothing
Nullable Types
Anonymous Types int? x = null;
Dim stu = New With {.Name = "Sue", .Gpa
= 3.4} Anonymous Types
Dim stu2 = New With {Key .Name = "Bob", var stu = new {Name = "Sue", Gpa = 3.5};
.Gpa = 2.9}
var stu2 = new {Name = "Bob", Gpa =
2.9}; // no Key equivalent
Implicitly Typed Local Variables
Dim s = "Hello!"
Dim nums = New Integer() {1, 2, 3} Implicitly Typed Local Variables
Dim hero = New SuperHero With {.Name = var s = "Hello!";
"Batman"} var nums = new int[] { 1, 2, 3 };
var hero = new SuperHero() { Name =
Type Information "Batman" };
Dim x As Integer
Console.WriteLine(x.GetType()) ' Type Information
System.Int32 int x;
Console.WriteLine(GetType(Integer)) ' Console.WriteLine(x.GetType()); //
System.Int32 System.Int32
Console.WriteLine(TypeName(x)) ' Console.WriteLine(typeof(int)); //
Integer System.Int32
Console.WriteLine(x.GetType().Name); //
Dim c as New Circle
Int32
isShape = TypeOf c Is Shape ' True if c is
a Shape
Circle c = new Circle();
isSame = o1 Is o2 // True if o1 and o2 isShape = c is Shape; // true if c is a
reference same object Shape

Type Conversion / Casting isSame = Object.ReferenceEquals(o1, o2)

Dim d As Single = 3.5 // true if o1 and o2 reference same object
Dim i As Integer = CType(d, Integer) ' set
to 4 (Banker's rounding) Type Conversion / Casting
i = CInt(d) ' same result as CType float d = 3.5f;
i = Int(d) ' set to 3 (Int function truncates
i = Convert.ToInt32(d); // Set to 4
the decimal)
(rounds)
Dim s As New Shape int i = (int)d; // set to 3 (truncates
Dim c As Circle = TryCast(s, Circle) ' decimal)
Returns Nothing if type cast fails
c = DirectCast(s, Circle) ' Throws
InvalidCastException if type cast fails Shape s = new Shape();
Circle c = s as Circle; // Returns null if
type cast fails
c = (Circle)s; // Throws
InvalidCastException if type cast fails

As shown in this example, in VB.NET there are several data types and all of them start in
a code line with DIM command, DIM is used to declare a data type for variables. To store
a Boolean data type in VB, the code needs to start with Dim so that the code/variable is
stored as a data type and then depending on the condition the programmer must set the
Boolean as a true o false condition, in this case the Boolean is written as a true condition
when something is correct otherwise it will be false, on the other hand in C# the method
of how to set a data type is simpler, for Boolean data type the programmer needs to
write bool and the program will detect it as a data type, afterwards the programmer
needs to set the Boolean if correct o false and the condition, in this case if the bool is
correct then the result will be correct. Generally Boolean is used when there is an
options of T/F or gender M/F.
To store a string in C# the programmer only needs to assign the name of the string as
shown, string name= “something”; , the code is really simple as the name can be set
straight forward inside quotes but in VB.NET is a little bit different, as mentioned before
in .NET all data types codes must start with DIM and another really important thing is
that all data types must be written outside the sub events so that the programmer can
use them in any part of the code. In VB.NET the programmer must write the name of the
object after DIM and write that the object must be stored as a string, then the
programmer needs to press equals and he needs to assign a name for that specific
string.
Another example of data type is to store certain type of information as a lower case or
upper case. In VB.NET to store data as a lower case the code needs an object name as a
Ushort and then the value, Ushort is the specific part that makes the characters into
lowercase, on the same language to make the characters in uppercase the structure is
the same however what changes now is instead of writing Ushort now is ULong, that will
make all the character into uppercase. On the other hand, in C# to write in lowercase
firstly the programmer needs to state if it is short or long, in this case firstly he needs to
write short, the object and finally the value. For uppercase the same applies however but
instead of short the code must be written with long.
Overall, the main difference is simply that in VB.NET to state data type it is must to start
with DIM while in C# it is easier to write the code and understand it.

Choices – If Statements
If statement is a code that carries out a task depending on which criteria the condition
met, normally there are 2 outcomes in IF statements, one outcome is executed if the
statement is true and the second one is executed if the statement is false. An advantage
of choices is that the programmer saves some lines of code as there are other ways to
present the outputs however choices make it simpler so it will save some space in the
storage, another benefit is that it gives to the user 2 choices so the program won´t do
always the same, for example in a game there may be a level where the user needs to
choose between 2 choices, depending on the choice he selects a specific thing will
happen. But a drawback of choices is that when more If statements of Nested If
statements are added, the code gets more complex so if a bug is made it will be harder
to debug and it will take time. However, choices are effective in software development
because it will let the user/programmer know whether the program will execute that line
of code or not, saving a lot of storage compared to other methods, also it will allow to
the user to select from multiple outputs which is better for him, otherwise for the user
the software would be boring. There 4 conditional statements for IF statement.
 If: specify which code to be executed if the condition met is true
 Else: specify which code to be executed if the condition met is false
 Else if: specify a new condition to test if the first one result to be false
 Switch: to specify multiple blocks of code to be executed
VB.NET C#
' Null-coalescing operator if called with 2 // Null-coalescing operator
arguments x = y ?? 5; // if y != null then x = y, else x
x = If(y, 5) ' if y is not Nothing then x = y, =5
else x = 5
// Ternary/Conditional operator
' Ternary/Conditional operator (IIf evaluates greeting = age < 20 ? "What's
2nd and 3rd expressions) up?" : "Hello";
greeting = If(age < 20, "What's up?",
"Hello")
if (age < 20)
greeting = "What's up?";
' One line doesn't require "End If"
If age < 20 Then greeting = "What's up?" else
If age < 20 Then greeting = "What's greeting = "Hello";
up?" Else greeting = "Hello"
// Multiple statements must be enclosed in
' Use : to put two commands on same line {}
If x <> 100 AndAlso y < 5 Then x *= 5 : y if (x != 100 && y < 5) {
*= 2 x *= 5;
y *= 2;
' Preferred }
If x <> 100 AndAlso y < 5 Then
x *= 5
y *= 2
End If
' Use _ to break up long single line or use No need for _ or : since ; is used to
implicit line break terminate each statement.
If whenYouHaveAReally < longLine And
itNeedsToBeBrokenInto2 > Lines Then _
UseTheUnderscore(charToBreakItUp)
if (x > 5)
'If x > 5 Then x *= y;
x *= y
else if (x == 5 || y % 2 == 0)
ElseIf x = 5 OrElse y Mod 2 = 0 Then
x += y;
x += y
ElseIf x < 10 Then else if (x < 10)
x -= y x -= y;
Else else
x /= y x /= y;
End If

Select Case color ' Must be a primitive

data type // Every case must end with break or goto
Case "pink", "red" case
r += 1 switch (color) { // Must be
Case "blue" integer or string
b += 1 case "pink":
Case "green"
case "red": r++; break;
g += 1
case "blue": b++; break;
Case Else
other += 1 case "green": g++; break;
End Select default: other++; break; // break
necessary on default
}

As shown in this example, in VB.NET the IF statement shows if the age is below 20 then
the program needs to show What´s up, otherwise it will show hello by, otherwise it
means bigger than 20. To write the code VB.NET needs of the words “Then greeting” and
“Else greeting” to write what the programmer wants to show after input, however in C#
is simpler to write because the programmer only needs to write Greeting and what he
wants to show. On the other hand, in C# to write multiple statements the programmer
needs to write the statements inside square brackets whereas in VB.NET the 2
commands can be written on the same line. Also, as VB.NET can have a long line
because the commands can be written in the same line, the programmer sets a
statement which separates a line into 2, as shown in the example to execute that the
programmer should use underscore whenever he wants his line to be separated but in
C# this is not shown because the statements were written on different lines this is
advantageous as it will consume less memory. Finally, in VB.NET to show a colour of an
axis or to modify any part of the program, the code is written like x (any colour) +=1,
the first character will select the colour and +=1 means that the specific colour selected
will be placed once so it depends on the programmer how many numbers of time, he
wants to show the colour. But on C#, all the code is written on a single line, r++ means
that it increases the value of the variable by 1 is the same as VB.NET but written in a
different style, finally break means that it is the end of the loop so the colour will stop on
that point
Comments
Comments are explanations written near the source code of the program to understand
what the code is doing, this is extremely important and beneficial when other
programmers are looking at your program, if there are annotations then it will be easy to
understand what the code is doing and easy to sport any bug. There are 2 types of
comments which are shown in the table below. The main benefit of comments is that
allows to other programmers to understand what is the code doing, this is beneficial
when a team is working on a project as the program needs to be understood by
everyone in order to offer the best code possible and to spot any bug, another
advantage is that for the final program the comments don´t take any of the storage
leaving to programmers to write as much comments as they need. However, a drawback
of comments is that they need to be updated as stated before, If the code is manipulated
but not the comment that will create confusion, additionally depending on the program
comments can only be written in single line such as VB.NET. Overall, comments are
necessary in software development as it gives the accurate information to developers of
what is the code doing, so if a programmer leaves the industry or project, others
developers will know what they´re doing and that also will help to sport bugs quicker.
VB.NET C#
' Single line only // Single line
REM Single line only /* Multiple line */
''' <summary>XML comments</summary> /// <summary>XML comments on single
line</summary>
/** <summary>XML comments on multiple
lines</summary> */

As shown in this example, in VB.NET there is only 1 type of comment which is the single
line comment, to start to write a comment the programmer needs to start with the
apostrophe and then he can start writing the comment, by the, also the compiler won´t
take any notice about the comments because of the apostrophe/REM. Comments are
effective however in this programming language the disadvantage is that the
programmer can only write a single line comment which limits his capacity to write the
code detail and therefore the programmer won´t be able to comment on complex code
as there is no space, an alternative to that can be to make a lot of single line comments
which is not productive and takes memory, therefore this programming language is not
the optimum one to make comments. On the other hand, in C# there are both
comments available however it is a different method to write it, the programmer in C#
needs to start with // for single comments and with /* for a large comment, the
advantage is that the programmer can document his code in multiple lines letting him
comment the complex codes as well, one of the disadvantages is that it may take
memory. Finally, to write a summary of the comment, in VB.NET the programmer should
start with triple apostrophe and write the summary inside chevron however in C# the
programmer needs to start with slash and chevron for single lines but there is another
code for multi lines which is by a slash and 2 stars.
Subroutines – Functions/Procedures
Subroutine is a small chunk of code that performs a specific task, subroutines make the
code easier to read and reusable. Also, the programmer can test the subroutines
separately instead than running the whole program which makes subroutines easier to
debug. An Advantage of subroutines is that the code is easier to understand and read,
this is because the program breaks the code into smaller fragments, another benefit is
that subroutines can be added into the library to use it in another program and also a
programmer can extract a subroutine from a library to use it, additionally if there is a
large program, different programmers can work on different subroutines for the same
program as that will improve the speed, productivity and there will be a better outcome
if programmers join the subroutines together. However, a drawback is that subroutines
can only be used in functions and procedures.
VB.NET C#
' Pass by value (in, default), reference // Pass by value (in, default), reference
(in/out), and reference (out) (in/out), and reference (out)
Sub TestFunc(ByVal x As Integer, ByRef y void TestFunc(int x, ref int y, out int z) {
As Integer, ByRef z As Integer) x++;
x += 1 y++;
y += 1 z = 5;
z=5
}
End Sub

int a = 1, b = 1, c; // c doesn't need

Dim a = 1, b = 1, c As Integer ' c set to
zero by default initializing
TestFunc(a, b, c) TestFunc(a, ref b, out c);
Console.WriteLine("{0} {1} {2}", a, b, c) ' Console.WriteLine("{0} {1} {2}", a, b,
1 25 c); // 1 2 5

' Accept variable number of arguments // Accept variable number of arguments

Function Sum(ByVal ParamArray nums As int Sum(params int[] nums) {
Integer()) As Integer int sum = 0;
Sum = 0 foreach (int i in nums)
For Each i As Integer In nums sum += i;
Sum += i return sum;
Next }
End Function ' Or use Return statement
like C#
int total = Sum(4, 3, 2, 1); // returns 10
Dim total As Integer = Sum(4, 3, 2, 1) '
returns 10 /* C# 4.0 supports optional parameters.
Previous versions required function
' Optional parameters must be listed overloading. */
last and must have a default value void SayHello(string name, string prefix =
Sub SayHello(ByVal name As "") {
String, Optional ByVal prefix As String = "") Console.WriteLine("Greetings, " + prefix +
Console.WriteLine("Greetings, " & prefix & " " + name);
" " & name) }
End Sub
SayHello("Strangelove", "Dr.");
SayHello("Strangelove", "Dr.")
SayHello("Mom") SayHello("Mom");
As shown in this example, in VB.NET a function is going on to sum values that meet a
criteria, it is shown in the example that it is a small task, the function is summing all the
integer numbers and for each integer in the value of i a 1 must be added in on i and so
finally a data type is used to acquire an answer for the sum that in this case in 10, in C#
the same task is being executed however the coding is a little bit different instead of end
statement in this case to break the function the programmer must write return sum as
the program will detect that as a final answer and stop the process. In this case VB.NET
is easier to understand because it shows clearer what each command is and what is the
code doing.

When it comes to comparing & contrasting programming languages, there are other many factors to look out
for, such as the requirements (e.g., hardware, software and special devices), performance and ease of
development. Furthermore, some programming languages require specific hardware (e.g., CPU) and software
(e.g., Python) for running and developing a program. Below is a picture showing the different domains
produced through programming languages

Hardware/Software needed for running/developing a program

Some programming languages such as Python, are considered as cross-platform, which enables developers to
develop apps for various platforms using a single codebase, meaning it will allow you to use it on any platform,
like Windows, Linux, Mac, etc... The advantages of having a good software/hardware needed for a program, is
that it increases work efficiency, easy to use, increases productivity, well-designed software increases
reusability and to perform specific tasks quickly and efficiently, and can often do so at a faster speed than
software alone. The disadvantages are the cost, limited lifespan, which may become outdated quickly, support
and documentation and the need for additional technical proficiency.
Special devices required
When designing a software or making a hardware, the specialist may have a need of using special devices that
would enhance the performance. For example, graphics card is an example of special devices that are required
to run high graphics applications. This can include things such as high-graphics games. Another example is
external storage devices, such as an SSD card, which are inserted into the computer to give more storage.
Another example is Virtual Reality (VR), which are specialised devices
Performance
Programming languages can perform more or less efficiently depending on the language ability to execute.
This includes specific restrictions such as speed, responsiveness, throughput (how many requests your
software can take on per second, minute, or even hour) and scalability. Some programming languages
generate better optimised machine code by having more efficient translators, such as CPUs. In addition, some
programming languages, manage RAM more efficiently by having aggressive garbage collection, which is
automated process which attempts to reclaim RAM taken by a program to store data. For example, an
identifier which is no longer needed. The advantage is that it helps to identify how well an application can
handle a growing number of users, transactions, and data volumes. Whereas on the other hand, the
disadvantage is the resource-intensive, as performance testing can require significant hardware and software
resources, making it expensive and time consuming.
Preferred applications areas
Some programming languages are better suited for some areas of application. For example:
PHP is used to create server-side applications, which is a type of development that involves programs that run
on a server.
C is a general language, but it is particularly effective for controlling the external. For example, this language,
has found lasting use in operating systems, device drivers, and protocol stacks, but its use in application
software has been decreasing.
Java is used to code web applications, and it has been a popular choice among developers for over two
decades, with millions of Java applications in use today.
C# can be used to create several different programs and applications, such as mobile apps, desktop apps,
cloud-based services, websites, enterprise software and games. Lots and lots of games.
Object-C is used to create mobile apps for Apple’s IOS devices, for example, iPads, iPhones, etc...
Development Time
Development time is the number of hours put into creating software based on specific requirements provided
by the client. Therefore, it’s as important consideration when choosing a programming paradigm. For
example, we have seen that the programs written using machined code, are executed very quickly, however,
when using high level language, it takes much longer for the CPU to compile it. In programming businesses,
time is equal to money, so languages supported by feature tools which claim to reduce development time are
much preferred. However, it can also be difficult to measure time as acceptable Metrics (measures of
quantitative assessment commonly used for comparing, and tracking performance or production), are hard to
determine and agree upon. For example, you can consider the number of lines of code written per hour, but
this may not be acceptable considered to the bugs related.
Ease of Development
Ease of development relates to the programming languages which are easy to use. This is because some
programming languages present the software user with advanced tools, such as predicted or autogenerated
text of codes, such as VB.NET. The quality of other tools available within the programming language, can also
have impact on the ease of development. For example, we can look at help systems, such as syntax
highlighting and debugging tools.
Development Tools:
Syntax highlighting is a feature in many languages in which editors display different programming constructs
in specific colours. For example, a comment may appear in green, a string text may appear in red. The benefit
of this is that it results the code easier to read, understand and debug.
Debugging tools offer programmers a range of features that help them identify bugs in their code and remove
them. This helps them reduce errors in the program using debugging tools that include traces, watches and
breakpoints.
Problem Definition Statement
Algorithm:
An algorithm is like a recipe for solving a problem. It's a set of instructions that tells a computer how to
perform a task step by step.
Pseudocode:
Pseudocode is a method for mapping out a resolution to an issue using clear, understandable language. It
involves documenting the instructions of an algorithm in a relaxed and easier-to-understand manner, without
being concerned about the exact coding language syntax. It assists developers in strategizing and sharing their
concepts prior to beginning the coding process.
Flowchart:
A diagram visually represents a sequence of steps or commands in a process or algorithm. It utilizes different
shapes and arrows to demonstrate the advancement of actions and decisions in a clear and organized way. It
resembles a visual depiction that helps understand the internal mechanisms of a program or system, making it
easier to monitor and analyse.
Principles of logic applied to program design
Mathematical logic
Mathematical logic plays a vital role in program design by guaranteeing correct behaviour and desired
outcomes of the program. Programmers can enhance their ability to create algorithms, make decisions, and
handle complex computations more efficiently through the use of logical reasoning and mathematical
principles. Mathematical logic enables accurate and rigorous thought, essential for creating sturdy and
dependable software. Assisting programmers in pinpointing and steering clear of logical errors is crucial for
ensuring the smooth operation of the program.
Completeness
Completeness plays a crucial role in program design by ensuring that all potential cases and scenarios are
taken into account and properly addressed. Once a program reaches completion, it signifies that it is capable
of managing all anticipated inputs and generating the intended outputs under any possible circumstance. This
aids in avoiding mistakes, unforeseen actions, and possible failures. By creating a comprehensive program,
developers can guarantee its strength, dependability, and ability to meet user expectations.
Truth Tables
Truth tables play a crucial role in program development by aiding in comprehension and assessment of logical
expressions and conditions. They offer a structured method for evaluating the truthfulness of various input
combinations and calculating the ultimate truth value of a compound statement. Through the use of truth
tables, programmers can verify the accuracy of their program's logic and conditions, resulting in the intended
outcomes.
Propositional Logic
Propositional logic, also referred to as Boolean logic, plays a crucial role in program design by offering a basis
for articulating and assessing logical statements and conditions in a precise and organized manner. It enables
programmers to think about whether propositions are true or false and decide on actions accordingly.
Through the utilization of propositional logic, developers have the ability to generate logical expressions,
conditionals, and loops that govern the progression of their program. It assists in guaranteeing that the
software functions properly and generates the expected outcomes according to the specified circumstances.
Use of Sets
Sets are essential in program design as they offer a strong method for arranging and handling groups of
distinct elements. Sets enable developers to efficiently manage collections of data by facilitating storage,
retrieval, and manipulation operations while handling duplicate entries. This is especially handy for tasks like
removing duplicate values, verifying membership, or executing set operations such as union, intersection, and
difference. Through the utilization of sets, developers are able to streamline their code, enhance efficiency,
and maintain the integrity of data.
Quality of Software Applications
Efficiency
The quality of software applications is significantly affected by efficiency, as it has a direct effect on user
experience. An efficient software application completes tasks rapidly and seamlessly, reducing delays and
frustrations experienced by users. Effective software efficiently utilizes system resources like memory and
processing power, resulting in improved performance and responsiveness. It also aids in preserving energy
and cutting expenses, particularly in environments with limited resources. For example, if you are making a
high-performance survival game with stunning graphics on unreal engine 5 with the most realistic software
you need to make sure an average CPU can handle that put also can handle the actual survival part of the
game. This is because if your game only looks good form the outside but needs a £10,000 pc to run properly
then you need to fix that as not a lot of people have that. So, you must dial back on the graphics and make it
so people can play the game without lag or low fps. This also falls into making your software application
robust. You need to test your application under a lot of strain by processing large amounts of data through it
and seeing if it crashes if it does you got work to do if not you did good. In general, a well-functioning software
program improves efficiency, user happiness, and the overall effectiveness of the system.
Maintainability
Maintainability plays a crucial role in the quality of software applications as it impacts the software's
manageability and upgradability throughout its lifetime. If a software application is maintainable, developers
find it simpler to comprehend, edit, and improve the codebase. This makes fixing bugs, adding new features,
and adjusting to changing requirements easier. Sustainable software adheres to recommended practices, like
modular design, thorough documentation, and uniform coding standards, to promote teamwork among
developers and minimize the chance of mistakes. If a programmer writes a code in an easier way
(maintainable way) it will be easier to manipulate by any programmer, therefore that will
save time, energy, and money. Additionally, before the programmer starts to create the
program, between the client and the programmer there is always a trade-off to make the
code efficient and easy so that it takes less time and money, ensuring that the code can
be manipulated in the future. An advantage of maintainability is that the program can be
changed by multiple programmers and it can be changed on different environments,
another advantage is that the software will always meet with the user needs so the
program will remain successful, also a method to improve maintainability is to comment
the code written by the programmer, therefore if any other programmer needs to
manipulate the code, he will know what is going on by the comments helping with
understanding and making the work easier however a drawback is that maintainability
can be hard to carry if complex code has not annotation, that will slow down the process
of maintainability because the programmers first must identify the errors within the
code. In the end, the software's ability to be easily changed, expanded, and supported over time is what
maintainability guarantees.
Portability
The ease of transferring and running software on various platforms and environments is crucial for software
applications' quality due to portability. When a software application is considered portable, it can be installed
on different operating systems, hardware setups, and devices without needing major changes. This expands
the software's coverage and availability, making it able to serve a broader range of users. Portability also
makes it easier to transfer the software to different systems or enhance the ones already in place. It cuts down
on development time and expenses by removing the necessity to modify or adjust the codebase for every
target platform. So, a PlayStation player can play with a pc player. This gives the company a wide range of
customers on different platforms. For example, Sony (PlayStation) have exclusive games like spider-man this
means that their software is not portable on the other hand epic games Fortnite is portable as you can play it
on all platforms. Another example is C++, it is the most used language in programming, this language is very
portable. This is because it provides with a wide range of compilers which translate the code to the required
CPU on many different platforms. On the other hand, a program that is written in machine code cannot be
portable as it limits its access and execution to the computer systems, while portable high-level languages
such as C++ or Python, provide their source code to other platforms/operating systems and the code will only
have slightly changes.

Reliability
Reliability is crucial in software application quality as it guarantees consistent and accurate performance in
different situations. If a software application is dependable, it operates as planned without any unforeseen
crashes, errors, or data loss. This builds trust among users, as they can depend on the software to always
produce the desired outcomes. Dependable software reduces downtime, avoids data loss, and upholds system
integrity. It also aids in establishing a favourable image for the software and the individuals who created it.
Usability
Ensuring a positive user experience and satisfaction levels depends on the functionality of software
applications. When a software program is intuitive and easy to navigate, minimal effort is required to learn
and operate it, making it user-friendly. Functional software that is effective offers clear guidance, easy-to-use
interfaces, and smooth operations to help users complete tasks efficiently. It accelerates learning, reduces
mistakes, and boosts efficiency. Factors such as accessibility, responsiveness, and customization are
considered in usability to ensure the software meets the needs of various users. A popular technique to get
some feedback is by rapid application development where the programmer rapidly alters the layout, schemes,
and other elements of the application to receive quick feedback from the user and fix or improve the errors.
For example, social media websites like Instagram, snapchat, Facebook, WhatsApp etc. All need to make sure
their apps and websites are usable. They do this by having instant messaging and by using different software
that make their apps and websites run better. They also make it, so their apps and website run on all devices
almost perfectly. This helps usability because it makes sure that no matter what device a user is using, they
can use that company’s apps or website no matter what. Also, the software should have a good user-interface
because that will affect how the user will use the application. Advantages of Usability is that the programmer
will meet the customer expectations by different methods such as a beta in a game, another advantage is that
it will allow to the user to have an easier navigation which means that the user is more likely to use that
software more.

Pattern Generalisation
Pattern abstraction is crucial in software application quality as it enables the development of code that is both
reusable and scalable. Software developers can transform identified patterns in their code into reusable
components or functions by abstracting and generalizing them. This decreases repetition in code, boosts
maintainability, and improves the overall efficiency of the software. Through the use of pattern generalization,
developers can quickly modify and expand their codebase, resulting in speedier development processes and
reduced mistakes.
Logical Operations
Logical operators a symbol or word used to connect two or more expressions. These include operations such
as And, Or, Not, etc... which operate on Boolean principles. Furthermore, they are used to combine conditions
in if statements and various loops. For example, in the picture below there is a list of logical operators used in
C++
NOTICE: be careful when using different languages. For example, in VB.NET, the symbol ‘=’ is used to test
equality. However, in other programs, such as Java, C, C++, C#, the ‘==’ is used instead.
Subroutines, Functions and Procedures
Subroutines, functions and procedures are terms used in procedural programming, where code is split into
different sections, and each section is called subroutines, functions and procedures depending on the
programming language used. Furthermore, each one is responsible for performing a single task, where the
coding script is anywhere between 5 to 50 lines. In addition, the use of these modules tends to be easier to
write, read and debug as code written in these ways can usually be reused. You can see this in the example
below

Library Functions
Library functions are functions stored in a special library file (nearly all programming
hold this function), however sometimes it depends on the programming language
chosen, for example in C language Library function are localised in the header files. This
function provides to the programmer solution to different complex problems. All of the
information that a programmer may looks in this function are stored in a common
location known as library. What offers to the programmer is common operations such as
formatting appearance, find the exact length of a string, calculations, etc… Additionally,
the programmer can install some functions from google which will amplify his library
function, Microsoft offers his library for the people to install functions. This is beneficial
as it saves a lot of work and time. The main advantage of Library function is that it
provides to the programmer with codes that work perfectly and can be used in the
program, therefore this will save a lot of time and the programmer will be able to tackle
a problem with a code that even he doesn´t fully understand, another benefit is makes a
high degree of code reusing as a lot of coding can be extracted from the library, also this
ensures accuracy of code and so the programmer doesn’t need to check If there is bugs
inside the code extracted from the library, additionally the code can be manipulated into
what the programmer wants if it´s necessary. However, a drawback of library functions is
that if the library code is updated then the programmer should recompile the whole
program again to apply the new one and that is time consuming. Overall, libraries are
essential in software development, it makes it easier for developers to tackle problems in
an efficient way by providing reusable chunks of code, this is also a time saving and
ensures the code free from bugs.
Data Structures
Data structure is a way of organising and collecting specific data in a formal structure.
This formal structure helps to the computer to keep the information organised and
processed so that the information can be retrieved rapidly and helps to the data to be
processed effectively. Data Structure is essential is the programmer wants to program
fluently and without problems, for example with the use of data types, the programmer
can decrease the chance of error making the program more effective, also developers
will learn more data types as they try more programming languages. Depending on the
programming language, some of the data structures can be restricted however all
programming language provides the main data structures which are; Arrays, Strings,
Stack, Queue, Record, Graphs, Linked Lists. Data structure is essential in software
development as it is necessary for executing efficient algorithms inside the program,
also if data structure has a good structure the programmer will be able to abstract some
data and save a good amount of time.
Data Structures
Data structure is a programming technique used to collect and organise data items. And sometimes, it is
possible to program more effectively through the selection of specific data structures. Therefore, this is why
software developers become familiar with different data structures as they learn about different programming
languages. In addition, there are many data structures, but here are the most common:
String (Or Text) - Used to store a collection of characters with one character requiring one byte of RAM. These
can also be fixed length, for example, only 10 characters. Some languages also use a one-dimensional
sequence of characters to simulate a string, rather than using specific string data type. Furthermore, string is
mainly used to store data entered by the user, such as username or password.
Here is an example demonstrated in VB.NET
Array (One-Dimensional) - An array can only store one type of data. Any type of data such as integers,
characters and Booleans are acceptable. For example, if we wanted to store the temperature of seven days,
we could create an array of seven decimal numbers. It is also possible to access individual elements in the
array using the required index. Normally as being a static data structure, the variable has a
fixed field size however some programming languages allow to manipulate the fixed size
as they are more flexibles. Additionally, with array the programmer can access to the
specific element he wants by applying the necessary/required index. The image below shows
the creation of this simple one-dimensional array in C

We also have array two-dimensional

This array is similar to one-dimensional array fulfilling the same purpose, however in this
dimension it can be visualised a table with rows and columns storing multiple
information. Also, similar to one-dimensional array in this array the programmer can
access in the individual elements of the array if the inputted index is the appropriate
one. For example, if a programmer needs to add information about the sales of a
business over 4 continuous weeks, he will use 2-dimensional array as it will store
information in rows for each week as shown below. An advantage of 2-Dimension Array
is that it can be used in any function and furthermore 2-dimension array can store an
enormous amount of data at one time, this is commonly used in game development.
Also, it can represent multiple types of data by using a single name. However, the
drawback is that the programmer must know from before which elements to add in. 2
dimensional array have a great impact on software development as the programmer can
store a great amount of data in a single name, that will help him to be organised,
however in game development is where 2 dimensional arrays are mostly used, for
example this type of array can be used In games to specify the character location.
 0 1 2 3 4 5 6
1 $765 $888 $583 $799 $1012 $1300 $1001
2 $777 $712 $400 $612 $834 $1027 $996
3 $657 $700 $412 $800 $998 $2000 $900
4 $700 $898 $567 $599 $799 $1130 $1002

Stack (LIFO)
Stack is a data type with the purpose of collecting elements that are coming in. Stack
has 2 main operation which are described as push and pull (also known as push and
pop). Stack is an essential part of the program when some operation is taking place. If a
computer is processing something and some important factor comes inside the process
which has more importance, then the current process will be interrupted/stopped and
deal with the important part
As stated before, Stack can only be accessed in the way of last in first out (Unlikely an
array which the elemetns can be accesed in any order) . This is because stack required
of a data type and that data type will follow the process of last in first out. This is
advantegous for the programmers as it helps to reduce likely errors and to process
better the recursive alghorithms. Additionally, Stacks can be included in the library of
programming languages offering to the programmers different methods and coding to
tackle the problems. Also, stacks can contain different data types elements. However a
drawback of stack is that it offers a limited size so the programmer cannot excced to the
amount he wants, and so before creating the stack the total size must be defined
first.Despite the drawback stacks are really important in software development beacause
they can abstract a lot of information and stacks maintain an order of the elemetns that
need to be executed. Another example of stack in computing can be when a character in
a game collects a series of objects. The character is most likely to use the last object the
he collected (last object in, the first one to be out/used) however he will have on his
invenotory other more objects that he collected previously (that will make the pile)

LIFO stands for last in, first out, and it describes how data is treated in some data structures. This means that
the last item of data pushed on, is also the first item of data that may be pulled back off.

Queue (FIFO)
Unlike stack, queue is known as a FIFO data structure, and it considers two basic operations, add and remove,
and they are also viewed horizontally. Furthermore, only data at the head of the queue can be
accessed/removed, and they are also a vital part of any computer's operating system.Queues are essential for
every program, an example of it can be phone call system, as more people call a company more are added to
the queue and normally it follows the FIFO system, the first one that call is the first one that leaves. Also, there
are 4 types of queues which are Simple Queue, Circular Queue, Priority Queue, Double Ended Queue. And
there will be an example of how queues are viewed. A benefit of queue is that it uses a better way to store the
space, if there is space available the element will be added in and will be the first one to leave. Another
benefit is that operations such as insertion or deletion are easy to perform as they follow FIFO rule,
additionally queues are really useful when a service is being used by multiple customers. However, some
drawbacks is that it offer limited space so the programmer cannot work flexible and so the maximum size
must be defined from before, another drawback is that operation such as insertion or deletion are time
consuming. Overall queues are useful in software development as it gives a structured information of which
things to execute first, this structure makes it easier for the developer and provides advantages such as not
losing any storage which is beneficial for the program and its performance.

Record (Or Structure)

A record has similarities with an array, however record can store fields with several data
types in a structure to store information or any details, it groups together related
elements of a data. For example, in a game record can be used to show how much score
did the user get and how much damage he did, also it can be used to fill details as
shown below. A benefit of record is that multiples information with different data type
can be collected on the same field and there can be a great amount of records saved,
another advantage is that for 1 record multiple fields with different data types can be
saved. But a drawback is that each data field contains a limit size e.g. a string has a
maximum of 2048 bytes. However, records are necessary in software development as
they contain confidential information and records are the main source to extract these
types of information, for example a business has records of different employees personal
details and in order to contact them, these details are necessary and it will be extracted
from a record system.
String Handling
As stated in the report, string is a collection of characters and even if they’re a text, they
need to be processed. Therefore, there are techniques to check and manipulate the data
inside the string, this is what is known as String Handling. The common benefit of String
Handling is that the programmer can manipulate the data as he wants to extract the
information he desires. Another advantage of string handling is that the size of the
stored string can change allowing to the programmer to control the storage, also there is
a library for string handling which provides string objects that can be used in the
program. However, a drawback is that in some programs the library doesn´t apply. But
string handling is extremely important in software development, this is because
developer should be able to manipulate string data for important fields, for example
string rules can be applied when making a password so that it is secure, therefore this
has a great impact on users and the software itself. There are a lot of different types of
String Handlings however the most common ones are shown below.
Finding the length of a String: This is used to determine the maximum length
of a certain data, to apply this string handling the programmer must start with the
instruction LEN in pseudo-code because this tells the length to be an integer. For
example, a code such as LEN (password) will give an answer of 8 as there are 8
characters in the word “password” this is commonly used by the programmers as
it is useful for fields such as maximum lengths of password, or maximum
characters in a username inside a game.
Examining single characters: The purpose of this feature is to extract a single
character from a string, an example can be using the string “October”. One of the
codes to apply this feature is by typing October [2] the answer for this would be
the letter “t” as the number 2 is at the position of t. Additionally, the programmer
needs to remember that the computer starts to count from 0.
Finding The Length Of A String In Characters
In the example below, the length property of the ‘month’ string is used to access the string’s number of
characters.
Examining Single Characters
The output will be 'Character 3 of January is u’. This is because ‘u’ is the character in position 3.

Extracting A Substring
The output will be ‘Substring is ua’, because we start extracting at position 3, and we want to extract the nest
2 characters.

Concatenating Two Strings

Concatenating is the process of joining things together. In programming, it is used to describe the process of
joining shorter strings together to form longer strings. For example, ‘Hello’ and ‘World!’ to form ‘Hello
World!’.

Programming Languages & Implications

C++
Low-Level & High-Level programming language
It’s an extension of C programming language with added features such as classes,
templates and exceptions.
Why & where it’s used
C++ is used in developing browsers, operating systems, and applications, as well as in-
game programming, software engineering, data structures, etc... It’s also known for its
performance, meaning it runs faster in comparison to other programming languages,
flexibility, and wide range of applications. Furthermore, developers use this
programming language for a variety of reasons; this includes things such as;
High-performance: C++ is a compiled language, meaning it’s a programming language
that is converted into machine code so that the processor can execute it, and has a
reputation for being a fast and efficient programming language. It also allows developers
to directly interact with the hardware, giving a greater control over the system.
Flexibility: C++ is also a programming language that offers a wide range of features.
This is good for developers to write complicated and efficient code for many different
applications.
Portability: C++ can also be easily ported to different platforms and operating systems,
making it a much more popular choice for software development.
Advantages
High performance
Object-Oriented Programming, as C++ supports concepts like classes, inheritance, etc...
Portability
Flexibility
Standard Library, as C++ comes with a variety of features for various task
Disadvantage
Steep learning curve, as C++ can be very hard to learn and understand the concepts
that are within the language, especially for new learners.
Memory management, as C++ memory management can lead to memory leaks if not
handled properly.
Complexity, as C++ comes with a variety of features, which can be hard to learn and
maintain.
C#
C# can be considered a high-level programming language although it still being
considered a low-level language from organisation such as Unity, which has been using it
for years.
Why & where it’ used
C# is an object-oriented programming language, and it’s used for developing a variety of
software applications, such as mobile apps and desktop applications. In addition, there
are a variety of reasons why developers use this programming language; this includes
things such as:
Versatility: C# is a versatile language, meaning it’s able to do many different tasks, and
can be used for a wide range of applications, including things like web development,
mobile app development, desktop development and game development.
Familiarity; C# is also very liked by developers due to its familiarity with other similar
programming languages, such as C++ and Java. This makes it easier for developers to
learn and adapt to the programming language easily.
Security: C# also has a built-in security feature, such as type safety that helps prevent
common security vulnerabilities.
Advantages
Easy to learn, making it a good choice for beginners
Flexible programming language, meaning it can be used for a wide range of applications
Built-in library, meaning it provides a rich set of tools, as C# is part of the .NET
framework
Disadvantages
Can be slower in comparison to other programming languages such as C++ or Java
Not as popular as other programming languages such as Python, resulting in a less
active online community
Not as well suited for low-level programming
Java
Java is a high-level programming language that is used for developing desktop and
mobile applications. It’s mainly known for its “write once, run anywhere” mantra, which
means that the code can be executed on any platform, without the need of recompiling
it.
Why & where it’s used
Java is a multi-platform, object-oriented and network-centric programming language, and
it’s mainly used in the development of popular mobile applications, computer
applications and video games. Furthermore, developers also use Java for a variety of
reasons; this includes things such as:
Platform independence: Java is a platform-independent language, meaning that it can be
run on any platform without the need of recompiling it.
Object-Oriented programming: Java is an OOP language, which makes it easier for
programmers to organise and structure their code in a much easier way so that they can
reuse the code later.
Robust & Secure: Java has built-in security features which helps make the language
much robust and secure for developing applications. It also has an automatic memory
management feature which helps prevent memory leak.
Advantages
Platform independent, as Java code can be run on any platform once it’s been compiled,
making a much more flexible programming language.
Secure, as Java built-in features which help the programming language become more
secure and robust.
Simple, as Java has a vast ecosystem of libraries and frameworks which make
development much faster and efficient.
Disadvantages
Performance, as Java applications can be slower compared to similar languages like C or
C++
Memory consumption, as Java applications tend to consume more memory compared to
other languages
Verbosity, as Java code can be verbose, requiring more lines of code to achieve the same
functionality as other languages.
.NET
Programming language developed by Microsoft which is based on the Visual Basic
programming language. It’s also a popular choice for developers due to its syntax.
Why & where it’s used
.NET is a multi-paradigm, OOP language which is used to build desktop, web and mobile
applications that can run natively on any operating system. In addition, developers
prefer this programming language for many reasons; some of the reasons are;
The ease of use: .NET is very easy to use due to its syntax and familiarity, which makes it
a popular choice for new developers
OOP: Makes it easier to create and manage complex applications
Built-in Library: .NET has a large built-in library which can save developers a lot of time
when building applications
Compatibility with other Microsoft technologies
Advantages
Easy to learn, AS vb.net is designed to be easy to learn and use
IDE, as Visual Studio provides a very powerful and easy to use IDE for developing
applications
OOP, as it makes it easier to manage code
Disadvantages
Performance, as compared to lower-level languages like C++, VB.NET may have slower
performance
Limited cross-platform support: VB.NET is primarily designed to run on Windows
operating systems
Lack of community support as although it has a dedicated community, it is not large as
other programming languages such as Java or Python
Analysing
Decomposition is a vital part of programming, as it is applied in many parts and helps
the programmer design the software application in a variety of different ways, which are
less complicated and much quicker. For example, decomposition allows the user to take
a complex problem, and break it down to smaller understandable problem, which they
can later solve it. The benefit of this is that it doesn’t constraint the user from solving a
problem they come across and motivates the user from giving up on a problem.
However, the disadvantage is that it can take up a lot of time depending on how
complex or big the problem is. This is very big downgrade as in major companies, the
programmer can take a lot of time to solve one problem, and if they miss the deadline,
they can get fired from their jobs. An example of decomposition I encountered, is when I
was a making a “Rock-Paper-Scissors" game using the programming languages HTML-
CSS-JavaScript; inside I encountered a problem, in which I had to calculate the different
outcomes the game must have, therefore, I divided the solutions into different section,
which I later coded and tested.
Furthermore, pattern recognition is also a vital part of computational thinking, which
simplifies the user’s life by recognising the patterns of the matching data. For example,
in VB.NET, the designer of the software application has made it so that once clicked on
one attribute, the software will automatically match the corresponding matching data,
which will be highlighted. The benefit of this, is that will allow the user to make sure
there aren’t any mistake in the program, which will have a better outcome. However, the
disadvantage is that it can take up a lot of time, as you will have to find the correct place
to insert the matching opening/closing data. An example of where I encountered pattern
recognition, is in HTML, where the software VS Code, underlined the HTML attribute in
red, showing that there’s an error, which was mostly about the closing data. For
example, <p> was missing </p>.
In addition, pattern generalisation and abstraction are also a vital part of computational
thinking, and like pattern recognition, they also simplify the user’s life, by taking out the
irrelevant information which the users might not need, for example, how the CPU
compiles high-level language, to low-level language. The advantage of this is that it does
not create a lot of tension for the user, especially the new ones, as they do not want to
start learning any programming language by learning the hard part. However, a
disadvantage is that it prevents the experienced programmer from having any extra
knowledge, as most software applications hide such information. Therefore, the user
must do his own research, which can take up a lot of time. An example of this
computation skill I encountered, is when running the program whilst coding in VB.NET.
Here, once I clicked the run button, the software did not show irrelevant information,
such as how the CPU was compiling the script of code in that moment. Instead, it showed
me a loading screen which was much better as I did not want to see the first set of
information which would make my life harder because I am still a new learner in VB.NET.
The use of software applications consists of the software the programmer uses to design
the software application. For example, right now, the preferred application for
programming is VS Code, which contains a variety of common programming languages,
and has a feature which called “Live Server Extension”, which allows you to test your
program to see if it’s meeting your requirements. This is a huge helpful tool as it’s free
and helps new learners to program their small software in a much less complex way as
the software application has a simple interface.
The features & characteristics of programming languages consist of the different visible
characteristics the coding script has on each programming software application. For
example, VS Code has this feature which colours the matching coding attributes in the
same colour, so that it’s not only visually better, but also allows you to see what each
code is about. For example, the tags <html> and </html> will be highlighted in the
same colour, along with all the other tags which are considered as html attributes.
Procedural programming is a programming model that runs the script of code in order,
line by line. The advantages of procedural programming are that it’s excellent for general-purpose
programming, simplicity of code and less demanding on memory use. For example, in Java, the code
writeMessage() is an example of code re-use, because it's used multiple times. On the other
hand, the disadvantages of procedural programming are that the program code is harder to write when
procedural programming is written down, the procedural code is often not reusable.
Event-Driven programming is a useful tool as it runs the program that is triggered by the actions of the user.
For example, IF Statements, which are only executed only if the user has done certain action. The advantage is
that it will provide a way to make decisions and control the flow of a program based on
different inputs and conditions. However, the disadvantage is that sometimes the
program will not run for various reasons, such errors in the IF Statements.
Machine learning is the process by which the CPU compiles the high-level language into
something it can understand and execute, low-level language. The advantage of this is
that it will allow the user to execute any programming language without worrying about
any malfunction in the process of executing the program. However, a disadvantage is
that it will cost a lot of money to run such CPU as you’ll need advanced CPU for
advanced programming languages.
Markup language consists of coding attributes/elements used to construct a software
application. The benefit of this is that they are very easy to learn, and do not require a
lot of time to get used to them. For example, the html attribute <p> stands for
paragraph. However, a disadvantage is that it’s easy to forget such attributes, because
they are not displayed like normal words, we use every day.
Scripting is another programming paradigm that is used to instruct the computer. For
example, Ruby is a scripting language that has advantages such as the interactivity of
the code which allows the code to be developed and test rapidly. However, a
disadvantage is that script often lack coding skills by the user, which prevents the
programming from executing.
Object Oriented programming is another programming paradigm that is characterized by
the identification of classes of objects closely linked with the methods (functions) with
which they are associated. The advantage of OOP is the flexibility and security of the
code, as you can reuse the same code multiple times. For example, in JavaScript, you
can give a class to the attribute. However, a disadvantage is that it can be challenging
as you might have multiple classes which can be challenging to design with an OOP
concept as you will have to remember what u named. For example, if you have multiple
classes and if you did not name the classes properly, it will create a lot of problems.
Evaluation
Whilst decomposition can be useful as it allows the user to break down complex
problem, into smaller understandable problems, so that it becomes easier to solve,
decomposition also has many disadvantages. For example, decomposition can take a lot
of time, which impacts the design of the software application as time becomes a
constraint. Furthermore, you will also have to solve the problem you broke down into
small understandable chunks, which can take a lot or less time depending on how hard
or easy the problem is to solve. For example, in html, when making layouts, the function
div, can take a lot of time to understand, as it can be confusing and stressful. However,
an advantage for decomposition is that it allows you to solve a complex problem in a
much easier way, which can reduce time impact the design of software application as
now it’s taking much less time. For example, when designing a website, such as
YouTube, you break down the layout in small pieces, so it becomes less confusing, and it
will allow you to solve the problem in a much less complicated and complex way. In my
esteemed opinion, I believe that decomposition is a useful and a vital part of
computational thinking, as it allowed me to solve different problems when it came to
programming. For example, when I made the gym membership, and I broke the
checkbox down into a different section, and I finally managed to write every code which
belonged in that category.
Whilst Pattern Recognition can be useful as it recognises and identifies patterns in a
data, it also had downsides, which can impact the design of software applications. For
example, some disadvantages of pattern recognition are that it can be complex to
implement, and it is a very slow process. This impacts the design of software
applications as sometimes the programmer cannot know which data it’s classifying. For
example, in html, when there’s a lot of div elements, it can be hard to identify which can
be stressful for the programmer. However, an advantage is that the software
applications are now designed so that it will identify which attribute has its closing
attribute, such as <p> and </p>. In addition, it also helps classify unseen data, which
makes valuable decision, and it impacts the design of software applications as it
decreases any chances of syntax errors., which helps the design of software applications.
In my esteemed opinion, I think that pattern recognition helped me a lot whilst I was
designing website in html, as anytime I got lost, I simply clicked on the html attribute,
like <p>, and highlighted its matching closing attribute, which was </p>, which helped
me a lot. This impacted the design of software applications, which made it for me much
easier.
Whilst pattern generalisation and abstraction can be useful as it simplifies the program,
it can also have many downsides, which can impact the design of software applications.
For example, some disadvantages are that its constraints the user from knowing what’s
happening behind the code, and how the CPU compiles the code. This impacts the design
of software application as I cannot know extra information which I could use for my
overall design. For example, when I run the html with a live server extension, the
program VS Code will not show what’s happening behind the code I wrote, which
prevents me from seeking that extra knowledge. However, an advantage is that it will
take out all the irrelevant information that I don’t need, such as the CPU, which is
compiling, only if I’m a new user, which means that having the knowledge of the CPU
and how it’s compiling the code, is not much relevant to me. Another example is when I
was designing a website with HTML and CSS, I did not need to know how the CPU in my
device compiled the code, as my target was different. This will impact the design of
software application as I will be able to build up my application without wasting time
knowing what’s happening in the CPU. In my esteemed opinion, I think that pattern
generalisation and abstraction is useful as it allowed me to program in a very less
complicated way, as I’m a new learner in the programming language html and made my
life easier thanks to the different computational skills that were applied to the software
application. This impacted the overall design of the software application as it saved my
time, and I made the outcome in a much quicker and less complex way.
Before starting to program, it is vital for the user to know which programming software
application they are going to use. This is because, different applications have different
categories, which may or may not help the user depending on how much experienced
they are. For example, a new user should use applications such as VS Code, which
contains pretty much every language, and has a simple interface which the user will be
able to understand. The advantage of this is that it will simplify the user’s life, and they
will be able to program in a much less complicated way. This will impact the design of
the software application as it will save time and decrease the chances of any syntax
errors. However, there are also disadvantages which can make the user’s life harder. For
example, VS Code can be overwhelming for new users, as they might not need all the
hundreds of features which are listed. This impacts the design of the software application
as the user might select the wrong feature which will have a wrong outcome. In my
esteemed opinion, I think that it is vital for the user to select which software they are
going to use for their design, because it all depends on the list feature it contains. For
example, I chose VS Code, and although it seems very overwhelming, I got used to it and
carried on with my program.
Furthermore, whilst using the software application, it is also vital to see which software
has the different features & programming characteristics. For example, VS Code has this feature
which colours the matching coding attributes in the same colour, so that it’s not only visually better, but also
allows you to see what each code is about, which is a good benefit for the user. For example, the tags <head>
and </head> will be highlighted in the same colour, along with all the other tags which are considered as html
attributes. This will impact the design of the software application. However, a disadvantage, is that low-level
language, is more complex and stressful compared to high-level language as it’s the closest language to the
English language. However, it also has its own disadvantages as high-level language takes more time for the
CPU to compile it. This is because low-level language it’s written in binary, which the computer understands
and can execute the program quickly. This impacts the design of software applications. In my opinion, I think
that this is indeed a very important in programming as new learners cannot understand low-level languages,
therefore, high-level language suits them. An example which I encountered, is when learning VB.NET, which
was best for me to learn t in high-level language as low-level language would be stressful for me.
In addition, there are many programming paradigms in programming. One of which is procedural
programming, which runs the code line by line. Procedural programming enjoys the benefits of being easy to
compose, less memory-requesting, and extraordinary for broadly useful programming. For instance, in Java,
the writeMessage(), is a reusable code which is utilised a few times. This impacts the design of software
application as it will take less time to build the software. In any case, procedural programming has downsides,
for example, harder program code to deliver while procedural writing computer programs is archived and
often non-reusable procedural code, which may create a problem as it will require you to use another code.
This will impact the design of software application as new sources of code could not match what the user
wants to. In my estimation, I think such paradigm can create a lot of problems, as sometimes new learners
only have the knowledge of few sources of code, and do not know any alternatives. For example, I do not have
much experience in JavaScript, to the point where I can create a full running website on my own. Therefore,
any encounter such as above could create a big problem for me. This will impact the design of software
applications as I would have to learn new features, which will delay the time taken to build the software
application.
Event Driven writing computer programs is a valuable device as it runs the program that is set off by the
activities of the client. For instance, IF Statements, which are possibly executed provided that the client has
done specific activity. The benefit is that it will give a method for deciding and control the progression of a
program considering various data sources and conditions. This will impact the design of software application
as the program will now run on specific conditions that the user will meet by their own will. Nonetheless, the
drawback is that occasionally the program won't run considering multiple factors, such mistakes in the syntax
errors, which you might have not met whilst writing the code. This will impact the design of software
applications as mor errors will lead to a weak software application. In my opinion I think object is a really
important tool as it helped whilst making a rock paper scissors game in JavaScript, in which I had to list all the
different answers the computer was going to give out though the function alert(. This improved the design of
the software application as now there were no more mistakes or bugs any user could come up to whilst using
the program.
Machine learning is the process by which a CPU compiles the code. For example, in HTML, the computer does
not understand the language used, therefore, the CPU compiles/converts to something it understands, also
known as hexadecimal (low-level language). The advantage of this is that the user will not need to worry about
learning complex hexadecimal languages. This will impact the design of software applications as now it will
cost language to learn and write these programming languages as they are close to the English language.
However, a disadvantage is that it takes a lot of time to execute. For example, a program written in Python,
will take more time to execute to a program written in binary, as it takes time for the CPU to compile
programming languages. This will impact the design of software applications as it will delay the time of the
outcome, which now will take more time. In my esteemed opinion, I didn’t find machine learning frustrating
yet, because the software I’m running are much smaller compared to the one a company runs.
Markup language is a vital for design such as websites. This is because they consist of elements which are used
to build the design. For example, the attribute <html> is vital when making websites, otherwise your program
will not run. The advantage of this is that they are easy to remember as they are not very complex. This will
impact the design of software applications as it will save tie, rather than searching up for the solution online.
However, a disadvantage is that it can be very complicated and confusing when there’s a lot of coding script,
and you must insert the attributes in the right place where it belongs. This will impact the design of software
application as it can take up a lot of time depending on how long the script of code is. In my esteemed
opinion, I didn’t find markup language frustrating yet, as the software I’m running are much smaller compared
to the one a company runs, such Amazon. Whilst scripting language is useful as it allows you to give
instructions to the computer, it also has its own advantages and disadvantages. For example, in JavaScript, you
can instruct the software to open a folder first, and then a file by the code folder/file. The function folder
stands for the folder you want to open, the symbol “/” tells the program to open the folder and the function
file, stands for the specific file you want to open. The advantage is that it lets you instructs the computer to
perform specific tasks. This will impact the design of software applications as it will save your time and get you
used to the functionality. However, a disadvantage is that sometimes the file can be lost as you might have
misplaced or deleted the file. This will impact the design of the software application as it will cost your time
because you will have to find different alternatives and you will also be constrained to carry on. In my
esteemed opinion, I found this feature useful as it allowed me to perform multiple operations on it. For
example, when I was making the website YouTube in HTML, I created a folder in which I inserted all the
different pictures I was going to use and insert in the program. The reason why I made a folder was to not
have multiple files misplaced.
Whilst Object Oriented can be useful as to improve code readability and reusability by defining a
program efficiently. For example, in HTML, you can give the attributes classes, which
means you will target specific attributes, no matter how many times they are used. For
example, in if you have multiple attributes of <p> (paragraph), you can name each one
single one by doing the following: <p class= “paragraph1”>This is a text of
paragraph</p>. The elements highlighted in red, stand for “paragraph”, and they are
the opening and closing points in which you’ll display your text you want the user to see.
However, we might have multiple <p> attributes, and we might want to change the
format of one specific elements, and not all of them. Therefore, after <p, you insert the
element class, highlighted in blue, followed by an “=” sign. This shows that you’re about
to give a specific name to the attribute. You then put speech marks, which are
highlighted in green, and in between you write the name you want to give to your
attribute, for example, paragraph1, which is highlighted in gold. After that, you write
your text you want the user to see, as shown in the line of code above ( This is a text of
paragraph). At the end, you end the code with </p>, or anything else depending on
which attribute you are using. You can later target the line of code in CSS, by starting
with a dot, and then the class name. In our example, it would be “ .paragraph1{}” By
doing this you will be able to change the physical characteristic of your text, such as
size, colour, font, etc... This impacts the design of software application as you will be
able to give different properties to specific things you want, which will catch the user
attention and will also have a good design. However, a disadvantage is that it can be
really challenging as you might have many classes and you do not remember properly
how you named them. For example, you might have multiple <p> attributes, and you
might have named one of them “paragraph1”. Then, whilst you’re targeting the line of
code, you might write “parargaph1” which is different from the original class, therefore,
your code will not execute, and can be very frustrating as you might have hundreds and
hundreds of lines of code. Therefore, it will constraint you from improving the design of
the software application.

Bibliography
Low-Level Language
https://sites.google.com/a/iharrow.org.uk/compsci/1-1-data-representation/1-1-2-
hexadecimal/3-uses-of-hex-html-mac-debugging?tmpl=%2Fsystem%2Fapp
%2Ftemplates%2Fprint%2F&showPrintDialog=1
High-Level Language
https://towardsdatascience.com/3-tools-to-track-and-visualize-the-execution-of-your-
python-code-666a153e435e
Machine
https://www.se.com/uk/en/faqs/FAQ000247106/
Markup
https://studio.code.org/docs/concepts/html/html-tags/
Scripting
https://debug.to/378/if-conditions-in-programming-languages
Comparing & Contrasting Programming Languages
https://twitter.com/seokonikaislam/status/1538110507227312128
Identifiers
https://alok-verma6597.medium.com/case-styles-in-development-camel-pascal-snake-
and-kebab-case-ed8e7b2497af
Data Type
https://www.comteachers.com/dataypes-in-vbnet
Statements
https://www.c-sharpcorner.com/UploadFile/75a48f/python-if-else-nested-if-elif/
Logical Operations
https://www.geeksforgeeks.org/written-version-logical-operators-c/
Subroutines, Functions and Procedures
https://bournetocode.com/projects/gcse_computing_fundamentals/pages/3-2-7-
subroutines.html
String
https://www.homeandlearn.co.uk/NET/nets1p13.html
Array
https://study.com/learn/lesson/one-dimensional-arrays.html
Stack (LIFO)
https://www.programiz.com/dsa/stack
Queue (LIFO)
https://www.geeksforgeeks.org/queue-data-structure/
Structure (Or Record)
https://medium.com/nerd-for-tech/c-class-struct-record-record-struct-d3b21c57d9bb
Finding The Length Of A String In Characters
https://www.javastring.net/java/string/length-method-examples