- ID2221 - Data Intensive Computing
- DA2210 - Introduction to the Philosophy of Science and Research Methodology for Computer Scientists
- DD2440 - Advanced Algorithms
- DD2380 - Artificial Inteligence
- DVA481 - Automated Test Generation
- DD2520 - Applied Cryptography
- DD2480 - Software Engineering Fundamentals
- DD2459 - Software Reliability
- DD2300 - Program-Cohesive-Course-In-Computer-Science
- Computational Intelligence
- Advanced Data Analysis
- Game Theory
- Transportation Planning
- Data Mining
- Fondation of Multi Agent Systems
- Pattern Recognition
- DD2482 - Automated Software Testing and DevOps
- DD2443 - Parallel and Distributed Computing
This course describes the critical technology trends enabling cloud computing and its services and applications. The course covers various advanced topics in data-intensive computing, including:
- Distributed file systems, e.g., HDFS
- No SQL databases, e.g., BigTable, Cassandra, Neo4j
- Big Data execution engines, e.g., Map-Reduce, Spark, Spark SQL
- Scalable messaging systems, e.g., Kafka
- Stream processing, e.g., Spark Streaming
- Graph processing, e.g., GraphLab, GraphX
- Resource management, e.g., Mesos, YARN, Borg
- Data lake, e.g., Delta Lake, Lakehouse
After passing the course, students should be able to (according to Bloom's taxonomy):
- ILO1: Understand the main concepts of data-intensive computation platforms.
- ILO2: Apply the grabbed knowledge to store and process massive data.
- ILO3: Analyze the technical merits of data-intensive computation platforms.
- The basic concepts within the philosophy of science and research methodology, such as causality, data, correlation, hypothesis, and inductive-deductive methods.
- Special methods and problems within computer science and mathematics.
- Research methodology within engineering projects.
- Experimental methodology.
- Ethics in science and the role of science in society.
- How to read and write scientific reports.
- Practical training in writing scientific reports (similar to degree projects).
- Explain and analyze scientific theories relevant to research in computer science,
- Explain and analyze scientific methods relevant to research in computer science,
- Review scientific articles in computer science about theory, method, and results critically
- Identify methodological problems in a study
- Identify ethical problems in different scientific situations and discuss them
- Plan and carry out the writing of a scientific report.
The course will describe and analyze several algorithms for combinatorial computational problems. Algorithmic concepts: Randomized algorithms, approximation algorithms, fixed-parameter algorithms.
After passing the course, the student should be able to:
- Explain different advanced algorithmic concepts such as randomized algorithms, approximation algorithms, fixed-parameter algorithms
- Analyze, select, use, and verify algorithms that are based on the above concepts,
- Develop efficient algorithms that are based on the above concepts,
- Independently explore existing advanced algorithms, implement them, and improve them using heuristics,
- Communicate algorithmic ideas in a clear, formal way
The following fields are treated within the scope of the course: problem-solving with search algorithms, heuristics, knowledge representations (logic), planning, representation of uncertainty and inference (Bayesian networks, HMM), decision theory and utility theory, and diction (NLP).
After passing the course, the student shall be able to:
- apply different principles of Artificial Intelligence (AI)
- choose appropriate tools and implement efficient solutions to problems in AI
- integrate tools to design computer programs that show different properties that are expected by an intelligent system
- present, analyze, and entitle your solution to an AI problem
- reflect on and discuss current social and ethical aspects of AI
The increasing competition pressure for the rapid introduction of new or modified system versions poses problems in properly testing software. These pressures have led many organizations to transition their development processes to agile development and continuous integration, greatly shortening the time to conduct comprehensive testing.
This course provides an understanding of automating software testing using program analysis with the goal of intelligently and algorithmically creating tests. The course covers search-based test generation, combinatorial and random testing while highlighting the challenges associated with the use of automatic test generation.
- Understand algorithmic test generation techniques and their use in developer testing and continuous integration.
- Understand how to generate test cases with assertions automatically.
- Have a working knowledge and experience in static and dynamic generation of tests.
- Have an overview of search-based testing and the use of machine learning for test generation.
Basic concepts and principles of cryptography, intuition about security, implementation and engineering aspects as well as influence on society, black box analysis, use of cryptographic primitives such as symmetric and asymmetric encryption in applications, digital signatures, cryptographic hash functions, and simple cryptosystems and cryptographic protocols.
After passing the course, the student should be able to:
- use basic terminology in computer security and cryptography correctly
- describe cryptographic concepts and explain their security properties
- find and use documentation of cryptographic libraries and standards
- identify and categorize threats against a cryptographic IT system at a conceptual level, suggest appropriate countermeasures, and present the reasoning to others to as a citizen and engineer be able to discuss applied cryptography in general and the risks of using/developing cryptography in particular in professional life and/or research and development projects be able to evaluate challenges in software development related to cryptography.
- Requirements engineering
- Revision control, continuous integration, and the life cycle for software.
- Design patterns, and components.
- Testing and debugging.
- Software maintenance, configuration management, refactoring.
- Quality assurance Estimation and measurement of performance code complexity, and scalability.
After completion of the course, students should be able to:
- apply revision control to a software project
- systematically test and debug a program
- combine different types of software testing technologies in a project
- understand and use patterns for the design and implementation of software
- deploy quality assurance techniques and judge their results.
The course will cover the following topics:
- software testing concepts according to the V-model
- graphical requirements modeling, including use case modeling
- logical requirements modeling, including preconditions, postconditions, and class invariants
- graph coverage models
- logic coverage models
- input space partitioning
- syntax based testing
- reliability models
- advanced topics such as automated and model-based testing.
The theoretical subjects are supported by laboratory work to deepen the student's understanding of important concepts.
Having passed the course, the student shall be able to:
- identify the basic activities needed for software testing, including requirements capture, test planning, test case generation, test case execution, fault diagnosis and fault correction
- construct requirements models for simple embedded, reactive, and object-oriented systems
- construct a test suite for a simple requirements model
- assess the quality of a test suite according to a variety of coverage models.
The Program Integrating Course runs through both years of the Master's Program in Computer Science at KTH. The course uses reflections as the main educational instrument.
You will learn why the compulsory courses are compulsory in the program and how these relate to each other, how you should select courses and specialization to become well-prepared for your future employment, and how to study to gain the most from the program.
The program integrating course each year simply consists of four one-hour seminars in groups of about a dozen first and second year students, together with a professor as a mentor. Since the program is quite large there are 24 parallel groups and 12 professors as mentors.
Each seminar has a topic, some links to texts to read or videos to look at, and some questions to think about. You will write a reflection on the topic and also on your current courses and studies. Thereafter you will should read and comment the other students' reflections and discuss them at a seminar.
Lecture on calculation methods for control, reasoning, adaptation/learning, and optimization using soft computing techniques (Fuzzy Reasoning, Artificial Neural Networks, Genetic Algorithm, etc.) in addition to numerical computation.
- Learn practical data analysis on Python environments.
- Learn about visualization of data and representation of analysis results on Python environments.
When an intelligent agent makes an decision, it need to consider the existence of other agents and how they choose their decisions. Game theory, which is founded by John von Neumann, aims to deal with decision making of rational agents in such situations. This lecture covers the basics of game theory, as well as auction theory, which is an application domain of game theory. More specifically, this lecture describes basic auction mechanisms (e.g., ascending, descending, first-price, second-price) and their properties. Finally, this lecture covers mechanism design theory, which deals with a more general group decision making procedure.
- Overview of the transportation system (Transportation Planning Ⅰ)
- Trip generation (Transportation Planning Ⅰ)
- Vehicle and Human characteristics (Transportation Planning Ⅰ)
- Traffic Flow (Transportation Planning Ⅱ)
- Public passenger transportation (Transportation Planning Ⅱ)
- Urban transportation planning (Transportation Planning Ⅱ)
| Topic | Content | Expected Outside Work |
|---|---|---|
| 1. Basics of Multivariate Analysis | Learn the meaning and calculation methods of descriptive statistics for multivariate data. | Review the content after class. |
| 2. Multiple Regression Analysis | Learn the theory of multiple regression analysis and acquire practical methods through exercises. | Review the theory after class and practice using a computer. |
| 3. Principal Component Analysis | Learn the theory of principal component analysis and acquire practical methods through exercises. | Review the theory after class and practice using a computer. |
A multi-agent system consists of multiple "agents" that can act autonomously. Each agent locally communicates and interacts with the neighbours to meet some global design objectives. Such systems include "smart mobility" such as vehicle platoons, power networks and smart grids, and sensor networks. The course introduces some basic ideas, techniques, and theories to control multi-agent systems.
Main topics:
- Introduction to multi-agent systems
- Mathematical foundation (Linear algebra and algebraic graph theory)
- Consensus control
The aim of this course is to let students acquire fundamental knowledge and skills about pattern recognition. The content of the course includes feature extraction, clustering, dimensionality reduction, statistical modeling, classification, time-series data and so on. In addition, programming exercises will provide students with practical experience.
- Software testing
- Continuous integration
- Continuous delivery
- Continuous deployment
- Continuous monitoring
After passing the course, the student shall be able to
- Write and deploy tests, and assess test quality
- use the state-of-the-art of software development platforms
- configure and deploy infrastructure software, including continuous integration, continuous delivery, and continuous deployment
- use collaborative platforms for software development
- design, deploy and orchestrate microservices and containers
in order to
- have the required skills of a Devops Engineer
- be prepared for lifelong learning with respect to fast-changing technology.
The course is an advanced course in parallel and distributed computations, dealing with the following subjects:
- models, fundamental concepts and analytical methods for parallel and distributed systems, fundamental limitations and impossibility results
- algorithms and protocols for commonly occurring computing problems in communication, synchronisation, fault tolerance, coordination, consensus and replication, sharing and security, and distributed storing.
The course assumes interest for programming and theoretical issues.
After passing the course, the student should be able to
- account for models, limitations and fundamental concepts within parallel computations with communication based both on message passing and shared memory
- apply and adapt existing algorithms and develop new algorithms for execution on parallel and distributed machines and analyse these algorithms with regard to correctness, security and performance.