Base Knowledge
Students should possess and master advanced computer application development skills.
Previous completion of the following curricular units is recommended: (1) Programming Fundamentals; (2) Data Structures; (3) Programming; (4) Applied Programming; (5) Database (I and II); (6) Internet Programming (I and II); and (7) Software Engineering.
Teaching Methodologies
The following teaching methodologies are used in this course:
1. Expository method: explanatory method where theoretical foundations and concepts are presented by the teacher and discussed with the class. Concepts and information will be presented to students through, for example, slide presentations or oral discussions. It will be used in classes to structure and outline the information.
2. Demonstrative method: based on the example given by the teacher of a technical or practical operation that one wishes to be learned. It focuses on how a given operation is carried out, highlighting the most appropriate techniques, tools and equipment. It will be used, for example, in practical and laboratory classes.
3. Interrogative method: process based on verbal interactions, under the direction of the teacher, adopting the format of questions and answers. It allows for greater dynamics in the classroom and consolidates learning. It will be used, for example, to remember elements of previous classes and in revisions of the lectured content.
4. Active methods: pedagogical techniques will be used in which the student is the center of the learning process, being an active participant and involved in his own training. The teacher assumes the role of facilitator, stimulating critical thinking, collaboration, creativity and student autonomy. They will be applied in classes to achieve a dynamic and more lasting learning environment.
Learning Results
At the end of the course, students will be able to:
1. Develop skills in structuring and planning computer applications. Understand and apply software development methodology. Analyze and specify system requirements. Model systems using UML, C4 Model and GRL. Use planning tools effectively.
2. Implement good programming practices and prepare technical documentation. Adopt consistent coding conventions. Document code and API using tools. Produce useful comments and maintain readable code. Write quality technical documentation and user manuals.
3. Use version control systems to manage software projects. Understand the fundamental concepts of Git. Manage local and remote repositories. Apply workflows with Git. Resolve conflicts and review code effectively.
4. Analyze and apply sorting algorithms and efficient data structures. Analyze the complexity of algorithms using Big O notation. Implement soring algorithms. Use efficient data structures.
5. Implement and manage virtualization, containerization and serverless computing solutions. Understand the fundamentals of virtualization. Use Docker to containerize applications. Orchestrate containers using Kubernetes.
6. Implement real-time data monitoring and processing systems. Understand the concepts of streaming data. Use time series databases. Apply real-time data processing techniques. Use data visualization tools.
7. Develop and integrate own and third-party code. Understand the fundamentals of Django. Develop RESTful APIs. Integrate and reuse third-party libraries and packages.
8. Implement security practices in software development. Understand the principles of security in software development. Identify and mitigate common vulnerabilities. Apply secure programming practices. Use security analysis tools.
9. Ensure software quality through testing techniques and quality metrics. Understand software quality concepts. Apply unit, functional, integration and regression testing techniques. Use test automation tools. Measure code quality using metrics.
10. Implement deployment and maintenance strategies for computer systems. Understand and apply deployment strategies. Implement CI/CD pipelines. Use deployment tools. Monitor and maintain post-deployment systems effectively.
Program
1. Planning and structuring computer applications. Software development methodologies (Agile, Scrum, Kanban). Analysis and specification of requirements. Systems modeling (UML, C4 Model, GRL). Planning tools (Jira, Trello).
2. Good programming practices and writing technical documentation. Coding conventions. Code and API documentation. Useful comments and maintaining readable code. Writing technical documentation and user manuals.
3. Version control systems. Fundamental concepts of Git. Local and remote repositories (GitHub, GitLab, Bitbucket). Workflows with Git (branching, merging, pull requests). Conflict resolution and code review.
4. Complexity and ordering. Complexity analysis of algorithms (Big O notation). Sorting algorithms (QuickSort, MergeSort, HeapSort). Efficient data structures (linked lists, trees, hash tables).
5. Virtualization, containerization and serverless computing. Virtualization fundamentals (VMware, VirtualBox). Containerization with Docker. Container orchestration with Kubernetes. Introduction to serverless computing (AWS Lambda, Google Cloud Functions).
6. Real-time monitoring and control systems. Data streaming concepts (Apache Kafka, RabbitMQ). Time series databases (InfluxDB, Prometheus). Real-time data processing techniques (Kapacitor). Data visualization tools (Grafana, Chronograf).
7. Creation and (re)use of own and third-party code. Django fundamentals (models, views, templates). Developing RESTful APIs with Django. Integration and reuse of third-party libraries and packages. Unit and integration testing in Django.
8. Software security. Security principles in software development. Common vulnerabilities (SQL Injection, XSS, CSRF). Secure programming practices. Security analysis tools (OWASP ZAP, SonarQube).
9. Software quality. Software quality concepts. Testing techniques (unit, functional, integration, regression). Test automation (Selenium, Jenkins). Code quality metrics (test coverage, cyclomatic complexity).
10. Deployment of computer systems. Deployment strategies (blue-green, canary). Continuous Integration/Continuous Deployment (CI/CD) pipelines. Deployment tools (Ansible, Terraform). Post-deployment monitoring and maintenance.
Curricular Unit Teachers
Nuno Miguel Gil FonsecaGrading Methods
- - practical work - 100.0%
- - a practical job - 100.0%
Internship(s)
NAO
Bibliography
Brown, S. (2018). The C4 Model for Visualising Software Architecture. Leanpub.
Chacon, S., & Straub, B. (2014). Pro Git (2nd ed.). Apress.
Cohn, M. (2009). Succeeding with Agile: Software Development Using Scrum. Addison-Wesley Professional.
Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.). MIT Press.
Fowler, M. (2004). UML Distilled: A Brief Guide to the Standard Object Modeling Language (3rd ed.). Addison-Wesley Professional.
Greenfeld, D. R., & Roy, A. (2017). Two Scoops of Django 1.11: Best Practices for the Django Web Framework. Two Scoops Press.
Hightower, K., Burns, B., & Beda, J. (2017). Kubernetes: Up and Running: Dive into the Future of Infrastructure. O’Reilly Media.
Holovaty, A., & Kaplan-Moss, J. (2009). The Definitive Guide to Django: Web Development Done Right (2nd ed.). Apress.
Humble, J., & Farley, D. (2010). Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation. Addison-Wesley Professional.
Hut, N. (2017). Ansible: Up and Running: Automating Configuration Management and Deployment the Easy Way. O’Reilly Media.
Hüttermann, M. (2012). Agile ALM: Lightweight Tools and Agile Strategies. Apress.
Kaner, C., Bach, J., & Pettichord, B. (2001). Lessons Learned in Software Testing: A Context-Driven Approach. Wiley.
Kernighan, B. W., & Plauger, P. J. (1978). The Elements of Programming Style (2nd ed.). McGraw-Hill.
Kleppmann, M. (2017). Designing Data-Intensive Applications: The Big Ideas Behind Reliable, Scalable, and Maintainable Systems. O’Reilly Media.
Loeliger, J., & McCullough, M. (2012). Version Control with Git (2nd ed.). O’Reilly Media.
Martin, R. C. (2008). Clean Code: A Handbook of Agile Software Craftsmanship. Prentice Hall.
McGraw, G. (2006). Software Security: Building Security In. Addison-Wesley Professional.
Merkel, D. (2014). Docker: Lightweight Linux Containers for Consistent Development and Deployment. Linux Journal, 2014(239), 2.
Myers, G. J., Sandler, C., & Badgett, T. (2011). The Art of Software Testing (3rd ed.). Wiley.
Narkhede, N., Shapira, G., & Palino, T. (2017). Kafka: The Definitive Guide: Real-Time Data and Stream Processing at Scale. O’Reilly Media.
Sbarski, P. (2017). Serverless Architectures on AWS: With Examples Using AWS Lambda. Manning Publications.
Schwaber, K., & Sutherland, J. (2017). The Scrum Guide. Scrum.org.
Sedgewick, R., & Wayne, K. (2011). Algorithms (4th ed.). Addison-Wesley.
Sommerville, I. (2010). Software Engineering (9th ed.). Addison-Wesley.
Turnbull, J. (2018). Monitoring With Prometheus. Turnbull Press.
Wysopal, C., Nelson, L., Dai Zovi, D., & Dustin, E. (2006). The Art of Software Security Testing: Identifying Software Security Flaws. Addison-Wesley Professional.