|
|
| Line 5: |
Line 5: |
| ''A short documentary about live coding practise by Louis McCallum and Davy Smith.'' | | ''A short documentary about live coding practise by Louis McCallum and Davy Smith.'' |
|
| |
|
| | | <br> |
| '''Iteracy'''
| |
| | |
| Iteration itself, is a term used in computing to refer to the repetition of a command, code fragment, process, function, etc. Understanding iteration is a crucial skill for developing programming skills as it is a means of re-using existing processes (looping structures). But also, iteration itself, combined with constant improvements, is a key way of developing software/code (very much associated with agile programming, for instance).
| |
| | |
| An example of iteration in Zajal code is (Zajal is a programming language):
| |
| <pre>
5.times do
| |
| | |
| text "Hello"
| |
| | |
|
end</pre>
| |
| This instructs the computer to perform the task text "Hello", or print Hello to the screen, five times in a repetitive loop, or iteration.
| |
| | |
| Here though I want to broaden the meaning of iteracy beyond mere iteration/looping structures in programming code. What skills, then, might be associated with this notion of iteracy? Computational Thinking: being able to devise and understand the way in which computational systems work to be able to read and write the code associated with them. For example abstraction, pipelining, hashing, sorting, etc. (see Wing 2011).
| |
| | |
| *'''Algorithms''': understanding the specifically algorithmic nature of computational work, e.g. recessions, iteration, discretisation, etc.
| |
| *'''Data and Models''': understanding the significance and importance of data, information and knowledge and their relationships to models in computational thinking.
| |
| *'''Reading and Writing Code''': practices in reading/writing code require new skills to enable the reader/programmer to make sense of and develop code in terms of modularity, data, encapsulation, naming, commentary, loops, recursion, etc.
| |
| *'''Learning programming languages''': understanding one or more concrete programming languages to enable the student to develop a comparative dimension to hone skills of iteracy, e.g. procedural, functional, object-oriented, etc.
| |
| *'''Code Aesthetics''': developing skills related to appreciating the aesthetic dimension of code, here I am thinking of 'beautiful code' and 'elegance' as key concepts (see Oram and Wilson 2007).
| |
| | |
| | |
| | |
| I also talk about a notion of 'digital bildung' but that is meant to be a broader term which would include iteracy as a constituent part. Digital Bildung and computationality (see Berry 2011) are larger frameworks of knowledge and practices around computational literacy, broadly conceived. However, iteracy is the name for the specific skills used for understanding code and algorithmic culture – as indeed literacy (understanding texts) and numeracy (understanding numbers) do in a similar context. That is, iteracy is specifically the practice or being able to read and write code, rather than the more extensive notion of digital Bildung (see Berry 2011: 20-26). In short, Bildung is still a key idea in the digital university, not as a subject trained in a vocational fashion to perform instrumental labour, nor as a subject skilled in a national literary culture, but rather as subject that can unify the information that society is now producing at increasing rates, and which understands new methods and practices of critical reading (code, data visualisation, patterns, narrative) and is subject to new methods of pedagogy to facilitate it (Berry 2011: 168). So digital Bildung would include the practices of iteracy and would build on them to facilitate a broader humanistic or critical education. Here, then, iteracy is defined broadly as communicative competence in reading, writing and executing computer code. But also, iteration itself, combined with constant improvements, is a key way of developing software/code (very much associated with agile programming, for instance). An example of iteration in C++ code is:
| |
| | |
| int loop = 1;
while (loop <= 10)
{
cout << "Iteration #" << loop << endl;
loop++;
}
| |
| | |
| <br> ''Why is "literacy' insufficient as a term?'' | |
| | |
| Of course, it isn't that 'literacy' is necessarily insufficient, but perhaps clunky when we start talking about 'code literacy', 'information literacy', 'data literacy', 'media literacy', etc. etc. Consider it a quick hack to create more meaning with less information by lopping off the 'l'.
| |
| | |
| The idea really follows from the idea that we don't talk about number literacy we talk about numeracy, we don't talk about word literacy, we talk about literacy, and it is also playful, having a strong association with the notion of iteration. Iteration, or looping structures more generally, are hugely important to understanding how and why computers function at all, it is also very important in order to read code to be able to see these structuring principles for code. See below for an extended 'content' for the concept. One thing we have to bear in mind is that we have not overly narrowed the definition of iteracy to ‘formal programming’. In this context I have found it very useful to explain to students that they are 'programming' a computer when they set an alarm on their iPhone or negotiate a menuing system in photoshop. This highlights that it is ‘blackboxes’ all the way down in computer systems. Iteracy, therefore, includes the abstract principles of computational thinking, as well as the specifics of learning programming in terms of source=>executable. I think that this is important in order to highlight the disadvantages that face individuals that do not have these basic skills around using computational devices. Increasingly 'iteracy' will be crucial for operating in this computational culture - especially considering the ontologies or models that are delegated into the computational devices that surround us take for granted certain computational principles of operation
| |
| | |
| ''"Messy" programming vs Literate programming''
| |
| | |
| When teaching iteracy we need to attend to the fact that certain ways of ‘writing’ code create functioning software. You cannot write random symbols into a computer and expect it to have an intended effect. Here, my intention is not to 'prevent' simple programming steps via examples – nor to prevent play or experimentation with different ways of writing code. But students will not get very far in using some of the more powerful potentialities of computation if iteration, etc., is not introduced in a timely manner, and preferably as soon as possible. That is why so many programming languages offer loops, iteration, recursion, procedures and so forth as a means of creating easily iterable blocks of code. I would also say, remarking on the choice of programming language for learning iteracy, that it is crucial that it is an accessible language but not too much of a 'toy language', that is, that you can 'build' real stuff with it. I, personally, think that that was one of the huge advantages of Basic, way back in the mists of time. Certainly programming languages have moved on now and so we need to find a new base language that can teach simple, moderate and then more complex ideas that are transferable to other languages with ease. Zajal/Ruby seems to me a good starting point, but this is certainly something that will be found in experiments in teaching code more generally.
| |
| | |
| I would like to say in addition to this that having grasped the basic principles of iteracy is crucial for reading code and for undertaking critical code studies at all. But also for using computational media. I think of the difficulty of using something like 'Motion' or 'After Effects' without understanding the basic principles of using and creating loops of visual material, or modern music composition using 'Logic Pro' or 'Pro Tools' without understanding samples, loops of samples, and the aggregation and layering of effects. These are deeply computational ways of working with media, and those who understand iteracy, I would argue, have an advantage in creating and using these systems and platforms, because of the cognitive maps iteracy provides for circumnavigating complex menuing, object-oriented visual structures, creating looping aggregates, and so forth.
| |
| | |
| This, of course, allows us to draw the distinction of source code (code as text) and compiled code (software as executable) and the fact that written differently may actually have the same effect (i.e. compile to the same thing). Certainly with the smartness of many compilers removing the need to worry too much about 'efficiency' and resource allocation this is the case. So writing code has some flexibility in how things are implemented (see later chapters that discuss this in detail in relation to object functions and immediate functions).
| |
| | |
| So, often when it comes to code, the emphasis is on documented code, readable code, literate code that can be maintained and scaled and remains comprehensible. Indeed many of the great leaps forward in computing, such as object oriented programming, are less to do with efficiency (in code), and more to do with comprehensibility of large systems for design and implementation (reading and writing of code systems and aggregates).
| |
| | |
| By contrast 'messy' programming is not literate programming and in some senses need to be balanced as a step in the learning process for iteracy. This is not to say it isn’t useful as a stepping stone to building software systmes, indeed many of the methodologies in computer science are aimed at helping to reduce messy code and therefore the bugs associated with it ('spagetti code').
| |
| | |
| The point isn't that iteracy is used to define what is and isn't code, rather it is to highlight the way in which code has certain affordances towards repetition and iteration. That these structures are built into the background of the syntax of the programming language and the practices associated with programming. Additionally computer science itself is highly geared towards elegance and efficiency in writing algorithms and code and it is important for us to take account of that, even to critique or highlight counter-examples and anomalies in code.
| |
