>>Computational thinking<<

As we evolve and progress in technology we face more complex

problems from AI and rocket science to curing cancer so we need to
know how to use our brain to solve these problems.
In order to solve problems, we need computer and computational
thinking help us and computers to understand problems.
Computational thinking is a way to solve complex problems faster
and easier and its not only for technology systems, we can use these
steps t solve everyday problems and train our brain.

1. Decomposition:
Decompositions means breaking a complex problem into
smaller and simpler parts, so if we can’t understand it we
break it and make it simple, by doing this we can understand
complex problems and once we understand it we can make
new solutions to solve it.
For example you are trying to make a really complex
program and you don’t know how to start it or what
functions to make, what you can do is break that one big
program to simpler parts, then organize these parts and
decide which part should be first, like this you waste less
time writing useless code and have more time working on
your functions.

2. Pattern recognition:
Looking for similarities among or within a problem, sometimes we
can use our past experiences to solve new problems, lots of times
we have the answer to a problem but we don’t understand it so
we think its impossible to solve but trying to look for similarities
can help us to use our experience with older problems to solve
new ones.
Sometimes you have the answer to your problem for example,
you want to write a function for your code and you don’t
remember how to make that function, by looking at your past
work and functions you made you can find a solution to that
problem or maybe you already have the code for that function
and you don’t know it.

3. Abstraction:
In a complex problem we can encounter a large amount of data
and information, but first two steps can help us to identify
important part from irrelevant part, it’s important to focus on
important parts of the problems instead of irrelevant parts.

4. Algorithms:
Once we follow first three steps we can make a solution for our
problem but after finding the solution we have to develop it in
a way that others and computers can understand it and work
with it, so algorithms mean developing a step by step solutions
that computers can follow and function with it and help us
solve the problems.
 Principles of computer programming.
There are lots of programming languages in the world that we
can use, programming languages are usually different from one
another and this can make it difficult to learn two or more
different languages, in each separate language you have to use
different codes to make your program but there are some
principles that are the same all over programming world and
we have to use them to make programming easier for our
selves and write codes with higher quality.

KISS (Keep it simple, stupid)

This means when you are writing codes you have to keep your
solutions simple so other people can read and understand your
code, you can make your code simple by commenting your
code, removing unnecessary codes and breaking complex codes
into smaller and simpler parts.
When you are working with a group of programmers you must
make sure they can understand your code when they read it so
you all can collaborate easier and faster.
Having simple code is not only about others, its more about you
and how you can fix problems in your code, when you write
code you going to make mistake and having simple code with
comments which can explain what that part of your code does
you can find problems easier, you can debug easier and faster
because you can see or at least guess which part is causing the
problem.

DRY (Don’t repeat yourself)

You should never repeat you code for many reasons, it will take
time to write and clean when you have too many codes and
you don’t need, it can be confusing for others or yourself when
you read it specially if you are working on a big project it can
 waste everybody’s time and repeating code will make your
program larger in size.
It will be harder to maintain your code, if you change one part
of code you must go back and change other parts but instead of
that you can use define a function to stop repeating your code.

YAGNI (You aren’t going to need it)

Stop writing a bunch of code that you don’t need, sometimes
people write codes that they might need in future but that is
wrong because if you don’t use that code you wasted so much
time.

Separate different parts and functions of your code it makes it

simpler and if you decide to optimize or update your code it
would be easier to do it because you can find them easier and
change them without harming other part of your program.

Optimizing your code.

Do not optimize your code before finishing it, optimizing can
help your code run faster and take less space but first you need
to finish your code test it and see which part can be optimized
then start optimizing it because if you start optimizing at the
beginning you can waste you time and maybe you code doesn’t
need optimizing.
 Principles of software design.
When you are making an interface for your program you need
to consider bunch of things to make it suitable for users, there
are some principle that you can use to make a good interface
for your program and I am going to explain some of them here.
Software design is really important because most of the time
it’s the way user can interact with the program so when
someone is trying to design a software they should consider as
much of these principles as they can to make sure every part of
program works.

SOLID principle.
SOLID principle stands for five principles which are
1.Single responsibility
2.Open/Close
3.Liskov substitution
4.Interface segregation
5.Dependency inversion
Solid principle is a coding standard and all developers must
have a clear concept for making software’s with high quality
and proper design.
It was introduced by Robert C. Martin and its used in object-
oriented spectrum.

Single responsibility principle.

A class should only have one and only one reason to change,
The idea is to show us as time passes requirements changes
and we have to make some changes in our code, now if you
have a class that is responsible for a lot of functions when you
try to change it you have to change all the functions in that
class and it can lead to bugger problem because after that you
may have to change other parts of your code, so if each class
has a single responsibility you have an easier time to change it.
 Open/Closed Principle
This principle states in object-oriented programming entities
(classes, modules, functions, etc) should be open for extension
but close for modification.
The idea is to tell us write your code in a way which you can
add new functionality without changing the existing code, this
will prevent the situation in which you make one change in one
class but you have to change all other classes to.

Interface segregation principle.

Clients should not be forced upon interfaces that they do not
use, this principle states that as a software designer we should
separate the interface in different parts and then design each
of then in a way which user needs to.
As time passes users have new requirements and if you have
one main interface and you try to make new changes and add
new features you will need to change a lot of thing but if you
separated your interfaces you can choose which one to change
and make the new changes.

Software should be flexible.

Software design must be flexible so when change is needed
programmer can make changes in any part of the code without
running into huge problems or breaking the program, to
achieve the flexibility the basic design concepts such as
abstraction, refinement and modularity should be applied
effectively.
 Impact of computational thinking on software design and the
quality of the software application produced.

Impact of computational thinking on software design:

Computational thinking is a way to solve complex problems in
programming and writing algorithm, software design is
programming so we can use it to solve complex or even simpler
problems.
I found Software design really hard and you will run into lots of
problems and I think the best way to solve these problems
without damaging our code is to use computational thinking
there are 4 steps in computational thinking and by following
them you can solve complex problems, I realised you may be
able to solve them by not using the computational thinking but
you have to consider it may take much longer time and you can
change and break some parts of your program which will lead
to more smaller problems and you have to spend more time
debugging and solving those smaller codes.
When you are making a program for a serious project for
example making an OS like windows or making OS for smart
cars or rockets you will run into massive problems, scientist
also use these steps which I already explained to solve those
problems.
After doing this report I learned that big part of software design
is programming and knowing all those principles and steps can
have a huge impact on software design.
Computational thinking became a thing because running into
problems is part of programming.
By using computational thinking programmers can waste less
time on problems, fine better salutations and make software’s
with higher quality.
 Computational thinking impact on quality of software
applications:
I think The quality of the software is as important as other parts
of the software, if you have a company that is responsible for
making software’s or you are in a group of programmers and
you make software’s for other companies, you are directly
responsible for the quality of the software.
All those principles and steps are designed to help developers
design a high-quality software for their clients, if you read those
principles and understand them you can design a high-quality
software.
From this report I learned using computational thinking has
impact on your code and quality of your software and it can
improve your coding skills.
Some software’s are design to be used only by humans and
some of them are designed to work with each other, its
important to make both of them with high quality but from
what I learned the one humans use need better and higher
quality because humans care about GUI and small details, I
think one small mistake in design can make people dislike your
software and leave bad reviews which can lead to decreasing
users of your software also apps with users need new updates
and patches and these type of software’s wont last long if you
don’t add new features, new looks and patch old bugs in your
software.
From this report I learned Having high quality means your
software should run smoothly without crashing, having useful
features for your audience, having a professional GUI or not
running in to bugs when using that software, to achieve all
those thing we need to follow the computational thinking steps
to solve complex problems and bug in your software, I think
 every programmer needs to understand principles of
programming and software design so you can code easier,
faster and with less bugs and mistakes, when you learn to use
them properly you can make a software with good quality for
your audiences.

Evaluation:
This is the evaluation of how computational thinking and
principles of computer programming can help and enable a
programmer to produce high quality software’s.

(Seymour Papert -1980)
The term computational thinking was used by Seymour for the
first time in 1980 and 1996, computational thinking was made
to solve complex problems by using 4 simple steps which
breaks the problem into smaller and simpler part, today
programmers use this method to make better software’s and
save more time on solving the problems, computational
thinking teaches programmer to break the problem into
smaller parts so they can understand it then they look for
similarities between that problem and other problems because
sometimes you have the answer but you cant see it next they
look for more important parts to solve and focus on and at last
when they have the answer they make a algorithm for
computer to understand and solve the problem, these steps
help the programmer to solve complex problems which means
larger, better and more complex programs for bigger projects
like rockets, cars and more.
Large projects like working for tesla or SpaceX or other large
companies with super important projects will have large and
complex problem and bugs but computational thinking has
always helped programmers to solve these problems and make
higher quality software’s.

(U.S NAVY-1960)
KISS principle which is short for keep is simple was design by
US navy, it helps programmer in groups to keep the code
simple delete unnecessary codes and writing comments for
code, this way wen they work in groups everyone can
understand the code and edit it or add more features which
means better team work and higher quality.

(Andy Hunt and Dave Thomas-1999-The pragmatic

programming)

DRY principle or Don’t repeat yourself helps programmer by

telling them to stop making the same functions many times so
when they want to change something they don’t have to
change the whole code instead they should use one same
function in different areas of the code so if they need to change
something they do it one time in one part of the code.

(Bertrand meyer-1988)
Open/close principles says classes, modules and functions must
be open to extension but close modification, so programmers
use it to add new features to a piece of code but they can’t
change the already existing code, this helps programmers to
make new features without deleting or making new bugs in the
old code.