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ä: Vaihda suomeksi.
Learning Objectives in O1
Programming 1 a.k.a. O1 is an introductory programming course. After you complete O1, we hope that you can mean it when you say:
- Computer programming is a meaningful and fun thing to do.
- I know the basics of computer programming.
After O1, you should be able to write small application programs of your own. You should also be able to read and modify programs — even somewhat bigger ones — written by others. Moreover, you should have an understanding of various fundamental programming concepts that will help you develop your programming skills further, whether in the follow-on courses at Aalto or independently.
We use the Scala programming language as a tool, but most of what you learn in O1 is applicable when programming in other languages, too.
We’ve tried to design O1’s grading policy (Chapter 1.1) so that a grade of one means you’ve reached the minimum requirements for passing, a grade of three roughly corresponds to what you need to know to succeed in follow-on courses, and a grade of five indicates a still better level of achievement.
By the time you finish O1, you ought to have the following basic skills at the very least.
- You understand many key concepts of computer programming,
especially those associated with imperative-style
object-oriented programming: program code,
variable, class, object, method, reference, data type,
parameter, return value, expression, collections
(e.g.., buffer or vector) and basic methods for processing
filter), selection (e.g.,
if), iteration with loops,
- You are prepared for learning more from materials that feature those concepts and terms.
- You can apply the programming concepts as you read and write programs.
- You can read programs (written in Scala) that consist of several interacting classes. You can analyze what given programs do, at least if the programs are no more than about a hundred lines of code long and don’t feature demanding algorithms or exotic language constructs.
- You can implement classes (in Scala), assuming that you are given a specification that defines the classes’ public interfaces In other words, you can implement the instance variables and methods of a specified class. You can write such implementations from scratch as well as edit a given program so that it meets a specification.
- You are familiar with some of the main activities of a programmer, such as reading a specification, writing code, and testing. You are capable of using tools that support the programmer (especially: you know how to use an IDE).
- You have at least a rudimentary understanding of what a computer does as it runs a program. You have an understanding of objects being created and initialized in memory. You have a sense of the role of the call stack in controlling how a program run unfolds.
- You know what a software library is. You can read the given documentation of a library and use tools from a library in your programs.
- You understand that good programming style matters. You can format your code so that it’s easy for a human to read and understand.
- You have at least a rudimentary understanding of how a graphical user interface works in combination with the rest of an application. You have used a library for implementing simple GUIs.
What You’ll Also Need in Follow-On Courses
The minimum requirements alone aren’t enough if you intend to continue on to other courses at Aalto or if you develop a hunger to learn more about programming (as we expect). The spring courses Programming 2 and Programming Studio 2, for instance, expect that you know more than what was listed above. All students that plan to take those courses should aim for these objectives, too:
- You know what a compiler and a virtual machine are, and what bytecode and machine language are.
- You know a number of programming techniques associated with
functional programming and thus have a platform for learning
more about that programming paradigm. In particular:
- You are accustomed to working with immutable objects, including immutable collections.
- You have gained some practice on using
common higher-order methods (such as
filter). You can make use of anonymous functions as you use these methods.
- You understand the concepts of inheritance and traits. You can apply these techniques, too, as you read programs and as you implement programs to a specification.
- You know several ways to store multiple elements in a collection (e.g., vectors, buffers, streams, maps). At least in simple cases, you can pick a collection type that suits the program at hand.
- You have some practice on reading and editing somewhat larger programs. These programs may consist of up to hundreds of lines of code or a dozen or so classes and may feature algorithms that are somewhat more challenging.
- You have at least a rudimentary appreciation of various criteria for software quality. For instance, you have seen examples of how the programmer’s decisions impact on the modifiability and efficiency of a program. (You may still not, however, be skilled in writing programs that are particularly modifiable or efficient.) You understand what refactoring is.
What Else Is on Offer?
There’s a lot more that you can learn in O1. Here are some examples of learning objectives that you may go for (and that may boost your grade); below is just a small selection of topics from the optional sections in the ebook.
- You have tried designing a program without being given a detailed specification of what each of its components (classes and methods) needs to do. You have implemented a program of your own design.
- You can tell if a given program or program component is typical of
- the imperative or the functional style of programming. You are aware of some of the benefits attributed to these programming paradigms.
- You understand the concept of recursion and have seen examples of recursively defined data and recursive method implementations. You can implement a simple recursive class or method.
- You can use a debugger for examining a program and locating errors.
- You can use API functions to implement a program that reads and/or writes (text) files.
- You have at least an inkling of how a program may operate on other programs and how a programming language may be used for implementing another language.
Thousands of students have given feedback that has contributed to this ebook’s design. Thank you!
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 automatic assessment of the assignments has been developed by: (in alphabetical order) Riku Autio, Nikolas Drosdek, Joonatan Honkamaa, Jaakko Kantojärvi, Niklas Kröger, Teemu Lehtinen, Strasdosky Otewa, 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 toolkits.
The other diagrams and interactive presentations in the ebook are by Juha Sorva.
The pedagogy behind O1Library’s tools for simple graphical programming (such as
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.
Additional credits appear at the ends of some chapters.