Additional Lecture: Introduction To Programming

Loading...

En provenance du cours de University of London

Creative Programming for Digital Media & Mobile Apps

35 notes

University of London

Creative Programming for Digital Media & Mobile Apps

35 notes

This course is for anyone who would like to apply their technical skills to creative work ranging from video games to art installations to interactive music, and also for artists who would like to use programming in their artistic practice. This course will teach you how to develop and apply programming skills to creative work. This is an important skill within the development of creative mobile applications, digital music and video games. It will teach the technical skills needed to write software that make use of images, audio and graphics, and will concentrate on the application of these skills to creative projects. Additional resources will be provided for students with no programming background. At the end of this course, you will be able to: * Write creative, audiovisual programs in the Processing environment that run on desktop and mobile * Programatically manipulate sound in creative ways * Display images and image sequences * Generate interactive, algorithmic graphics * Work with a 2D physics engine to create a basic game

À partir de la leçon

Sonic Painter

This week we are getting up and running with the Processing IDE. We will show you the basics of writing Processing sketches then move onto some graphics and audio concepts. Mick will then introduce our first audiovisual example - SonicPainter, which allows users to interactively paint with synchronised graphics and sound.

Additional Lecture: Introduction To Programming 13:11

Additional Lecture: Variables 18:15

Rencontrer les enseignants

Dr Marco Gillies
Senior Lecturer
Computing Department, Goldsmiths, University of London
Dr Matthew Yee-King
Lecturer
Computing Department, Goldsmiths, University of London
Dr Mick Grierson
Reader
Computing Department, Goldsmiths, University of London

This is the first of our lectures for people who are doing this course but are

new to programming. If you've got no programming experience

you're probably going to have to work a little bit harder in this course.

It will be a little bit more challenging though we will guide you through it, and

this, these lectures will explain the major concepts.

And we're also going to put up a bunch of other materials that can support you.

before we talk about programming we need to think a little bit about what a

computer is, in order to understand how to program.

this is a computer, the inside of a PC, I, I just got off flickr.

and you can see it's messy. There's lots of microchips, there's sort

of motherboards, wires everywhere. But actually we don't really, to program,

we don't need to know what a computer is in all it's complexity.

Actually all we need to know is some very simple things, and And really we just

need to know two things that make up a computer.

This is the processor. It's not actually a processor, it's a

fan, but underneath that fan is the processor.

The processor is the thing that does calculations.

It does actions. It really is the core computer.

And the other main that we need to know about is memory.

This is where we store data. And anything that is, you know, any form

of data that we are processing in the computer must go through memory.

And really what a computer does and what a computer program does is.

The processor does actions on memory, memory is composed of very very simple

output, so it's, what we call bits. Each bit can, is like a switch.

It can be on or off. And we normally represent that as a zero

and a one. So, really memory is along Series.

And the processor, what that does is very simple operations on memory.

It can add two elements of memory together, multiply those mathematical

operations, very simple ones, and it can move things around in memory.

And that's It's a little bit more compelx than that, but really not much at all,

it's, you know, what, it's only these very simple things.

So, why are computers so powerful, if all they can do is, is, move around and add

together zeroes and ones. Well, the reason is, because memory is

very, very big. So it's measured in gigabytes, that's

billions, American billions of, of bytes. A byte is eight of these bits.

So there's a lot similarly processes summations in gigahurtz which essentially

billions of these very simple instructions per second.

so a computer program is really about doing a simple things.

But very, very fast and lots. Luckily we don't have to think in terms

of the very, very simple operations that can, that processors we can do when we

want the computer to programs. We turn them into what we call high level

languages, that have, that combine lot's and lot's of these, very simple

operations into bigger ones. this still may not look very readable to

someone that's new in programming. But you can see that, at least we've got

much higher level concepts like Backgrounds, in the background color of

the screen, rotating things around, drawing images, stuff that's, that's at

least a bit more in the, the realm of what we think about as humans.

Similarly those, those ones and zeroes in memory, we can interpret them in many,

many ways to create many complex forms of data.

A single bit can't tell us much, but it can tell us if something is true or

false. It can be this kind of binary division.

But normally you would combine bits together into more complex things, the

basic level with calculating numbers. Whole numbers or fractional numbers, we

actually leaps rather differently I'll come back to that in a later lecture.

Text, and then much more complicated things like images or sound waves.

All of these things are essentially longer and longer strings of ones and

zeros and this course will cover a little bit about how the last two represent when

the main merges. Okay so let's try writing a simple

program. This is processing.

it's a piece of software. it's a program language and also it's a

piece of software for writing programs in that language.

We have this area here where we can type the text of our program.

But let's start by playing with, pressing the Play button to run our program.

And here we are. We've got a program, it's a very small

window, it doesn't do very much, but that's not really surprising.

We haven't actually written any program text.

At least even with writing nothing there, we do get a program.

Now I can close my program in the normal way with the close button, or I can also

press stop to stop it running, and then we can actually try writing something.

Okay. I'm going to first write this command

size 640x480. And let's see what that does.

There we go, we've got a much bigger window.

and I've, what has happened here. Well I've called a command size and that,

what that does, size is the named command.

And it changes the size of the screen. And you need two numbers in order to

change the size of the screen. And one of these numbers is the width,

640, the other is the height, 480. And These numbers are put in brackets, so

every time you're calling command you need brackets.

There are commands which don't need, any, numbers.

What we call parameters, parsed in. But we still need brackets.

Empty ones, which show that we're not parsing anything in.

The commands are separated by commas. And at the end of everything we have a

semicolon. Now the first thing to really notice when

we're writing new programs when you're new to programming is that grammar and

punctuation are vital, what we call the syntax of the program.

So computers, in many ways, are very, very stupid so they don't understand

things very well, unless you've got very, very precise punctuations to tell them

what to do. It needs these brackets, so that it knows

we're calling a command, and it knows where all the values we're passing into

the command, what we call parameters are know, needs those, the begin and end

brackets to know when these parameters stop.

It needs a comma to know when, parameter has ended and the next one has started.

It needs a semi-colon to know when one, when each command has stopped.

Don't have those things it will get you [INAUDIBLE] out/g.

For example, if I leave off the setting [UNKNOWN] it gives me unexpected token

null. It doesn't, it's something it hasn't

understood. And often these errors can be quite hard

to understand. so it's important to be quite careful.

Okay, let's try doing another thing with background 255, 0, 0, and there we have

arrange background. I will do, while it's slightly not the

program that draws a pointed screen, I will show this in more detail in me main

lecture, might want to take a look at but I can do that to set position and give it

a certain width. Otherwise we're not going to be able to

see it very effectively. And if you do that some [INAUDIBLE]

stroke weight length. so this is a typical thing, I did it

accidentally, but I've written the name of the command wrong.

It didn't understand it. The function stroke width does not exist.

I made an error, it told me that it wouldn't work.

Very common easy mistake to make um,. It was completely accidental in my

[INAUDIBLE], in my case but I'm going to leave this in the video because it helps

you see exactly the kind of areas you get, and what happens when you get that,

you get this little red bar coming out and you know something is wrong.

And it gives you some information which can be used for the function strokewidth

does not exists. [INAUDIBLE] What's one of them, stroke

width and then [INAUDIBLE] points. I'll go over these commands in the main

page. And there we are, we've got a dot on the

screen. There are two other things that I want to

show you that can be useful. Firstly we sometimes want to write notes

in our programs, if we want to sort of explain them.

So maybe I want to explain them so even. Explain it to somebody else using your

program or simply if you're going back to your program later it's useful to have

notes to remind yourself what's going on. We call these comments and we create a

comment by putting these 2 slashes in front of the line and anything else on

that line is ignored. I could do it at the end of a line a

well. [SOUND] And sometimes if I want to get

rid of a line of code temporarily as I'm testing what I'm doing I can comment it

out like this, so I can put a comment, turn it into a comment and all of these

comments are going to get ignored. And as we'll see now, the stroke weight

is no longer being called and my dot is very tiny you may not even be able to see

it. The other thing I'd like to do, show you,

is another very useful thing when you can, you're, when you're programming, is

that you can also print stuff out. If you do print ln, that stands for print

line, and some text. Like that, it will print it out.

Note that I'm putting all the text values in these double quotes.

You need double quotes so that the program knows this isn't the name of a

function or anything, this is actual text you want to use.

So you need to have that in double quotes.

And when I'm on my program, it will print heavily down here at the bottom of the

screen. That's useful for you, we'll see in the

future, as a way of getting information about the program when it's running, and

some debugging. Okay, so let's recap that a little bit.

The core of writing a program is the number of commans.

Each command has a name. It has parameters, these are values that

we pass to the command to change how it works.

For example, the size command takes a width and a height.

These parameters are inside brackets and we need commas to separate them.

And then we need a semicolon on the end of the line.

All this punctuation is very important, and you mustn't forget.

We can use comments to get the computer to ignore certain bits.

Okay, so the last thing is, I showed you, is this println command, and its for

using to print things out. Print out text, you can also print out

different values like numbers and variables which we'll come to in the

future. And you can use the plus to combine

together text and values, so that'll be quite useful in a number of ways later on

That way, we keep blocking our programs. Okay.

So that's a very brief introduction to the basics of programming and I'll do a

couple of extra lectures this week on specific topics and will be covering

various topics next, next couple of weeks to explain some of the concepts we use in

the main languages.

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play