Unit GRAPHICAL USER INTERFACE AND MOBILE DEVICE PROGRAMMING
- Course
- Computer science and electronic engineering
- Study-unit Code
- 70A00087
- Curriculum
- Ingegneria informatica
- Teacher
- Luca Grilli
- Teachers
-
- Luca Grilli
- Hours
- 54 ore - Luca Grilli
- CFU
- 6
- Course Regulation
- Coorte 2024
- Offered
- 2025/26
- Learning activities
- Caratterizzante
- Area
- Ingegneria informatica
- Academic discipline
- ING-INF/05
- Type of study-unit
- Obbligatorio (Required)
- Type of learning activities
- Attività formativa monodisciplinare
- Language of instruction
- ITALIAN
- Contents
- Basic concepts of interactive graphic application programming. Programming of desktop applications using JFC/Swing technology (Java). Programming of native apps for Android. Analysis of simple case studies related to the development of video games for desktop and mobile.
- Reference texts
- The course covers many very recent topics related to technologies in constant evolution, which are not collected in a single textbook. For this reason, much of the course content is presented in the handouts prepared by the instructor.
However, some reference books, tutorials, and online documentation are recommended for further insights into the various topics covered.
Recommended books
Kathy Walrath, Mary Campione, Alison Huml, Sharon Zakhour. The JFC Swing Tutorial: A Guide to Constructing GUIs (2nd Edition), Addison-Wesley, 2004.
Dawn Griffiths, David Griffiths. Head First Android Development, 3rd Edition, O'Reilly, 2021.
Robert C. Martin. Clean Code: A Handbook of Agile Software Craftsmanship, Prentice Hall, 2008.
Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (the Gang Of Four). Design Patterns: Elements of Reusable Object-Oriented Software, Addison Wesley, 1994.
Online tutorials and official documentation
The Swing Tutorial - The Java™ Tutorials, Oracle Java.
JavaFX Documentation Project.
Android Developers - Training Courses.
Android Developers – Tutorials. - Educational objectives
- The main objective of the course is to provide students with the basic principles for the design and development of interactive graphic applications, both for desktop and mobile devices. The reference technologies adopted are the JFC/Swing framework for desktop applications, and Android Studio technology for native app development.
The key knowledge students will acquire includes:
• advanced programming techniques in Java and its APIs for managing 2D graphics;
• techniques for programming graphical interfaces for desktop applications.
• programming techniques for mobile apps (native), with particular emphasis on the Android ecosystem;
• basic elements of object-oriented modeling for an abstract problem or the real world;
• some fundamental design patterns for software design, such as Singleton and Model-View-Controller (MVC);
• main integrated development environments (IDEs) for the Java language and for native Android app development, specifically Eclipse, NetBeans, IntelliJ, and Android Studio.
The main skills students will acquire include:
• the ability to analyze an abstract or real-world problem and model it according to the principles of object-oriented modeling;
• the ability to identify issues during the modeling or implementation phase of a software system, and to devise effective and efficient solutions or, as a last resort, to foresee strategies to work around them;
• the ability to manage the entire software system development process following an iterative and evolutionary development model (agile).
• the ability to write a simple software project document;
• the ability to use integrated development environments (IDEs);
• the ability to consult various types of software documentation (tutorials, reference documentation) and interact with libraries, frameworks, and generic software systems developed by third parties. - Prerequisites
- Passing the “Computer Science Basis” exam is a prerequisite for this course. In fact, understanding the topics covered requires a solid knowledge of the fundamental concepts of object-oriented programming and the main constructs of the Java language. It is also important to be familiar with some advanced topics such as: nested classes, generics, collections, enumerated types, exception handling, and input/output stream management.
- Teaching methods
- Each lesson typically consists of one or more computer-based exercises, generally focused on the examination of simple case studies. The various exercises are preceded by an important preparatory phase, aimed at providing the necessary theoretical, methodological, and technological knowledge.
Traditional lectures will be held sporadically, and only to provide the fundamental theoretical and methodological tools required for understanding the topics covered. - Other information
- Besides the weekly office hours, the teacher is available for individual or group consultations, on dates and times to be arranged with the students.
- Learning verification modality
- The exam consists of developing a graphical desktop application or a mobile app, and producing the corresponding report (i.e., the project document), both of which are to be done individually or in pairs.
Timeline
1. Project Proposal [to be submitted at any time before the exam date, typically at least 30 days before]
The teacher and the student(s) agree on a possible project theme, typically a video game (e.g., Pac-Man), a board game emulation (e.g., Risk), a simplified version of an existing app, or another (simple) utility software. The teacher is open to accepting proposals from students as long as they are relevant to the topics and goals of the course.
2. Project Assignment [to take place after phase 1, ideally within 10-15 days]
The student(s) draft the first two chapters of the project document, including a description of the problem being addressed and a list of software requirements/features. After one or more consultations with the teacher (typically via email) to agree on a final list of requirements, the instructor assigns the project and assigns a level of difficulty on the scale: very easy, easy, normal, difficult, very difficult.
3. Project Submission [to take place after phase 2 and 2 days before the exam date]
The student(s) submit the project document, the software source code, and all resources necessary for its execution to the instructor via the UniStudium e-learning platform. The thesis should include, among other things, a section describing the overall software architecture, a section where individual architectural modules are examined in detail, and a section outlining the main issues (of various types) encountered. The 2-day advance submission allows the instructor to carefully review the various projects in all their parts.
4. Project Discussion [to take place on the exam date, immediately before the possible recording of the grade; lasts 15 to 30 minutes]
The teacher asks specific questions regarding the modeling strategy adopted, the reasons for the main design choices, the issues encountered, and how they were addressed.
Evaluation
The total score is the sum of the points awarded for the report and the points for the software system. The details are outlined below.
Report Score (12/30)
The score is calculated by evaluating the completeness and clarity of the project document, approximately following this scheme:
• accuracy (4/30);
• completeness (3/30);
• conciseness (3/30);
• readability (1/30);
• aesthetics (1/30).
Software System Score (20/30)
The score is calculated based on the project's difficulty level, the effectiveness and efficiency of the developed software, and other factors that contribute to its quality. The following scheme is applied as a rough guideline:
• project difficulty: up to 8/30 based on the following scale: very easy, easy, normal, difficult, very difficult;
• effectiveness of the developed software: up to 8/30 based on the percentage of agreed requirements that function correctly;
• efficiency and quality of the developed software: up to 4/30 based on a quick analysis of the software's efficiency and quality, expressed in terms of modularity, expandability, and correct use of polymorphic techniques and design patterns explained in the course. - Extended program
- Teaching Unit: Module 1 - Introduction to Interactive Graphic Application Programming
• Graphic components.
• Event-driven programming.
• Main architectural patterns.
• Overview of concurrency management and multithreading.
Teaching Unit: Module 2 - Desktop Application Programming
• Introduction to the JFC/Swing framework.
• Managing the layout of a GUI.
• Developing interactive GUIs.
• Using the graphics context.
• Graphic primitives.
• Rendering raster images and animations.
• Mouse interaction.
• Mouse interaction in fluid layouts.
Teaching Unit: Module 3 - Android App Programming
• Overview of the Android operating system.
• Technologies for developing native and non-native apps.
• Developing a basic Android app.
• Building dynamic user interfaces.
• Data storage.
• Managing graphics and animations.
Teaching Unit: Module 4 - Case Studies
• Developing video games for desktop and mobile. - Obiettivi Agenda 2030 per lo sviluppo sostenibile