Design and Analysis of Information Systems (MAS)

1. Introduction

The “Design and Analysis of Information Systems” course is devoted to practising the skills that are necessary for transition from a conceptual model (the product of the analysis and requirements specification phase in software development life cycle) into a specific implementation environment, either object-oriented or relational. Students learn some conceptual features that have no direct counterparts in a chosen implementation environment (actually Java or MS C#). Some rules regarding designing (usability) and implementing user interfaces and utilization of software frameworks are also presented. The lectures are supported by the implementation including data management, application’s behaviour and creating simple GUIs. Requirement specification and static analysis should be done along with teaching the course “Object Modelling Techniques in Software Analysis” (PRI). The size of a project, that each student has to do on their own, is limited to between 10 and 15 UML classes.

• Schedule

• Mini-projects

Their goal is to test the understanding the practical ways to implement particular constructions of the conceptual model (classes, associations, an extent, etc.) and their cooperation with the relational model. In addition, they can be treated as a “cornerstone” of the final project (which later will be supplemented with other required elements, e. g. GUI). You need to implement various business constructs (all the technical information such as the number of objects in extent, setters / getters do not apply), which are present in the conceptual model. Every MP must contain examples of data and / or methods that illustrates its proper operation (localized in the main() method). Projects evaluation schedule – see attached classes schedule. During the evaluation you can expect questions about ongoing issues and implementation approaches. Your late mini projects can be evaluated during next classes, but it is associated with a 50% reduction in the score.

MP elements to be assessed1:

The topics of the MPx could be different from a topic of the final project.

¹ You should propose your own business cases, i. e. do not use examples from lectures, books, etc.

² Relational model (MR) is not applicable for students of Department of Information Management (WZI).

It is not allowed to combine different constructs in the same example, e.g. each kind of an attribute should have its own business example.

Mini-projects are an integral part of the final evaluation (see section 5.1). Thus they should be well prepared.

• The final project consists of two parts: a documentation and an implementation. Its topic should be complex enough to create the appropriate number (12 – 15) meaningful business classes. Because of this, topics like tool applications, system applications, media players, etc. are not suitable. If you have doubts you should consult the teacher.
  • Documentation
    • The documentation includes the “old” part, i. e. the one that has been created on the PRI class (included as an attachment) and the “new” documentation. The “new” documentation copies the “old” documentation scheme, but there are some new elements, which are mentioned below. Those who do not have the “old” project of the PRI must develop at least: requirements (as the “story”), the use case diagram and analytical class diagram.
    • Use cases: „New” documentation of use cases should include detailed description of one non-trivial use case in addition to “old” documentation. The use case should refer to another use case. The scenario for this use case should be made using both natural language and activity diagram.
    • User interface design: based on the selected non-trivial use case, user interface design should be made (according to the guidelines given in the lecture).
    • For selected use case a dynamic analysis should be performed (i.e., UML diagrams of activity, interaction and state should be provided). Dynamic analysis should be completed not only by the appearance of the methods in the class diagram, but also a discussion of its implications. “The effects” of the dynamic analysis (perhaps not only new methods, but also new attributes, new associations, etc.) should be placed on a class diagram redrawn from the “old” project and, where possible, highlighted with a different color. The project must use all the kinds of diagrams mentioned above.
    • Before the “final” class diagram, which forms the basis for implementation, it is necessary to include elements specifying the design decisions (for example, based on the relevant parts of the diagram), e.g. how to implement a class extent.
    • In summary, the “final” (design) class diagram differs from the diagram provided on the PRI in the following sections:
      • Has more details
      • All structures which do not exist in a given programming language are transformed (according to the design decisions)
      • Is supplemented with methods resulting from dynamic analysis
    • You should take care of the readability of the entire documentation, especially diagrams (some vector format is recommended, e. g. Enhanced Metafile). Hence, you should ensure that:
      • each of them is properly described/entitled,
      • diagrams are prepared in a suitable tool (e. g. UMLet),
      • you use fonts which are big enough (100% A4 view should be readable),

• layout is clear, e.g. draw inheritance as vertical lines and associations as horizontal ones, avoid crossing lines, etc.
  • Documentation should be delivered in a single PDF file (MAS_Group_Lastname_Firstname_StudentNo.pdf) sent to the email address of the teacher. Deadline – see the attached schedule.
  • A summary of the contents of the project documentation (PRI + MAS):
    • User requirements
    • The use case diagram
    • The class diagram – analytical
    • The class diagram – design
    • The scenario of selected use case (as text)
    • The activity diagram for picked use case
    • The state diagram for selected class
    • The interaction (sequence) diagram for selected use case
    • The GUI design
    • The discussion of design decisions and the effect of dynamic analysis
  • The evaluation of the documentation will be issued in accordance with the table below (prerequisite: meeting the requirements of paragraph 4.1):

• Implementation
  • The whole structure (all the classes with appropriate associations).
  • Methods required to implement the use case (or cases).
  • Elements of the graphical user interface (GUI), which are necessary to present a working implementation of the selected use case. Each project must have a GUI.
  • Minimum implementation of the GUI use case should involve an interaction of two classes connected with an association, for example: We have two

classes: an Employee and a Company; a widget (capable of showing many items, e.g. ListBox) contains a list of companies, after clicking on any item should cause display another widget (capable of showing many items, e.g. ListBox) which contains a list of its employees retrieved using a defined association. GUI implementation, which only creates connections between objects and does not allow for the above interaction, is not enough to pass the project. Similarly, solutions e.g. with a single widget, a TextBox or just filtering the extent are insufficient (instead of using a previously defined association).

• Pay attention to quality, ergonomics and usability of GUI (e.g., windows scaling, colors, philosophy of actions) – it is an important component of the final assessment. Design and implementation of GUI (you can use dedicated editors) shall be in accordance with the principles of usability, described at the lecture.
  • All data stored in the system must be persistent (e.g. file, database, dedicated library, etc.).
  • Implementation of the project will be individually evaluated during the exercises (see below). Therefore, it does not need to be send in any persistent form.
  • Language of the implementation can be Java, C# or C++. Other languages should be agreed with the teacher.
  • The grade for the implementation will be issued in accordance with the following table (prerequisite: meeting the requirements of Section. 4.2):

The final project does not have to include all constructs from mini-projects.

• Each project will be evaluated individually. During the evaluation, you can expect detailed questions about the way of the implementation, e. g. “What will be if…”, “Why it’s done this way…”, “Please make the following modifications…”. People who

implemented the projects personally should not have any problems with answering the above questions. Lack of ability to answer above questions will result in negative grade of the classes.

• The following aspects of the project will be evaluated (see also points Błąd! Nie można odnaleźć źródła odwołania., Błąd! Nie można odnaleźć źródła odwołania.):
  • The difficulty of the task.
  • The realized scope of the functionality.
  • The documentation of the code including the comments, that allows to automatically generate API documentation.
  • The elegance of implemented solutions, including the GUI ergonomics
• The credit of the exercises

Final evaluation of the exercise consists of the following components:

• 5.1.  Points for mini-projects (total sum – no need to individually classify each item): 20 + 20 + 20 + 16 + 24 = 100 pts.,
  • Evaluation of the project:
    • 5.2.1.      Grade for the implementation
    • 5.2.2.      Grade for the documentation

With each part (5.1, 5.2.1, 5.2.2) you must obtain a passing mark (50% or 3,0). Therefore, people, who for example pass MP, and does not pass the project will not pass the classes.

Additionally, you can earn up to 15 points for solving tasks described during lectures. These bonus points are added to the total number of points (see Para. 5.1), provided you have at least 50% of the points.

• Deadlines

Deadlines for the various tasks (mini-projects, final project documentation, and implementation of the final project) are given in the table (point 2). Exceeding deadlines will result serious reduction in the mark, including up to failing the exercises.

There is no possibility of passing exercises at the end of the semester, conditional on the exam, retake session, etc.

• The exam

MAS exam consists of two parts (total points are the foundation of the mark):

• Test. You should evaluate each of the questions (Y / N). Correct answer is 1 point., Incorrect -1 point., No response – 0 points.
  • Practical exercises. You should name and briefly discuss how to implement the given structure drawn on the attached conceptual class diagram.

There is no exemption from the exam.

• Free books on-line:
  • Bruce Eckel – Thinking in Java: http://www.mindview.net/Books/TIJ/
  • Allen B. Downey – How to Think Like a Computer Scientist: Java Version: http://www.greenteapress.com/thinkapjava/
  • Robert Sedgewick and Kevin Wayne – Introduction to Programming in Java: An Interdisciplinary Approach: http://introcs.cs.princeton.edu/home/
  • Implementation tools

Due to the fact that there is quite a large freedom to choose the technology of the project, there is no mandatory tools list. However, the following list contains tools, which can be useful:

• CASE tools (including diagramming editors):
  • UMLet (open source, multiplatform): https://www.umlet.com/
  • Visual Paradigm Community Edition: http://www.visual-paradigm.com,
  • ArgoUML: http://argouml.tigris.org/,
  • MagicDraw Community Edition: http://www.magicdraw.com,
  • StarUML: http://staruml.sourceforge.net/en/,
  • NetBeans for Java: http://www.netbeans.org/ (allows, for example, the creation of UML diagrams and source code generation)
  • MS Visio (ELMS license available for PJAIT students)
  • A comprehensive list of tools: http://en.wikipedia.org/wiki/List_of_UML_tools.
• IDE
  • IntelliJ IDEA (free Community): https://www.jetbrains.com/idea/
  • Eclipse for Java: http://www.eclipse.org/,
  • NetBeans for Java: http://www.netbeans.org/,
  • MS Visual Studio (ELMS license available for PJIIT students)
• GUI editors
  • Included in NetBeans;

• For           Eclipse:           Jigloo           SWT/Swing           GUI           Builder (http://www.cloudgarden.com/jigloo/);
  • For Eclipse: WindowBuilder Pro – free to use after the acquisition by Google (http://code.google.com/intl/pl/webtoolkit/tools/wbpro);
  • Included in MS Visual Studio.