The course teaches students comprehensive and specialised subjects in computer science; it teaches students cutting edge engineering skills to solve real-world problems using computational thinking and tools, as well as soft skills in communication, collaboration, and project management that enable students to succeed in real-world business environments. Most of this program is case (or) project-based where students learn by solving real-world problems end to end. This program has core courses that focus on computational thinking and problems solving from first principles. The core courses are followed by specialization courses that teach various aspects of building real-world systems. This is followed by more advanced courses that focus on research level topics, which cover state of the art methods. The program also has a capstone project at the end, wherein students can either work on building end to end solutions to real world problems (or) work on a research topic. The program also focuses on teaching the students the “ability to learn” so that they can be lifelong learners constantly upgrading their skills. Students can choose from a spectrum of courses to specialize in a specific sub-area of Computer Science like Artificial Intelligence and Machine Learning, Cloud Computing, Software Engineering, or Data Science, etc.
This course helps students translate advanced mathematical/ statistical/ scientific concepts into code. This is a module for writing code to solve real-world problems. It introduces programming concepts (such as control structures, recursion, classes and objects) assuming no prior programming knowledge, to make this course accessible to advanced professionals from scientific fields like Biology, Physics, Medicine, Chemistry, Civil & Mechanical Engineering etc. After building a strong foundation for converting scientific knowledge into programming concepts, the course advances to dive deeply into Object-Oriented Programming and its methodologies. It also covers when and how to use inbuilt-data structures like 1-Dimensional and 2-Dimensional Arrays before introducing the concepts of computational complexity to help students write optimised code using appropriate data structures and algorithmic design methods. The module can be taught to allow students to learn these concepts using a modern programming language such as Java or Python. The course offers students the ability to identify and solve computer programming problems in scientific fields at a graduate level. The course prepares students to handle advanced data structures and algorithm design methods in the separate module, ‘Data Structures’.
Mathematics and computer science are closely related fields. Problems in computer science are often formalized and solved with mathematical methods. It is likely that many important problems currently facing computer scientists will be solved by researchers skilled in algebra, analysis, combinatorics, logic and/or probability theory, as well as computer science. This course covers discrete mathematics for computer science and engineering. Topics may include asymptotic notation and growth of functions; permutations and combinations; counting principles; discrete probability. Further selected topics may also be covered, such as recursive definition and structural induction; state machines and invariants; recurrences; generating functions. Students will be able to explain and apply the basic methods of discrete(noncontinuous) mathematics in computer science. They will be able to use these methods in subsequent courses in the design and analysis of algorithms, computability theory, software engineering, and computer systems. The focus of the course is real-world problems and applications often found in business and industry.
The ability to solve problems is a skill, and just like any other skill, the more one practices, the better one gets. So how exactly does one practice problem solving? Learning about different problem-solving strategies and when to use them will give a good start. Problem solving is a process. Most strategies provide steps that help you identify the problem and choose the best solution.Building a toolbox of problem-solving strategies will improve problem solving skills.With practice, students will be able to recognize and choose among multiple strategies to find the most appropriate one to solve complex problems. The course will focus on developing problem-solving strategies such as abstraction, modularity, recursion, iteration, bisection, and exhaustive enumeration. The course will also introduce arrays and some of their real-world applications, such as prefix sum, carry forward, subarrays, and 2-dimensional matrices. Examples will include industry-relevant problems and dive deeply into building their solutions with various approaches, recognizing each’s limitations (i.e when to use a data structure and when not to use a data structure). By the end of this course a student can come up with the best strategy which can optimize both time and space complexities by choosing the best data structure suitable for a given problem.
This course builds upon the introductory JavaScript course to acquaint students of popular and modern frameworks to build the front end. We focus on three very popular frameworks/libraries in use: React.js, jQuery and AngularJS. We start with React.js, one of the most popular and advanced ones amongst the three. Students learn various components and data flow to learn to architect real world front end using React.js. This would be achieved via multiple code examples and code- walkthroughs from scratch. We would also dive into React Native which is a cross platform Framework to build native mobile and smart-TV apps using JavaScript. This helps students to build applications for various platforms using only JavaScript. jQuery is one of the oldest and most widely used JavaScript libraries, which students cover in detail. Students specifically focus on how jQuery can simplify event handling, AJAX, HTML DOM tree manipulation and create CSS animations. We also provide a hands-on introduction to AngularJS to architect model-view-controller (MVC) based dynamic web pages.
This is a foundational course on building server-side (or backend) applications using popular JavaScript runtime environments like Node.js. Students will learn event driven programming for building scalable backend for web applications. The module teaches various aspects of Node.js like setup, package manager, client- server programming and connecting to various databases and REST APIs. Most of these concepts would be covered in a hands-on manner with real world examples and applications built from scratch using Node.js on Linux servers. This course also provides an introduction to Linux server administration and scripting with special focus on web-development and networking. Students learn to use Linux monitoring tools (like Monit) to track the health of the servers. The module also provides an introduction to Express.js which is a popular light-weight framework for Node.js applications. Given the practical nature of this course, this would involve building actual website backends via assignments/projects for ecommerce, online learning and/or photo-sharing.
This module covers general approaches to the construction of efficient solutions to problems. Such methods are of interest because: a) They provide templates suited to solving a broad range of diverse problems, b) they can be translated into common control and data structures provided by most high-level languages, c) the temporal and spatial requirements of the algorithms which result can be precisely analyzed.
This course will provide a solid foundation and background to design and analysis of algorithms. In particular, upon successful completion of this course, students will be able to understand, explain and apply key algorithmic concepts and principles, which might include: Greedy algorithms (Activity Selection, 0-1 Knapsack Problem, Fractional Knapsack Problem), Dynamic programming (Longest Common Subsequence, 0-1 Knapsack Problem),Minimum Spanning Trees (Prim’s Algorithm, Kruskal’s Algorithm), Graph Algorithms (Dijkstra’s Shortest Path Algorithm, Bipartite Graphs, Minimum Vertex Cover). Although more than one technique may be applicable to a specific problem, it is often the case that an algorithm constructed by one approach is clearly superior to equivalent solutions built using alternative techniques. This module will help students assess these choices.
This core course equips the student with knowledge of database management systems, operating systems and computer networks. At the end of the course, students will have a critical understanding of the architecture of computers and networks, as well has how programs interact with these. Students begin with mapping data storage problems (as they had done in Relational Databases) to understand how data is stored in a distributed network, and related issues such as concurrency. Subsequently, students cover operating systems with an overview of process scheduling, process synchronisation and memory management techniques with disk scheduling. The module concludes with computer networks, where we will be discussing all of the computer network layers and their protocols in detail.
Data is the fuel driving all major organisations. This course helps you understand how to process data at scale. From understanding the fundamentals of distributed processing to designing data warehousing and writing ETL (Extract Transform Load) pipelines to process batch and streaming data. Students will learn a comprehensive view of the complete Data Engineering lifecycle.
Low-Level Design & Design Patterns focuses on modularity and reusability in software design, common design vocabularies, refactoring and how to reduce it, and how to incorporate design patterns into iterative development processes. The course pays significant attention to the interaction between system architecture and components, including data organisation. The course begins with Object-Oriented Analysis (OOA), which is a problems-solving technique that includes: modelling an information design; representing behaviour; describing functions; dividing data, functional, and behavioural models to uncover detail; moving from abstraction to implementation details. The course then turns to Object-Oriented Design (OOD), which reduces the analysis model into a modular design for software creation, with subsystems, components, and objects. The iteration of analysis and implementation will be covered in detail with real-world industry examples.
A distributed system is an application that executes a collection of protocols to coordinate the actions of multiple processes on a network, such that all components cooperate together to perform a single or small set of related tasks. Goals of a Distributed System:
● Transparency -> End user does not know what lies behind and how the system is working internally.
● Scalability - > Refers to the growth of the system.
● Availability -> Refers to the system's uptime.
The module will carefully examine three case studies, with attention to such topics as:
● Basics of High Level System Design and consistent Hashing
● Caching
● CAP Theorem
● Replication and Master-Slave
● NoSQL
● Differences between SQL and NoSQL
● Multi Master
● Apache Zookeeper & Apache Kafka
● Case Study on ElasticSearch
● AWS S3 and Quad Trees
● Design Distributed Crawler
● Microservices and Containerisation● Hotstar & IRCTC System design
Every organisation is building products to solve the pain points of its customers. Product managers are a critical part of an organisation, who make sure that evolving customer needs, and market trends are observed and converted into delightful solutions which help businesses get its outcomes. In this course, students will get a fundamental understanding of product management practices. This will give them a comprehensive view of the complete product management life cycle.
This course is aimed to build a strong foundational knowledge of data structures (DS) used extensively in computing. The module starts with introducing time and space complexity notations and estimation for code snippets. This helps students be able to make trade-offs between various Data Structures while solving real world computational problems. The module introduces most widely used basic data structures like Dynamic arrays, multi-dimensional arrays, Lists, Strings, Hash Tables, Binary Trees, Balanced Binary Trees, Priority Queues and Graphs. The module discusses multiple implementation variations for each of the above data-structures along with trade-offs in space and time for each implementation. In this course, students implement these data-structures from scratch to gain a solid understanding of their inner workings. Students are also introduced to how to use the built-in data-structures available in various programming languages / libraries like Python/NumPy/C++ STL/Java/JavaScript. Students solve real-world problems where they must use an optimal DS to solve a computational problem at hand.
This course gives the detailed overview on how to approach Low Level Design problems with real-world case studies discussed such as Designing a Pen (Mac/Windows), TicTacToe, BookMyShow (most used event booking app, manages millions of users), Email campaign Management System and detailed design of Splitwise.
Advanced Applied Computer Science is a capstone project, an end-to-end deployable solution to a real-world computational problem that students build in the last phase of the programme. Its objective is to help students rigorously solve a technically challenging problem where they would apply all of the concepts, techniques and tools learned in the programme. Students typically pick a problem from their specialisation after discussing it with the course instructor(s). Students also have the option of working on a real-world problem in their company/ organization/ institution. They can be mentored by an expert supervisor from their organization along with an academic supervisor from Woolf. All external expert-supervisors and projects need to be approved by the instructor(s) to ensure that the project is technically challenging and the solution being built is rigorous
and of high quality. Students start with identifying a technically challenging problem. Once approved by the instructor(s), they start the literature survey to read research papers and technical reports of prior related work. Then, they build the system design and write a design document to solve the problem. This would be followed by designing and implementing individual modules and testing them. This would be followed by deploying the solution and making it available to end users while satisfying the problem’s real-world constraints and objectives. Students then document their work into a detailed technical report.
