Luet oppimateriaalin englanninkielistä versiota. Mainitsit kuitenkin taustakyselyssä
osaavasi suomea. Siksi suosittelemme, että käytät suomenkielistä versiota, joka on
testatumpi ja hieman laajempi ja muutenkin mukava.
Suomenkielinen materiaali kyllä esittelee englanninkielisetkin termit. Myös
suomenkielisessä materiaalissa käytetään ohjelmaprojektien koodissa englanninkielisiä
nimiä kurssin alkupään johdantoesimerkkejä lukuunottamatta.
Voit vaihtaa kieltä A+:n valikon yläreunassa olevasta painikkeesta. Tai tästä:
About This Page
Questions Answered: How can a program operate on other programs?
How could groups of virtual robots act in collaboration?
Topics: Another programming language as part of a computer
program; “virtual machines”. The stack collection type; implementing
a simple call stack. Additional practice on earlier topics.
What Will I Do? Study and extend a given program.
Rough Estimate of Workload:? Four hours? There actually
isn’t all that much code to write, but it will take time to understand
Points Available: C95.
Related Projects: RobotTribes (new), which depends on Robots.
Two robot tribes in mid-fight. The “Guardians” have settled in a
compact cluster. The “Tigers” are roaming for prey.
In this chapter, we’ll again pick up the theme of virtual robots and design some “robot
tribes” that do battle with each other.
Each robot tribe has its own program code, which specifies how the tribe’s members
behave. Each tribe’s code is written in a separate text file, which is not in Scala but
in a custom programming language called RoboSpeak. A RoboSpeak program consists of simple
commands that instruct the robots. For instance, the short RoboSpeak program below orders
robots to keep walking clockwise in a square pattern:
move # Moves the robot forward by one square.
spin # Turns the robot clockwise.
goto 1 # Returns to line 1 of this program.
The Scala app in project RobotTribes reads in RoboSpeak programs from text files, interprets
the RoboSpeak instructions therein, stores the instructions in memory as Scala objects, and
directs tribal robots accordingly. You can define new tribes simply by writing new files
of RoboSpeak; you don’t need to touch the Scala code for that.
In addition to following their tribe’s RoboSpeak program, tribal robots are always looking
to “hack” the members of other tribes, causing those competitors to join their tribe. As a
consequence, if you put two tribes in the same robot world, they’ll end up fighting for
survival as each tribe attempts to gain more members by converting the other. Once a tribe
gets the upper hand, the weaker tribe is often eliminated completely, as even its final
members defect to the winning side. You’ll see some examples of such tribal duels later.
This chapter revolves around the RobotTribes project. Once again, we’re going to give you
a version of the project that almost works but is missing some crucial pieces. The chapter
comprises a programming assignment in several parts, in which you’ll add those pieces.
Let’s start with an overview.
About the Robots project
The RobotTribes project depends on the Robots project of
Chapters 8.1, 8.2, and 8.3. If you don’t know it from Week 8,
go back there and read up on the project. You’ll need it here.
If you didn’t do the earlier assignments on Robots, do them now
or use the example solutions.
RobotTribes consists of two packages:
The table below lists the main contents of o1.robots.tribal.
Now’s a good time to try out some RoboSpeak programs.
If you call other methods from TribalBot
in talk, the method is quite simple to
If you first ask the robot world to list all
the robots in it, one of the collection methods
from Chapter 6.2 will give you a very simple
implementation for longRadar.
You can now try talk, enemiesnear, friendsnear, foddernear, fodderleft, score,
friendsdir, and enemiesdir in your RoboSpeak programs. These commands depend on the
implementations that you just wrote.
The RoboSpeak instructions callsub and return don’t work yet, but you’ll soon fix
that. First, though, you should read the Subprograms section in Tribe’s Scaladocs and answer the questions below.
set hackline 4
set hackline 1
iflt radar -3 22
set mem 4
set mem 8
In order to implement these methods, you’ll need to give each tribal bot its own call
stack. The bot can use the stack to track which subprogram calls are active and where it
should resume the program after a subprogram returns.
The TribalBots projects comes with a Frame class, which represents very simple call-stack
frames. Take a look.
In principle, you could represent the call stack as, say, a Buffer[Frame]. However, we’ll
instead go for a collection type that is specifically designed for representing stack-like
A call stack is a special case of the more generic concept of a stack (pino). A
stack is a collection that follows the LIFO principle: last in, first out. The
two main operations of a stack are:
The Scaladocs in RobotTribes describe a Stack class with these methods; read the
specification. There’s little in the way of
implementation yet, though; see Stack.scala.
Implement Stack. Use a private variable that refers to an auxiliary collection that
stores the stack’s contents. That auxiliary collection could be a buffer or a vector,
if you prefer, but we recommend that you consider the List type described below.
List is a widely used class that works well for this purpose and is a good addition
to your arsenal of collections in general.
A short introduction to Lists
A list (lista) is an immutable collection and, in that,
resembles a vector. Because of how they are implemented, lists
are efficient if you need to manipulate only the head of the
collection or if you need to traverse the elements only in order
from first to last. On the other hand, a list is probably a poor
choice if you intend to access arbitrary elements anywhere in the
collection (by their index, for instance).
In the Scala API, lists are available as scala.List.
Lists work much like other collections. Here’s one way to create a
val emptyList = List[Int]()emptyList: List[Int] = List()
var wordList = List("first", "second", "third")wordList: List[String] = List(first, second, third)
The familiar methods are available:
wordList.sizeres0: Int = 3
wordList.tailres1: List[String] = List(second, third)
wordList.map( _.length )res2: List[Int] = List(3, 4, 6)
The :: operator is specific to lists. It forms a new list that has
one additional element and is thus equivalent to the stream operator
#:: (Chapter 7.1) and the generic collection operator +: (Chapter 4.1).
wordList = "first-er" :: wordListwordList: List[String] = List(first-er, first, second, third)
It’s easy to implement a stack using a list: we’ll place the top element at the
head of the list and the bottom element at the rear end. All additions and
removals then affect the top of the stack, which is at the front of the list.
Lists are especially common in functional programming. Many Scala programmers use
them a lot. They will also play a significant part in Programming 2.
Class TribalBot already has a callStack variable with the type Stack[Frame]: a
stack that contains frame objects. The class doesn’t use the variable for anything,
Implement the methods callSubprogram and returnFromSubprogram. Use the callStack
variable for manipulating the stack.
You can then test your solution on the Patrolman tribe or a RoboSpeak program of your
A+ presents the exercise submission form here.
Further reading: domain-specific languages
RoboSpeak can be called a domain-specific language or DSL
(täsmäkieli). Look up the term. What are DSLs used for? Is RoboSpeak
an internal DSL or an external DSL? Could we say that the musical
strings that we pass to o1.play form a DSL?
Further reading: the collect method
shout uses a method named collect. Look up collect in the
Scala API and work out its purpose in shout.
Challenge: extend RoboSpeak
Please note that this section must be completed individually.
Even if you worked on this chapter with a pair, each of you should submit the form separately.
Time spent: (*) Required
Please estimate the total number of minutes you spent on this chapter (reading, assignments,
etc.). You don’t have to be exact, but if you can produce an estimate to within 15 minutes or
half an hour, that would be great.
Written comment or question:
You aren’t required to give written feedback. Nevertheless, please
do ask something, give feedback, or reflect on your learning!
(However, the right place to ask urgent questions about programs
that you’re currently working on isn’t this form but Piazza or the
lab sessions. We can’t guarantee that anyone will even see anything
you type here before the weekly deadline.)
Thousands of students have given feedback that has contributed to this ebook’s design.
Weeks 1 to 13 of the ebook, including the assignments and weekly bulletins, have been
written in Finnish and translated into English by Juha Sorva.
Weeks 14 to 20 are by Otto Seppälä. That part of the ebook isn’t available during the
fall term, but we’ll publish it when it’s time.
The appendices (glossary, Scala reference,
FAQ, etc.) are by Juha Sorva unless otherwise specified on the page.
The automatic assessment of the assignments has been programmed by Riku Autio, Jaakko
Kantojärvi, Teemu Lehtinen, Timi Seppälä, Teemu Sirkiä, and Aleksi Vartiainen.
The illustrations at the top of each chapter, and the similar drawings elsewhere in the
ebook, are the work of Christina Lassheikki.
The animations that detail the execution Scala programs have been designed by Juha Sorva and
Teemu Sirkiä. Teemu Sirkiä and Riku Autio have done the technical implementation, relying on
Teemu’s Jsvee and Kelmu
The other diagrams and interactive presentations in the ebook are by Juha Sorva.
The O1Library software
has been developed by Aleksi Lukkarinen and Juha Sorva. Several of its key components
are built upon Aleksi’s SMCL
The pedagogy of using tools from O1Library (such as Pic) for simple graphical programming
is inspired by the textbooks How to Design Programs by Flatt, Felleisen, Findler, and
Krishnamurthi and Picturing Programs by Stephen Bloch.
The course platform A+ has been created by
Aalto’s LeTech research group and is largely
developed by students. The current lead developer is Jaakko Kantojärvi; many other
students of computer science and information networks are also active on the project.
For O1’s current teaching staff, please see Chapter 1.1.
The notion of programmable “tribes” or “species” that fight each other on a grid comes
from a programming assignment by Nick Parlante.
Viljami Nurminen and Rune Pönni contributed additional commands to the RoboSpeak language,
drawing on student feedback.
wordListvariable’s old value with a reference to a new, longer list. You may find this notion useful as you implement