GitHunt
MU

MuxammilSidd/FAST-KHI-Semester-5

FAST NUCES Karachi - BSCS Fifth Semester Repository | Access notes, assignments, past papers, & more. For queries or suggestions, contact k232001@nu.edu.pk.

algorithmscomputer-networksdatabase-systemsgraph-theorynucesrecommender-systemssemester-5software-design-and-analysissoftware-project-managementweb-programming

FAST-KHI-Semester-5

Welcome FASTians! Here you can find relevant material for your fifth semester (BSCS) at FAST NUCES Karachi. A little effort by my side to boost your academic journey. ✨
Don't forget to star this repo if you find it useful! ⭐

For any queries/improvement feel free to contact me on k232001@nu.edu.pk
For contributions kindly look here.

🔗 Links to other semester repositories

🔗 Guide to get you started

🔗 How to crack your fifth semester at FAST NUCES!

  • Time management

  • Course-wise guide

    # Course Code Short Name Type Credit Hours
    1 CS2005 DS Database Systems Core 3+1
    2 CS2009 DAA Design & Analysis of Algorithms Core 3
    3 CS3001 CN Computer Networks Core 3+1
    4 CS3004 SDA Software Design & Analysis Core 3
    5 CS4044 FSPM Fundamentals of Software Project Management Elective 3
    CS4053 RS Recommender Systems Elective 3
    MT3001 GT Graph Theory Elective 3
    CS4032 WP Web Programming Elective 3
    MT4031 OR Operations Research Elective 3
    Total Credit Hours: 17

    🔗 Useful Websites you should know!

    • Theresanaiforthat There's an AI for That - Discover the newest & best AI tools with free alternaatives!
    • TinyWow Favicon TinyWow Text - Hundreds of free online tools to get you going on that assignment!
    • Quizlet - Expert textbook solutions to tally from!
    • GradeSaver - Literally a grade-saver after Quizlet turned paid!
    • PDFdrive - Thousands of eBooks available to download for free!
    • Buildspace.so Buildspace.so - Find ideas and inspiration for your next project!
    • Keybr Keybr - Improve your typing speed and take it to the next level!
    • learncpp.com LearnCpp.com - A free website devoted to teaching you how to program in modern C++!

    🔗 Useful tools you should know!

    • SolidPoint Solidpoint.ai - An online free YouTube Summarizer that automatically generates concise summaries of any video, saving you valuable time and energy!
    • Chatpdf Chatpdf.com - Chat with your PDF documents — Extract information or answer questions from large PDF files like manuals, essays, books.!

    🔗 Useful repositories you should know!

    🔗 Time Management

    pata chale toh mujhe bhi bata dena pls

    🔗 Course wise guide

    📌 Database Systems:

    DBS is a comparatively easy course, yet it is extremely important. Almost every interview you face in the future will include at least one or two questions from this subject. The concepts are easy to grasp, but they require practice to implement them confidently. Most topics are closely related to real-life scenarios, which makes them easier to understand. The only challenging topic you may encounter is Joins. For this, regular practice is essential. You should follow Jenny’s Lectures and Gate Smashers Playlist, as their explanations are clear and beginner-friendly. For the transactions part, the KnowledgeGate DBMS Playlist is highly recommended; it is detailed and aligns well with our syllabus.
    For practice, make sure to solve lab tasks from instructors of other sections as well, especially for PL/SQL and Joins. Overall, this is an easy and scoring course if you maintain pace with your teacher and practice consistently.
    For the lab, the advice is mostly the same. However, one important thing to remember is that time management is the biggest challenge during exams. Both mids and finals are very lengthy, so it is crucial to manage your time wisely. During exams, it is better to attempt the non-query parts first and leave the queries for the end, as they usually consume a lot of time. Practice is key here. Try solving problems by first writing subqueries and then converting them into joins. This approach makes your concepts crystal clear, especially how the result of one query is used by an outer query. Ideally, practice writing each query in both styles. The final exam is highly marks-gaining, so don’t lose hope even if your mids don’t go well. Make sure to practice triggers and PL/SQL, as these topics can be tricky and are often used to create confusion. Other topics like MongoDB and related concepts are relatively easy and straightforward

    🔗 Useful Youtube Playlists:

    🔗 Projects:

    🔗 Resources:

    🔗 Google Drives:

    📌 Design & Analysis of Algorithms:

    Algorithms is a relatively tricky course and can cause serious trouble if you don’t take it seriously from the start. Many people recommend Abdul Bari, and he is undoubtedly a great teacher for building intuition. However, for Mid-1, his lectures were not very helpful for me personally (please don’t kill me). In hindsight, it would have been better if I had relied more on the slides instead of depending solely on his lectures.
    I know many people will disagree, but this is purely my point of view. Abdul Bari is excellent for understanding concepts, but exam questions are usually not framed the same way. One very important thing to do is to carefully study the marking scheme from previous papers. For example, I lost almost 3 marks just because I didn’t draw a recursion tree in the exact way my teacher expected. Similarly, some of my classmates lost marks in an easy knapsack question simply because they didn’t draw the keep table. I was lucky enough to go through the slides beforehand, where both the DP table and the keep table were shown. From this experience if something is part of the marking scheme, your instructor will expect it.
    From Mid-2 onwards, you should follow Striver along with Abdul Bari. At this stage, start solving scenario-based questions from GeeksforGeeks and LeetCode using similar problem patterns to solidify your understanding. Once again, always refer back to your slides to match the representation and structure expected in exams.
    A common mistake students make is rote learning algorithms, which is a bad idea. Exam questions are rarely straightforward, and under pressure you’re more likely to forget memorized steps. Instead, focus on:
    Understanding the intuition > Dry running the algorithm > Studying the pseudocode > Dry running using the pseudocode > Finally, looking at the C++ implementation.
    Most instructors allow pseudocode, so don’t panic if you can’t write complete code. In many cases, clear pseudocode + written explanation + small snippets are more than sufficient. Overall, this course is absolutely worth your time, but it demands effort and smart preparation. Study hard and study strategically for this one.

    🔗 Useful Youtube Playlists:

    📌 Computer Networks:

    Computer Networks may seem boring at first, but it is actually a very interesting course if you study it properly. The course itself is not difficult, provided you follow the right resources and stay consistent. The single best resource for this course is James F. Kurose, who is the author of the book Computer Networking: A Top-Down Approach. His official YouTube playlist, based on the Top-Down Approach, is more than enough. The playlist covers every topic in detail, and you should follow it topic by topic without skipping anything. The course itself is not inherently hard, but if you have time, it is highly recommended to read the book as well. This is important because sometimes, especially in mids and finals, questions appear from corner cases—topics that are not fully covered in videos and sometimes not even emphasized by the instructor in class, yet still appear in exams. If not during mids, then at least read the book before finals. Overall, the course is easy if you:
    Follow the author’s playlist properly,
    Refer to the book when possible,
    Stay consistent with the topics.
    If you do these, it is more than enough to score well in the course.
    For the CN lab, focus on understanding the commands instead of memorizing them blindly. Try to score as many marks as possible in the mids, because the final exam is significantly more difficult and lengthy. In finals, you are expected to learn 30–40 router and switch commands, whereas the mid exam is comparatively very easy. So, use the mids as an opportunity to secure your score early. Make sure you practice on different network topologies. This is extremely important. Wireshark is also taught in this course. Many students initially think it involves hacking or advanced security concepts, but that’s not the case. The course mainly focuses on packet sniffing and using packet header information to analyze and extract details—nothing beyond that. For commands, you can use ChatGPT to understand the purpose and usage of each command. Honestly, it’s nearly impossible to remember all commands unless you understand why they are used. While practicing, always:
    Configure routers for each topic & Configure the opposite side of the network.
    This approach will make you comfortable with gateway concepts, which are frequently tested in exams. Overall, the lab becomes very challenging if you don’t practice on complex topologies. Regular hands-on practice is the key to making this lab manageable and scoring.

    🔗 Useful Youtube Playlists:

    🔗 Resources:

    📌 Software Design & Analysis:

    SDA is an easy course if you have good photographic memory, especially for remembering the representations of different diagrams. The diagrams themselves are not difficult; the real challenge is remembering their representation rules. There is very little theory assessed in exams—most questions are scenario-based. Therefore, don’t rely only on memorizing representations; make sure to practice at least 2–3 scenarios for each diagram. Mid-1 mostly focuses on OOP concepts (including OOP pillars and class diagrams). However, after Mid-2, around 6–7 new UML representations are introduced, which you need to remember and practice. You won’t really need YouTube for this course. Your slides are more than enough. Also, don’t hesitate to ask your instructors to provide practice scenarios. If you’re still struggling to find good practice material, refer to Ms. Rubab Manzar’s slides, where you’ll find at least three solved and unsolved questions after each topic, which are very helpful.
    The only topic that can cause real trouble is Design Patterns. For this, you can follow the Design Patterns in OOP Playlist, which explains the concepts clearly. Overall, the course is relatively the easiest as compared to other courses in the fifth semester. It is definitely marks-gaining, as long as you don’t take it for granted and practice consistently.

    🔗 Useful Youtube Playlists:

    📌 Graph Theory:

    Graph Theory is one of the best electives to opt for. It is extremely interesting, and you’ll often find yourself wanting to study it even in your free time. This course truly has the potential to make graphs your favorite data structure.
    The course is relatively easy as long as proofs are not heavily emphasized in exams. There are many algorithms, so make sure you learn them along with their names. Some questions are framed like “Prove this using Menger’s Theorem”, and if you haven’t memorized the names, you’ll be left wondering what the question is even asking. So, always associate algorithms and theorems with their proper names. The major drawback of this course is that there are very limited resources available on YouTube. You may find some lectures for the initial topics, but as the course progresses, YouTube becomes far less helpful. On the brighter side, the textbook is quite good and can be referred to for deeper understanding. However, the book should never be treated as a last-minute resort, so make sure you don’t miss classes. This course heavily depends on what your instructor emphasizes in lectures. Write down everything your instructor explains—you never know what detail might appear in an MCQ or a short question.
    Overall, this is an easy and marks-scoring course, but only if you follow the process properly and do not skip classes deliberately. The mids are usually quite lengthy, so it’s a good idea to solve at least one question of each type from the book beforehand to build confidence and speed!

    📌 Fundamentals of Software Project Management:

    Hands-down this has been the hardest elective out of the 5 choices offered to Batch-23K (CS). It is definitely not as easy as it sounds or how the seniors had guided. The contents of the course are easy but they are extensive and the exams are unimaginably hard. No matter how well you'd have prepared, the exam would feel like you haven't studied at all. There are many topics especially in the beginning that conflict with SDA, hence sometimes the course feels repetitive.

    📌 Recommender Systems:

    📌 Web Programming:

    📌 Operations Research:

    who even opted for this elective bruh 😭 hop over here if you can contribute any resources for this course, or email me if you'd like.

    🔗 Projects:

    • ORA - Minimum Spanning Tree OR Project.

    Can't find a course?

    Check out other semester's repositories here!

    🔗 Additional Resources

    Feeling this repository isn't enough? 😩 Here are all links to repositories and drives I found: ⬇️

    📌 Github Repositories:

    📌 Google Drives:

    📌 MEGA Drives:

Languages

HTML52.6%Rich Text Format39.6%Jupyter Notebook5.2%C++2.5%

Contributors

MUSH
Created August 3, 2025
Updated March 9, 2026
MuxammilSidd/FAST-KHI-Semester-5 | GitHunt