Video Tutorials: CAS-AI (original) (raw)

DISCLAIMER

THIS IS NOT AN OFFICIAL DOCUMENT OF THE UNIVERSITY OF BIRMINGHAM OR THE SCHOOL OF COMPUTER SCIENCE.
NEITHER THE UNIVERSITY NOR THE SCHOOL HAS ENDORSED THE OPINIONS EXPRESSED HERE.

About 41 minutes.
Available at: http://youtu.be/PglYnQr85S8
The programs demonstrated in these videos all use parts of the Poplog system. In particular I have created several demonstrations using Pop11, the core language of the poplog system, and the editor Ved/XVed which is implemented in Pop11. This tutorial shows how to install 32-bit linux poplog version 15.65 (the latest version, assembled in December 2011) on a linux system.
The demonstration uses Fedora version 15, but the same procedure will work on other versions of linux including for example Ubuntu and Arch linux. There are slight differences in the preparation needed for different versions of linux, as pointed out in the video, and also in the installation instructions here:http://www.cs.bham.ac.uk/research/projects/poplog/v15.65/#installing.
**N.B.**Since the video was made, two simplified installation scripts have been provided, one for users of linux based on 'rpm' packages (e.g. Fedora, Redhat, Scientific Linux, CentOS) and one for users of linux based on 'deb' packages (e.g. Debian, Ubuntu, and some others). Those scripts simplify the installation, as just one script has to be downloaded, made executable and run. The methods shown in the video will work on other versions of linux.
Script for Ubuntu and other systems using 'apt-get install':Fetch and install 32-bit Poplog on Ubuntu
Script for Fedora and other systems using 'yum install':Fetch and install 32-bit Poplog on Fedora
The installation process requires some preparation of the linux system to ensure that it has the graphical libraries and also the usual compiling and linking tools (gcc). A shell script can be downloaded that will check whether you have the required graphical libraries.
Then, to do the actual installation, a short shell scripthttp://www.cs.bham.ac.uk/research/projects/poplog/v15.65/get-and-install-v15.65-poplogcan be downloaded, and made executable and then run. This is all done automatically in the new scripts for rpm and deb package users mentioned above.
**NOTE:**In the video all the installation commands are given without using the 'sudo COMMAND' format normally required when altering protected files or directories. That is because I had previously given myself full read- and write-access to everything in the /usr/local directory, using this command as super-user:
chown -R XXX /usr/local
replacing XXX with my login name on the machine. If you don't want to do that, you can either prefix all the installation commands with 'sudo', or first become super-user, e.g. 'sudo su'. Then all installed files will be owned by the super-user and only super-user can change them. (There are useful online tutorials on linux/unix giving more information, e.g.http://linuxcommand.org/lts0070.php)
When the 'get-and-install-v15.65-poplog' script is run, it fetches a compressed 'tar' file (size about 16.5MB), as shown in the video, and also fetches another shell script to install the contents of the tar file. The video shows what the installation process looks like, and how fast it goes (especially when using a 30Mb/sec cable broadband connection to do the download). On a slower internet link, and a slower PC than the one I used the process would take longer, but on modern machines it should be at most a minute or two. It unpacks the tar file into a new directory at the default location /usr/local/poplog (though you can change that) and after re-linking the core of poplog, and building saved images to run Pop11, the editor, Common Lisp, Prolog, and Standard ML it ends up using less than 80MB for the whole installation.
Quite a lot of that can be deleted if you don't want all the four languages and if you don't want to be able to look at the system source code.
The tutorial then shows how some demonstrations that are scripted in the directory /usr/local/poplog/current-poplog/bin/demos can be run to test the installation. In the video, I demonstrate the Pop-11 eliza chatbot, with and without audio output, then a toy simulation of some simple 'emotional' agents (not really emotional) moving around and reacting to what happens to them. I also show how some of David Young's popvision system can be run to do image processing using tutorials supplied in the popvision library whose files are also available for browsing here:http://www.cs.bham.ac.uk/research/projects/poplog/popvision/
The tutorial ends by showing how, in addition to the saved images created to support the different poplog languages a shell script provided can be used to create another little demonstration of a very simple interactive simulated conversational robot inspired by the work of Terry Winograd on his SHRDLU system around 1971. The pop11 version is simpler than Shrdlu mainly because its natural language capabilities are very much simpler, but also because the world it talks about is simpler.)
All the demos shown (and many more) are implemented using programs that students or teachers can copy and edit in order to produce new versions with different capabilities. Some of them can be used by novices (e.g. starting with a very simple chatbot) whereas others will stretch advanced students, e.g. the Shrdlu example. With a development environment like Poplog it is possible for the teacher to isolate a small part of a complex package and invite students to modify or extend that small part, while using the rest as a 'black box', defining an experimental 'microworld', as a rewarding and challenging learning experience. (For an example see theriverworld tutorial below.)
**NOTE:**Supplying poplog using a tar file and an install script, rather than a typical linux package (e.g. deb or rpm), gives the user a lot of choice as to where and how it will be installed, compared with installation using a standard linux package in Ubuntu, Fedora, etc. It also allows the same system to be installed in two (or more) different places, so that one is for regular use while experimenting with modifying or extending another version.
Please send comments and questions to Aaron Sloman at Birmingham (preferably using normal email not social web sites).
The poplog system, used for this tutorial is described with examples of teaching materials here:http://www.cs.bham.ac.uk/research/projects/poplog/examples/
NOTE: because these tutorials are unscripted, they include errors and moments of confusion!
Uploaded: 27 Dec 2011

Available at:http://www.youtube.com/watch?v=y1syZ-Sl8ZY
Jump to CONTENTS List

Available at:http://www.youtube.com/watch?v=j0oaK59SSM0
This is a sequel to my previous tutorial (pop-espeak).
The code examples in this video can be found here:
http://www.cs.bham.ac.uk/research/projects/poplog/teach/haiku-examples.txt
There are many more examples of the kinds of things that can be done in Pop11 (especially "thinky programming" examples) in this file
http://www.cs.bham.ac.uk/research/projects/poplog/examples/
People who are not familiar with the idea of a grammar, as used here, may find this short tutorial by 'drewmfisher' on the idea of a grammar useful:
https://www.youtube.com/channel/UCZ3sx1PFJ6ImyqwC9RRb8JA
Anyone familiar with search engines may be able to find additional introductory presentations on grammars. A 'teach' file that can be used with pop11 in Poplog is here:
http://www.cs.bham.ac.uk/research/projects/poplog/teach/grammar
This is part of a planned series of video tutorials introducing some of the features of Pop-11, an AI programming language (part of the Poplog system).
More information about the language and its environment, and ways in which AI programming is relevant to science and philosophy as well as engineering, can be found here
http://www.cs.bham.ac.uk/research/projects/poplog/examples
http://www.cs.bham.ac.uk/research/projects/poplog/cas-ai/
I am not an expert pod-caster, so there will be many flaws. I hope to learn from experience and from feedback from users.
I am contributing this as part of the UK ComputingAtSchool (CAS) initiative, described here:
www.computingatschool.org.uk
Uploaded: 15 Nov 2011;
Modified 11 Dec 2011; 14 Oct 2015
Jump to CONTENTS List

Available at:http://www.youtube.com/watch?v=9TAQoRpvLFE
This is a sequel to my previous tutorial (pop-espeak2.ogv)
This is part of a planned series of video tutorials introducing some of the features of Pop-11, an AI programming language (part of the Poplog system).
Unlike the previous tutorials this one makes use of Poprulebase, an extension to Pop11 designed for construction of rule-based systems and used in the SimAgent toolkit.
This tutorial does not claim to show how to model what goes on in the mind of a child learning about numbers but does aim to show how one's scientific understanding of the nature of the process can be enhanced by trying to build models of various aspects of the competences. This could help to guide both experimental and modelling research investigating how the learning and development processes occur in children. It could also be a precursor to the design of future robots with human-like intelligence (still a very long way to go). The tutorial uses some of the ideas in Chapter 8 of "The Computer Revolution in Philosophy" (1978).http://www.cs.bham.ac.uk/research/projects/cogaff/crp/chap8.html
"On learning about numbers: Problems and Speculations" The chapter (like the whole book) is on-line.
I also believe that using computers to model some of the processes by which animals reason and human children acquire and extend their mathematical knowledge and competence is relevant to Philosophy of mathematics as illustrated in these talks:http://www.cs.bham.ac.uk/research/projects/cogaff/talks/
The demo uses a text file including comments and code, end ends with some suggestions for project work extending the demo in various ways. The text file is available online here:http://www.cs.bham.ac.uk/research/projects/poplog/teach/number-rulebase.txt
Since this video was made several of the rules in that file have had comments added to the code.
The video was unscripted and there are at least two mistakes in portions of the presentation relating the program's demonstrated behaviour to the code. One mistake was to use a version of the code that included an unnecessary local variable. Another mistake was to choose the wrong rule to illustrate how one of the replies had been generated, because there are a number of slightly different rules.
More information about the Pop11 language and its environment, and ways in which AI programming is relevant to science and philosophy as well as engineering, can be found herehttp://www.cs.bham.ac.uk/research/projects/poplog/cas-ai/
The original tutorial recordings are hosted here (in .ogv format):http://www.cs.bham.ac.uk/research/projects/cogaff/tutorials
I am not an expert pod-caster, so there will be many flaws. I hope to learn from experience and from feedback from users.
I am contributing this as part of the UK ComputingAtSchool (CAS) initiative, described here:www.computingatschool.org.uk
Uploaded: 25 Nov 2011
Jump to CONTENTS List

Available at:http://www.youtube.com/watch?v=jsCINKXK6ek
This tutorial makes use of a pop11 teach file available herehttp://www.cs.bham.ac.uk/research/projects/poplog/teach/random_walkto demonstrate some features of the 2-D graphical libraries available in Pop11, as well as the use of the Poplog editor Ved as an interactive learning, programming, testing and demonstration tool.
The tutorial introduces a small subset of the RCLIB extension to Pop11, providing a 'Relative Coordinates' graphical package, which allows the frame of reference to be altered (e.g. moved, stretched or rotated) so that the same graphical command has different effects. However that feature is not demonstrated here.
Instead the tutorial shows how an existing library program can be used to draw very simple faces with different expressions (e.g. happy, sad) and different colours, simply using circular blobs. The details, which are not explained or demonstrated in the tutorial can all be found in the file:http://www.cs.bham.ac.uk/research/projects/poplog/teach/faces
A learner trying various parameters for the face-drawing procedures should be able to work out what the parameters do, as part of learning how coordinates work.
After that introduction the tutorial shows how Pop11 and its graphical command rc_drawby(X, Y), which draws to a location specified relative to the previous location, can be used to explore different sorts of random walk. For example, this command randomly selects one element from a four-element list of pairs of coordinates to be given to rc_draw_by:
rc_drawby( explode( oneof( [ [20 20] [-20 20] [-20 -20] [20 -20] ] ) ) );
The key features of a random walk are demonstrated manually, and then put together in a little procedure that allows various kinds of random walk to be demonstrated and displayed graphically. This shows how, by playing with such a program, a learner can begin to get an intuitive feeling for the ways in which random walks can vary.
The tutorial ends by mentioning that the program can be extended to collect different sorts of statistics about the random walks, which could be used as input for the Pop11RC_GRAPHPLOTlibrary, which draws graphs of mathematical functions or, of empirical data.
So although Pop11 was designed for teaching and research in Artificial Intelligence (and cognitive science) it can also be used as a tool for doing research in mathematics, especially gaining an intuitive understanding of some features of a mathematical domain.
The talk was unscripted and may have a number of errors. One that I've noticed is that on more than one occasion I referred to a delay as one second rather than one hundredth of a second (the unit for the syssleep function).
There may be problems of synchronisation of voice and video because the recording was done with some compression, to save file space and download time. I use 'recordmydesktop' on linux (Fedora 15) on a desktop PC. Youtube kindly converts the .ogv format to flash. The original version is available, with other .ogv files, here:http://www.cs.bham.ac.uk/research/projects/cogaff/tutorials/
Please email comments and suggestions to mehttp://www.cs.bham.ac.uk/~axs/
Originally Uploaded: 1 Dec 2011. Revised version: 6 May 2012
Jump to CONTENTS List

Old Version (installed Dec 2011)
Available at:http://youtu.be/RvpK7RgWmoE
This is one of a collection of tutorials demonstrating Pop11, a language with some of the features of Lisp, Scheme, and Prolog, developed for teaching and research in AI and Cognitive Science.
This unscripted tutorial turned out longer than intended. It is based on this file, showing the program text demonstrated in the tutorialhttp://www.cs.bham.ac.uk/research/projects/poplog/teach/match_sorted
Most people think of pattern matching as an operation performed on strings (e.g. 'grep' in unix/linux). The matching here is on structures, including lists of items, lists of lists, etc. So the functions of matching in this context can be thought of as searching in and extracting information from a database of knowledge rather than finding and manipulating bits of text.
Because the tutorial was unscripted there are some bloopers -- e.g. where I temporarily switched my brain into the wrong context -- e.g. attempting to trace "matches" in an example that used "doesmatch", not "matches".
The tutorial presents a fairly standard recursive algorithm for checking whether a list of numbers is sorted, then shows how that can be replaced by a non-recursive definition using the pop11 pattern matcher, which allows you to specify a sort of abstract picture of what is not allowed in a sorted list. The pop11 matcher compares that picture with an input list, and if it matches, the list is not sorted.
This naive use of the matcher is shown to work, but with considerable inefficiency. So a Pop11 library is compiled which allows, instead of the format
DATUM matches PATTERN
the format
DATUM doesmatch PATTERN where CONDITION
Using the second format, the pictorial specification of what a non-sorted list is like is somewhat clearer and its use is also much more efficient, since the search for an unsorted fragment of the list is more controlled.
The tutorial then shows how the procedure can be generalised to test a variety of types of list, including lists with mixed types of components (e.g. words and numbers) by allowing the test for unordered elements instead of being frozen in the code to be passed as a second parameter to the procedure. Then by using the same procedure with different 'unordered' tests we can produce a variety of tests for different kinds of ordering, all using the same generic procedure.
Finally the tutorial shows how the generic procedure can be partially applied to different specific tests (forming Pop11 closures) to create different procedures, testing for different things.
In retrospect I think the example may be confusing for some viewers because the task of checking whether a list satisfies a condition (e.g. containing numbers in ascending order) requires using a test that indicates a failure to satisfy that condition, e.g. a test for an adjacent pair of numbers being in descending order. That implies that a true result for the test implies a false result for the main procedure. This complexity is a consequence of the example shown being for something being true of ALL parts of a list, which is equivalent to non-existence of ANY part of the list for which it is not true. Some human brains find this hard to grasp.
The process of generalisation or abstraction from a few examples of testing a list, then creating a new "generic" version of the test, by abstraction, which can then be instantiated to produce new examples, illustrates the ability of humans to learn different competences, then discover that those competences share some structure, and then use the shared structure with additional parameters to cope with novel situations.
That is a common process in mathematical discovery and in becoming more competent at programming. It is often confused with metaphorical thinking (which requires continued reference to the original examples, whereas abstraction does not).
I think it is an example of the notion of "Representational Redescription" presented by Annette Karmiloff-Smith in her 1992 book "Beyond modularity". Implementing representational redescription in a program is an ambitious task for Artificial Intelligence. This tutorial does not go into that.
Uploaded: 3 Dec 2011
Jump to CONTENTS List

Available at:http://www.youtube.com/watch?v=xfGv9xfqDxU
About 7.5 minutes.
Originally this was a 19 minute demo, illustrating some features of Pop11, then going on to present the Riverworld tutorial. Instead that is now done in a separate video http://youtu.be/RrT9DUyg88M. This tutorial has been shrunk to the first 7.5 minutes of the original.
This video is now a (mostly unscripted) tutorial presentation of some of the arithmetical and list processing facilities in Pop11, and the interactive mode of developing and testing programs, using the poplog editor as a development tool.
A feature of this and other pop11 tutorials is that it can be used on very low cost interfaces, since it uses only a textual display to paint schematic one-dimensional pictures of the state of the world as it changes.
Among the many tutorial files teaching aspects of Pop11 and AI that are included in the Poplog system, one that has been found very useful for teaching absolute beginners some of the key ideas of programming, including sequences of instructions, grouping of instructions into named procedures, procedures with input parameters, and the use of error messages is the TEACH RIVER file,log/t based on an earlier version by Max Clowes around 1978, now online here:http://www.cs.bham.ac.uk/research/projects/poplog/teach/river
The mechanisms used in that file are built on lower level abilities of pop11 including list processing mechanisms. This teach file is an introduction to a small subset of the more primitive mechanisms in pop11.
This video is an unscripted tutorial presentation of some of the arithmetical and list processing facilities and the interactive mode of developing and testing programs, using the poplog editor as a development tool.
A feature of this tutorial is that it can be used on very low cost interfaces, since it uses only a textual display to paint schematic one-dimensional pictures of the state of the world as it changes.
Aaron Sloman
http://www.cs.bham.ac.uk/~axs/
School of Computer Science,
University of Birmingham, UK
Uploaded: 11 Dec 2011, Modified: 10 Jan 2012
Jump to CONTENTS List

An earlier version of this tutorial wasted about a minute on a presentation error. That version is no longer available, so please don't save links to it.
Available at:http://youtu.be/M-NPoGCb0q8
About 55 Minutes
A separate tutorial fileRiverworld in Pop11: introduction to programmingalso listed below, demonstrates how a micro-world involving a man, fox, chicken and grain with a boat that holds two items and a river to cross could get across the river, subject to the constraints that the boat can hold only the man and one other item at a time, and the fox should never be left on a bank with the chicken if the man is not there, and the chicken should not be left alone with the grain if the man is not there.
That tutorial demonstrates that the river-crossing microworld could be used to teach absolute beginners some of the elementary aspects of programming, in an intuitive setting.
In contrast, this new unscripted tutorial (http://youtu.be/M-NPoGCb0q8) aims at showing teachers how to create such a microworld using features in Pop11 that allow programs to create, interrogate and alter a simple database, implemented as a list of lists. Procedures can be written that simulate perceiving the state of the world and acting on the world, and some of the manipulation procedures can be used to encode the causal laws and constraints of the world.
Such a world can then be used in a variety of contexts for student exercises, e.g. natural language interaction relating to the world, planning, problem solving, reasoning, etc. The tutorial is merely an introduction. There are many directions that can be taken, depending on the educational goals, the background and interests of the students and their abilities.
The poplog system, used for this tutorial is described with examples of teaching materials here:http://www.cs.bham.ac.uk/research/projects/poplog/examples/
NOTE: because this tutorial was unscripted, I made some minor errors wasted about a minute in the original version. I later was able to edit it on Fedora 15 using PiTiVi, to remove the unwanted episode. So a new version has been uploaded. Youtube does not allow an old faulty video to be replaced, so the new version had to go to a different location.
Uploaded: Original version 11 Dec 2011; Revised version 13 dec 2011
Jump to CONTENTS List * #### River Teach Using the river-crossing microworld to learn programming and AI -- first steps (river-teach.ogv)
Available at: http://youtu.be/RrT9DUyg88M
About 40 minutes.
Among the many tutorial files teaching aspects of Pop11 and AI that are included in the Poplog system, one that has been found very useful for teaching absolute beginners some of the key ideas of programming, including sequences of instructions, grouping of instructions into named procedures, procedures with input parameters, and the use of error messages is the TEACH RIVER file, based on an earlier version by Max Clowes around 1978, now online here: http://www.cs.bham.ac.uk/research/projects/poplog/teach/river
This video is a tutorial presentation of some of the key ideas in that teach file, while also introducing the use of the poplog editor Ved as a programming environment, and some of the ways of using pop11 for interactive programming.
This teach file introduces the river-crossing puzzle: get man, fox, chicken, and grain, across a river using a boat that can old only the man and one other item, without ever leaving the fox with the chicken, or the chicken with the grain, on a bank without the man present to prevent a vulnerable item from being eaten. Students are first asked to work out a solution away from the computer and then they try to express their solution using a specially developed 'micro-language' for the river world, with commands like putin(fox), takeout(chicken), getin(), getout(), crossriver(). When a sequence of instructions solving the problem has been found it can be made much shorter and clearer by defining new procedures for invoking frequently used sequences of instructions.
A feature of this tutorial is that it can be used on very low cost interfaces, since it uses only a textual display to paint schematic one-dimensional pictures of the state of the world as it changes.
Teachers can, of course, copy and edit the library program, the teach files, or other files that are used by this one, or which build on it.
Several other teach files in the Pop11 library develop this micro-world, e.g. by allowing students to design their own implementation for the world representation and the actions that change the world, or by adding a chatbot-like natural language interface to the program, or by using the poprulebase system (for rule-based programming) to get the computer to find a sequence of moves that solves the problem, using breadth first or depth first search. for example the addition of a natural language interface is the subject of this teach file http://www.cs.bham.ac.uk/research/projects/poplog/teach/riverchat
This illustrates the use of microworlds for teaching important concepts and techniques, especially in symbolic Artificial Intelligence.
This is one of several tutorials based on the river world. An earlier tutorial showed how a teacher could use the list processing and pattern-matching features of pop11 to set up a microworld like the riverworld, which could the be used as a basis for a number of different learning scenarios for beginner or more advanced programmers.
The poplog system, used for this tutorial is described with examples of teaching materials here:http://www.cs.bham.ac.uk/research/projects/poplog/examples/
NOTE: because these tutorials are unscripted, they include errors and moments of confusion!
Uploaded: 10 Jan 2012

Jump to CONTENTS List

About 62 minutes.
Available at: http://youtu.be/oFq1s2ul-Jw
(Replaces this one http://youtu.be/oFq1s2ul-Jw
Please do not save links to the older version.)
Pop11 is an AI language with a general purpose-core that is in some ways like Scheme, in other ways like Forth (use of an open stack).
This tutorial demonstrates some of the main "built-in" data-types (integers, decimals, complex/imaginary numbers, strings, words, lists, vectors, properties and procedures), some of the kinds of programming constructs, for referring to entities (expression formats), including expressions for referring to or constructing examples of all the above entities, the use of the poplog open stack, and some of the control constructs provided, including use of nested loops vs use of parallel loops. The latter is an unusual, but very useful feature.
Nested loops can be used for doing something to all possible combinations of items from several different lists.
Parallel loops repeatedly do something to a group of items, one selected from each of several different lists, so that each list item is used only once. The loop stops after all members of the shortest list have been used.
> Two "nested" loops
>
> vars item1, item2;
>
> ;;; Outer loop iterates over items in list of words
> for item1 in [a b c d e] do
>
> ;;; Inner loop iterates over items in list of words
> for item2 in [1 2 3 4 5] do
>
> [^item1 ^item2 ]
>
> endfor
>
> endfor =>
>
> ;;; That prints out:
> ** [a 1] [a 2] [a 3] [a 4] [a 5] [b 1] [b 2] [b 3] [b 4] [b 5] [c 1] [c 2] [c 3] [c 4]
> [c 5] [d 1] [d 2] [d 3] [d 4] [d 5] [e 1] [e 2] [e 3] [e 4] [e 5]
>
>
> Two "parallel" loops
>
> vars item1, item2;
>
> ;;; One loop, with two loop variables, one iterating over a list of words
> ;;; the other iterating over a list of numbers:
>
> for item1, item2 in [a b c d e], [1 2 3 4 5] do
>
> [^item1 ^item2 ]
>
> endfor =>
;;; that prints out: ** [a 1] [b 2] [c 3] [d 4] [e 5]
See also HELP LOOPShttp://www.cs.bham.ac.uk/research/projects/poplog/help/loops
The Pop11 language used for this tutorial is described with a wider variety of examples of teaching materials here:
http://www.cs.bham.ac.uk/research/projects/poplog/examples/
A large amount of documentation is provided with the poplog system when downloaded. Some of the teaching documentation is also available online here:
http://www.cs.bham.ac.uk/research/projects/poplog/teach/
Uploaded: 24 Dec 2011; Revised version 25 Dec 2011

About 9.5 minutes.
Available at: http://youtu.be/Athf7cFbk3E
Most of the tutorials on this web site make use of the Poplog editor Ved, or its multi-window version XVed, to demonstrate features of AI programming, testing of programs, searching for documentation, editing program code, etc. This short video (just over 9 minutes) illustrates uses of Xved and Ved that invoke some of Pop11's 2-D graphics capabilities, including handling multiple text windows, using (user definable) graphical menus, and running programs that invoke graphical displays. It was originally intended as an introduction to a longer tutorial on the uses of the editor. However, it made the tutorial too long, so I separated this from the main tutorial which is the video that will be uploaded after this (Essentials of Ved, the Poplog Editor at: http://youtu.be/h8zv_un5k3k) andthe Ved Keys tutorial, below.
The video quality of this tutorial is very poor for some reason. So I may replace it later.
The next tutorial, will show the Ved editor being used in single window mode, and will present the most commonly used keyboard commands for getting things done.
The poplog system, used for this tutorial is described with examples of teaching materials here:http://www.cs.bham.ac.uk/research/projects/poplog/examples/
NOTE: because these tutorials are unscripted, they include errors and moments of confusion!
Uploaded: 16 Dec 2011
Jump to CONTENTS List

About 47 minutes.
Available at: http://youtu.be/h8zv_un5k3k
The previous tutorial (http://youtu.be/Athf7cFbk3E( rapidly ran through some of the things that can be done with the Poplog editor XVed, using its 2-D graphical capabilities. including use of multiple windows and mouse drive menu panels. This tutorial goes to the opposite extreme to show how Ved can be used not only without 2-D graphics, but also without any function keys, so that it has to be driven only by normal alphanumeric keyboard keys, along with CTRL, ESC, RETURN, and Backspace.
This situation can arise when either there is something wrong with a keyboard, or the keyboard is small and lacks function keys (e.g. on a laptop), or the use of the function keys is not available to Ved because they are 'grabbed' by the operating system or graphical desktop interface.
In such a situation it is possible to drive Ved and do normal programming, development, testing, and reading of documentation, using only a minimal set of keyboard keys, namely all the alphanumeric keys plus the CTRL and ESC keys.
This tutorial explains how to move the Ved cursor around, how to delete text, how to mark portions of a file, how to mark and compile portions of a file, and how to switch between different files, while using nothing but the minimal set of keyboard keys. There are other help files that explain additional actions that can be performed using the keyboard, and without a mouse or 2-D graphical facilities.
The 'teach file' used for this tutorial is available as part of poplog, and also available online here:
http://www.cs.bham.ac.uk/research/projects/poplog/teach/essentialkeys
NOTE: because these tutorials are unscripted, they include some minor errors and moments of confusion!
For additional tutorials seehttp://www.cs.bham.ac.uk/research/projects/poplog/cas-ai/vid.html
Uploaded: 16 Dec 2011
Jump to CONTENTS List

About 35 minutes.
Available at:http://youtu.be/vXpjnqzTZIU
The previous tutorial demonstrated some of the things that can be done with the Poplog editor Ved/XVed without using any function keys, only normal keyboard keys and the ESC and CTRL keys. This tutorial goes beyond that to show how many of the operations can be performed more economically using function keys on a standard PC keyboard.
The keyboard layout is shown in this diagram
vedkeys
Near the end of the tutorial I tried to demonstrate the use of the numeric keypad to compile a marked range, but forgot to precede the key with ESC. So instead of compiling the whole range it compiled only the last line of the marked range, and reported a syntax error, because it found the 'endrepeat' syntax word without first finding the 'repeat'. If I had pressed ESC first, the demonstration would have worked, as you can confirm if you have poplog. (The correct behaviour is demonstrated in the next tutorialhttp://youtu.be/giEhHIN8z6I)
In fact, as shown in the demo, the marked range can be compiled using CTRL D, which is probably more convenient for most people than ESC followed by keypad '*' key.
Uploaded: 21 Dec 2011
Jump to CONTENTS List

About 9 minutes.
Available at:http://youtu.be/giEhHIN8z6I
In the previous tutorial, while demonstrating the use of numeric keypad keys in the poplog editor, I attempted to demonstrate the use of the '*' key on the keypad to compile a number of lines of Pop-11 code, which had previously been marked, using the Mark Start and Mark End function keys.
Unfortunately I forgot to press the ESC key before pressing the '*' key, so instead of compiling a range it attempted to compile only one line, and that line had 'endrepeat', which is not legal Pop11 unless preceded by 'repeat'. The result was an error message which, at the time, mystified me. See the last few minutes of this videohttp://youtu.be/vXpjnqzTZIU
Later I realised what I should have done, and so this tutorial is a supplement to the previous one, partly repeating the previous one and also correcting the mistake at the end of the previous one.
Uploaded: 21 Dec 2011