Programming Paradigms - Computerphile Computerphile English English (auto-generated)

Programming Paradigms - ComputerphileYouTube↗ IA↗(long shot)
Education 589.4K views 9.7K likes 729 dislikes 30 Aug 2013

Computerphile 2.6M subscribers N/A YouTube↗

Click to Play Video

The same problem of summing up from one to ten

the same problem of summing up from 1 to

is actually done by what would appear to be magic

10 is actually done by what would appear

by simply going, "sum... one... ten."

to be magic by simply going some 110

Done. It's not quite as easy as that.

done it's not quite as easy as that one

One of the questions that I get asked umm when introduce myself as a computer scientist is

of the questions that I get asked when I introduce myself as a computer scientist

what exactly is I do and the easiest answer for that is, "programming."

is what exactly it is I do and the easiest answer for that is programming

There are different styles and

there are different styles and a lot of

a lot of people might not be aware of them

people might not be aware of them so

so, today, I'm just going contrast two of the most popular ones.

today I'm just going to contrast two of the most popular ones namely imperative

Namely, imperative programming and functional programming.

programming and functional programming

Adding the numbers from one to ten in two languages

adding the numbers from 1 to 10 in two

Java and Haskell

languages Java and Haskell so we'll

So, we'll start with Java.

start with Java we begin by introducing

We begin by introducing a variable, "total", an integer and saying, "well, that's zero to start with."

a variable total and integer and saying well that's 0 to start with because we

because we haven't added anything up yet.

haven't added anything up yet and that's

and that's comparatively easy.

comparatively easy and the actual meat

and the actual meat of the loop is done by opening up a for loop

of the loop is just done by opening up a

where we say, "for some number int i = 0

for loop where we say for some number int I equals 0

and i less than or equal to ten then i plus plus

and I less than or equal to 10 then I

and what that means here

plus plus and what that means here is

is we've got this little tracking variable, i, which we initialize to zero

we've got this little tracking variable I which we initialize to 0 we're going

we're going to be repeating this loop as long as it's less than

to be repeating this loop as long as

or equal to 10.

it's less than or equal to 10 and every

And every time we repeat the loop, we're going to increase "i" by 1.

time we repeat the loop we're going to

We're adding numbers 1 to 10

increase I by 1 we're adding numbers 1

so the obvious thing to do

to 10 so the obvious thing to do is to

is to say we'll change the variable "total" to the result of

say we'll change the variable total to

"total" plus "i."

the result of total plus I what we have

All we have here, is we've got an appearance of

here is we've got an appearance of the

the "equals" sign--some people would look at this and go

equals sign some people would look at

"Right. This is clearly the mathematical definition of 'equals'."

this and go right this is clear the

"which means that the left hand is equal to the right hand side."

mathematical definition of equals which means the left-hand is equal to the

Now, that's not the case in Java and other "C-like" languages.

right-hand side that's not the case in Java and other seed like languages what

What this single "equals" actual means

this single equals actually means is an

is, um, an assignment. We're saying that "total" is now equal to the previous

assignment we're saying that total is now equal to the previous value of total

value of "total" and we've added to it in some way. In this way we've added 1 to it.

and we've edited it in some way in this way we've add 1 to it if we were to have

equals then we would be checking for equality in which case this total equals

a double equals then we would be checking for equality in which case this

total plus what I would be false in all cases except for when I was 0 so this

total equals total plus what I would be false in all cases except for when I was 0 so this kind of statement that

kind of statement that involves variables such as total is

involves variables such as total is

characteristic imperative languages where the main method of computation is

characteristic of imperative languages where the main method of computation is assignment

assignment of values to variables

of values to variables that's going to

that's going to say we start with total zero its a 50 total equals 0 plus 0 0

say we start with total at zero they say of I is zero total equals zero plus zero

then we go back we increase i buy one

zero then we go back we increase I by

so now we say okay total is 0 plus 1 which is one we go back is now to total

one so now we say okay total is zero plus one which is one we go back is now

two total is one plus two it's now three

it's now three and we repeat once we get to the ends then we're done

and we repeat once we get to the ends then we're done if we want to call total

if we want to call total then it would just be the result of going 1 + 2 + 3 +

then it would just be the result of going one plus two plus three plus

w and eventually at the end of it will have total if we were to do a calling it

doubled and eventually at the end of it we'll have total if we were to do a

calling rate is 55 because that's the

because that's the sum from one step this is a characteristic of imperative

sum from one step this is a characteristic of imperative programming

programming in that we are referring two variables

in that we're referring to variables

that are defined globally this is a simple example of adding a couple of

that are defined globally this is a simple example of adding a couple of

numbers up in an imperative language

numbers up in an imperative language

namely this is done in java

namely this is done in Java what I'd

what I'd like to do now having just spoken about the mathematical definition

like to do now having just spoken about the mathematical definition of equals

of equals move on to a another language in which to do this something from one

move on to a nother language in which to

do this summing from one to ten namely

namely Haskell which is a functional programming language so the same problem of something up from one to ten is actually done by what

Haskell which is a functional programming language so the same problem of summing up from one to ten is

would appear to be magic are simply going some 110 done

actually done by what would appear to be magic by simply going some 110 done it's

it's not quite as easy as that there is a library function in the background

not quite as easy as that there is a

that's explaining how some actually works

library function in the background that's explaining how some actually

the first thing that we need to know about the sum function is what it's type

works the first thing that we need to know about the sum function is what its

is so we would say that the function sum is the function that takes a list of

type is so we would say that the function sum is the function that takes

integers this is syntax for list and it returns a single integer

a list of integers that's a syntax for lists and it returns a single integer

namely if we take a list from one to ten we're going to return some of them and

namely if we take a list from 1 to 10 we're going to return the sum of them

what we're going to do now is we're going to define this function in terms

and what we're going to do now is we're

of pattern matching a function can have multiple definitions associated with the

going to define this function in terms of pattern matching a function can have multiple definitions associated with the

value that's given to it what pattern matching ends is a way of deciding which

value that's given to it what pattern matching is is a way of deciding which

definition of a function to apply in a given case depending on the structure of

definition of a function to apply in a given case depending on the structure of

the input so let's say that we are looking at a function that takes lists

the input so let's say that we are looking at a function

then that function could be looking at an empty list

that tastes lists then that function could be looking at an empty list

it could be looking at a list with one element in it or it could be looking at

it could be looking at a list with one

one with more than that and a simpler example perhaps is a function is defined

element in it or it could be looking at one with more than that a simpler example perhaps is a function that's

over the billions

defined over the billions so a billion

so a billion value can either be true or false and a function that's to find out

value you can either be true or false and a function that's defined over there

of that the obvious one will be not so not true is false not false is true and

the obvious one would be not so not true is false not false is true and if we're

if we're using pattern matching

using pattern matching I'm going to take

I'm going to take my value and say is it true if the value that I've got is true

my value and say is it true if the value

then i use the function definition of going to false if the value that I've

that I've got is true then I use the function definition I'm going to false

got is false it will say look at this first line and well if I got true no i

if the value that I've got is false it'll say I'll look at this first line and well if I got a true no I don't I'll

don't i'll go down to the next one and also

go down to the next one and I'll say ok

okay well I've got a match there when you look at a function your input

well I've got a match there when you're

you will try and match from the top say is that the 1i need no right

looking at a function your input you will try and match from the top say is that the one I need no right look at the

look at the next one is that the one I need no is next one and it may be the

next one is that the one I need no is the next one and it may be the

case that you don't have all of the patterns necessary to fully define your

case that you don't have all of the patterns necessary to fully define your

function in which case a school will give you an error

function in which case haskell will give

it's a non-exhaustive patterns so if we have this sum of a single number

you an error it'll say non exhaustive patterns so if we have this sum of a

this is a list of one element we say that the results of the sum of one

single number this is a list of one element we say that the result of the

number is just that one number and if we have a list of more than one number then

sum of one number is just that one number and if we have a list of more

we would write it like this

than one number then we would write it

some and ends this is just shorthand for saying that the element that's at the

like this sum n ends this is just shorthand for

front of the list we call n all the other elements are called ends and we

saying that the element that's at the front of the list we call n all the other elements are called ends and we

were just define that as n plus some ends so this function sum is defined

would just define that as n plus some ends so this function sum is defined

recursively that is to say it's defined in terms of itself

recursively that is to say it's defined

what I might like to do for some people aren't familiar with functional

in terms of itself what I might like to do for some people that aren't familiar

programming is going through a very quick example of how the sum function

with functional programming is go through a very quick example of how the

works some of 452

sum function works some of 4 5 - so we

so we can refer to this function here and throughout and see how this is

can refer to this function here and throughout and see how this is

equivalent to the java representation that we've got over here

equivalent to the Java representation

so what pattern matching involves we look down and say are we looking at a

that we've got over here so what pattern matching involves we look down and say

are we looking at a single list no we're

no we're not so we can move down to the next pattern and we say okay

not so we can move down to the next

in this instance this for is the end of this 52 is the ends so this is defined to be 4 plus the son of 52 grand next step we're going again

pattern and we say ok in this instance this 4 is the N and this 5 - is the ends so this is defined to be 4 plus the sum of five and two grand next

summers are defined in terms of itself we haven't gotten down to the base value

step we're going again sum is defined in terms of itself we

yet so we're going to have to carry on

haven't gotten down to base value yet so

so we do so by saying okay so what you mean by the base for them

we're going to have to carry on so we do so by saying okay so what do you mean by

ok so functional programming the main method of computation for that is

base fun okay so functional programming the main

applying arguments to functions as compared with Java but it's assigning

method of computation for that is applying arguments to functions as compared with Java or it's assigning

values to variables by here when I say we've reached a value

values to variables by here when I say we've reached a value I mean that we've

I mean that we've evaluated a singleton and returned and so to carry on with

evaluated a singleton and returned n so

this evaluation hear what I want to do is to say okay that's some five plus sum of two because in this instance here this was the end and this was the ends

to carry on with this evaluation here what I want to do is to say okay that's some five plus sum of two because in this instance here this was the N and

and now I carry on and I say oh well if I'm going to be corrected going to

this was the ends and now I carry on and I say oh well if I'm going to be correct

bracket that and say four plus five plus now i can look and say

I'm going to bracket that and say four plus five plus and now I can look and

pattern matching start from the top have I got a single to list yes I do

say pattern matching is stuff from the top have I got a singleton list yes I do

so what am I going to return just that number two so now I can start boiling it down so that's 4 plus 7 equals 11

so what am I going to return just that number two so now I can start boiling it down say oh that's four plus seven equals eleven so what I've gone through

so wyd gone through here is just a quick example of how a functional programming

here is just a quick example of how a

would take the approach to some function defining what the some actually does as

functional programmer would take the approach to some function defining what the sum actually does as opposed to

opposed to looking down and doing it in terms of variables saying will track

looking down and doing it in terms of

this and add it to this and eventually the result will fall outfit

variables saying we'll track this and add it to this and eventually the result

it's it's probably worth saying though that this isn't how some is defined in

will fall out of it it's it's probably worth saying though that this isn't how

my Haskell high bring it is actually defined as some fold l + 0 but that is

sum is defined in the Haskell library it's actually defined as some fold l plus 0 but that is dark art that I don't

dark out that I don't want to get into it

quite want to get into it this video say

this video so one particularly important thing to take away here given that i've

one particularly important thing to take

been contrasting these two is that in this example here where I've been

away here given that I've been contrasting these two is that in this

something one to ten in java

example here where I've been summing 1

this is revolved somewhat around this variable total which has been evolving

to 10 in Java this is revolved somewhat around this variable total which has

as the for loop progresses

been evolving as the for loop progresses

I've been updating this total variable and increasing it to reflect a new value

I've been updating this total variable and increasing its

until I get to the end of the for loop

to reflect a new value until I get to

so this is characteristic of imperative programming languages

the end of the for loop so this is characteristic of imperative programming

the fact that i have a external global variable that i can update a will

languages the fact that I have a external global variable that I can

whereas in functional programming and high school there is no state externally

update it will whereas in functional programming in Haskell there is no state

I'm not calling anything from outside this sum function this sum from 1 to 10

externally I'm not calling anything from outside this sum function this sum from

is defined entirely in terms of itself there is no reference to a total or

1 to 10 is defined entirely in terms of itself there is no reference to a total

something that's not explicitly reachable from inside this function body

or something that's not explicitly reachable from inside this function body

and that's because functional programming languages or purely

and that's because functional

functional programming languages don't allow for side effects and a particular

programming languages or purely functional programming languages don't allow for side-effects and a particular

example of a side effect is a mutable state swear by mutable

example of a side-effect as a mutable

I mean it can mutate you can update it so it can change from one value to

states whereby mutable I mean it can mutate you can update it so it can

another as a program progresses

change from one value to another as a

it's worth saying that these are both high level instances of languages and

program progresses it's worth saying that these are both high level instances

particularly simple instances of fragments from these high-level

of languages and particularly simple instances of fragments from these high

languages these do look quite different in the way that they approach things but they will

level languages these do look quite different in the way that they approach things but they will be boiled down to

be boiled down to machine code and very similar machine go to that given that it does something

machine code and very similar machine go

quite simple and in effectively the same way it's something one to ten it's not

to that given that it does something quite simple and in effectively the same

something that can be done very very complicated ways by different compilers

way something 1 to 10 is not something that can be done very in very complicated ways by different compilers

what if the university is just a computer simulation

what if the universe is just a computer

how would we know what sort of things when we expect to see

simulation how would we know what sort of things we expect to see could we ever

could we have our tab could we ever be able to work out that work

tell could we ever be able to work out

you know living in proud of a simulation of words and being pivoted down putting

that work you know living in part of a simulation or we're just a bit pivot and

all the elements lesson on one side and then Christ on the other side

putting all elements less on it on one side and then a great start on the other

I mean it that does not get any to something like side so you can see it's

side and then it there does that get any to sum each side so you can see it's

kind of it's done all the left hand side and I start doing the right hand side so

kind of it's done all the left-hand side and now I start doing the right-hand

the paper it does all the left hand side

side so there's a pivot it does all the

it's another pivot keeps doing this this animal until it's sorted

left-hand side it's another P that keeps doing this this animal till it's sorted

Similar videos:

1.1 Programming Paradigms
Functional Programming Principles in Scala
1.7K views 16 likes 0 dislikes 11 Sep 201767% match

HTML IS a Programming Language (Imperative vs Declarative) - Computerphile
Computerphile
137.1K views 3.8K likes 477 dislikes 28 Jun 201629% match

"C" Programming Language: Brian Kernighan - Computerphile
Computerphile
1.5M views 20.4K likes 772 dislikes 18 Aug 201524% match

Pong & Object Oriented Programming - Computerphile
Computerphile
193.9K views 3.8K likes 146 dislikes 16 Mar 201621% match

Programming in PostScript - Computerphile
Computerphile
181.1K views 3.5K likes 42 dislikes 11 Apr 201421% match

Funky Music from Functional Programming - Computerphile
Computerphile
65.5K views 1.3K likes 131 dislikes 06 Jan 201721% match

Functional Programming & Haskell - Computerphile
Computerphile
493.3K views 12.2K likes 144 dislikes 30 Nov 201620% match

Settings Privacy About Contact Donate