Frequently Asked Questions - and Answers

Organizational questions

Can I participate in a project voting as an individual?

Yes. If you are only a single person without a team, vote as a "1-person team". Similarly you can vote in 2- 3- 4- 5- 6- an 7-person teams.

What happens next?

You will be merged with other individuals (teams) according to your project preferences.

I missed the registration deadline. Can I still get in?

Unfortunately, the registration is closed. We may be able to squeeze you in only if there is still space in one of the projects.

I passed the project part last edition of the course, but didn't attend/fail exams. Can I get the project credited for this year?


I missed the deadline. Can I still register for the course?

Unfortunately the registration is closed. We are massively overbooked, though, we may be able to squeeze you in only if there will be . Please dpor us a note and we will notify you about the decision by the beginning of the next week.

Questions about the exam

Can I bring a calculator?


Can I bring a cheat sheet?

A4 paper, one page (not an entire sheet! A sheet has two pages and you can have only one page filled!) written with a permanent writer (so pencils, among others, are disallowed).

Can I bring paper slides?


When and where the exam inspection will take place?

We will announce this at a later date.

What if I cannot attend the exam?

If you provide a proof you couldn't attend the exam (e.g. a certificate from a doctor) you will be allowed to write the re-exam as first exam and take an oral exam as the re-exam. If you won't have any proof, you will just miss the exam: you will be graded solely based on re-exam (which will be treated as your first exam) and you won't be allowed to take an oral exam.

Will a mock exam be available?

We won't prepare a new mock exam for this course edition. Please refer to the one from previous edition:

SE 2012 demo_exam.pdf

What will the exam encompass?

All lectures. Questions will be both multiple choice and open ended, checking if you can apply the taught concepts yourself. See the mock exam linked above to get an idea.

Questions about finalizing the project

Do we have to present our results to the course managers and/or professor?

Yes, by uploading all your source code, documentation and other development artifacts to your team's Redmine. We will take care of the rest.

How we will be graded?

Your team grade will be based on:
- the quality of final deliverables you have uploaded to Redmine;
- how happy is the customer with your team;
- the extend to which you used Redmine during the course;
- how well you worked during the course;
- the opinion of your tutor about your team.

The grade is being assigned by Prof. Zeller based on his review of the team Redmines and summaries and recommendations provided by the course managers, who in turn decide based on the information listed above.

In addition, if some team members were extraordinary good or bad, their grade might deviate from the grade of the team.

Will we be able to get a project extension?

Only in extreme circumstances beyond your control in which you were unable to work on the project for an extended amount of time. For example, the client was unresponsive or team progress was stalled due to critical team members being sick. In such cases you will get extension. To apply for such extension, you have to provide a small report explaining what were the circumstances beyond your control that made you ask for the extension and how long extension do you need. A small penalty to your project grading will be applied for getting the extension.

Questions about the UML diagrams

What is the motivation for having the UML Class and Sequence diagrams?

The UML diagrams you write are expected to be read by a new developer that will have to maintain your code. They are supposed to aid him in understanding the system. The developer is supposed to gain understanding of the high-level architecture and inter-component interactions in the system based on the diagrams, as opposed to trying to deduce them by looking at the source code. To further this end, the diagrams have to be precise and have to abstract away unimportant low-level details, so the inter-component interactions are clearly visible.

By saying they are precise we mean they accurately reflect what is actually happening in the source code. If you write in the sequence UML diagram "get recommendations" this is a natural language phrase that has no precise mapping to the source code and thus is too abstract. If you instead write the actual method call "getRecommendations(String: userId)" then you are being precise. The exception is user (actor) interaction with the system. Do not write artificial "click_load_button()" if you just want to denote that the user clicks on the button labeled "load". Instead, write "clicks the "load" button". However, if user types in commands in the command line, be precise: give the exact commands the user has to type in.

For an example scenario, imagine the following: you wrote an app with a GUI that allows to load an image from the disk and apply a transformation to it that makes it black & white. If now a developer wants to answer the question "where is the code that actually transforms the image?" if he would not have the UML diagrams, she has to guess what is happening based on the method names and manually follow the execution flow of the code until she finds what she needs. However, with a sequence diagram covering the use case of "loading and making a picture black and white" the developer should be able to take a look at it and clearly see what is happening in the system: first the user (actor) starts the app, then clicks the "load" button, some logic gets executed (which is modeled on the diagram if it includes multiple components interacting with each other), then the user clicks the "transform to black & white" button and some other logic gets executed. All of this is modeled on the sequence diagram. The developer sees clearly from the diagram where is the logic doing the transformation and can easily locate the actual source code based on this information.

The diagram our student team prepared has a lot of uninteresting details not really helping in the system understanding, e.g. GUI layout definition. What should be done about it?

As the diagrams are supposed to aid the developer in high-level understanding of the system (see previous question and answer). Any complex, long, obscure diagrams are obviously pointless. If there is a lot of boilerplate or boring code, like definitions of the layouts of buttons of the GUI, then you can just model them as one "GUI" entity on the diagrams. Concentrate on nontrivial and interesting logic.

The implementation our student team is implementing is composed of many components that interact with environment, 3rd party components, dependencies, etc. Which of those should we model in the diagrams?

You should model interactions between major components of your application as well as how your application interacts with its dependencies (3rd party components/libraries) and the environment. You should not model interactions within the components you have not implemented: they are blackboxes to you. You also shouldn't model interactions with the environment that are too common. For example, you obviously won't model each call to "Console.out" or "println" because they would pollute the diagrams with irrelevant details, masking the high-level architecture you are trying to show. Use your judgement which amount of detail is enough but remember to be precise as stated in the answer to the first question.

There is no notion of the object-oriented "Class" in the language our student team is using or it is heavily discouraged, yet UML Class diagram requires Classes. How to write the diagram then?

Then use an equivalent. For example, if you are programming in Python and you have a very good reason not to use its Classes (e.g. because client forbid you to, or their usage would result in a boilerplate code) then use Python's Modules and model them as Classes substitutes in the UML Class diagram.

Sometimes you might run into more exotic cases. For example, you might have a statically-obtainable map from Strings to Closures named PreprocessorProvider that returns different Preprocessor (a Closure taking an image and returning a preprocessed image). if such map is an important part of the high-level architecture, you might model it as a class, but you should make it clear it is a map from String to Closures returning images and make it clear which Strings actually point out to different Closures. To understand how to do it, read the answer to the question below.

There is no easy way to show explicit types in the language our student team is using, yet the UML diagrams require them. How to write the diagrams then?

Then adopt some notation allowing you to show a type or use a variable and/or method naming convention. For example, methods named "getType" might always return object of class Type. This is de facto a kind of extension to the UML to accommodate for the dynamic/type-less nature of the modern languages. Please give a brief explanation of the notation you adopted at the top of your UML diagram.