This slide discusses the most popular distributed version control system that is GIT and it's different commands that we need in our daily operations for project collaboration.
This document provides an overview of Git commands and workflows:
- It introduces basic Git commands for setting up a local repository, adding and committing files, viewing the status and differences between commits, ignoring files, and more.
- Common workflows are demonstrated including cloning a repository, making changes and committing them locally, and pushing changes to a remote repository.
- More advanced topics are covered like branching, merging, rebasing, resolving conflicts, and using tools to help with these processes.
- Configuration options and tips are provided to customize Git behavior and inspect repositories.
Git is a version control system that stores snapshots of files rather than tracking changes between file versions. It allows for offline work and nearly all operations are performed locally. Files can exist in three states - committed, modified, or staged. Commits create snapshots of the staged files. Branches act as pointers to commits, with the default branch being master.
Git is a distributed version control system that records changes to files over time. It allows multiple developers to work together and tracks the version history. The document outlines the basic concepts and commands of Git including repositories, commits, branches, merging, cloning, pulling and pushing changes between a local and remote repository. Examples are provided to demonstrate how to initialize a local repository, add and commit changes, switch branches, and push updates to a remote server.
This document provides an introduction to Git basics and concepts. It covers version control systems and why distributed version control is useful. It then discusses how Git originated from the Linux kernel project. The document reviews basic Git commands and workflows for setting up a repository, tracking and committing changes. It also covers viewing differences between commits, staging files, and undoing or amending commits. Finally, it discusses sharing repositories remotely including adding remotes, pushing and pulling from remote repositories, and cloning repositories from remote URLs.
Git is a distributed version control system that allows developers to work collaboratively on projects. It works by creating snapshots of files in a project over time. Developers can commit changes locally and then push them to a remote repository to share with others. Key Git concepts include repositories, commits, branches, cloning repositories from remote locations, and commands like push, pull, commit, log and diff to manage changes.
Github - Git Training Slides: FoundationsLee Hanxue
Slide deck with detailed step breakdown that explains how git works, together with simple examples that you can try out yourself. Slides originated from http://teach.github.com/articles/course-slides/
Author: https://twitter.com/matthewmccull
This document provides an introduction to Git and GitHub. It outlines the basics of Git including initializing repositories, tracking changes, branching, merging, and resolving conflicts. It also covers GitHub concepts such as cloning repositories from GitHub to a local machine and pushing/pulling changes between local and remote repositories. The document explains how to collaborate on projects hosted on GitHub using Git.
The everyday developer's guide to version control with GitE Carter
Git is a distributed version control system that allows developers to track changes in source code. It provides tools to commit changes locally, branch code for parallel development, and collaborate remotely by pushing and pulling changes from a shared repository. Common Git commands include init to create a repository, add and commit to save changes locally, checkout to switch branches, pull to retrieve remote changes, and push to upload local changes. Git helps developers work efficiently by enabling features like branching, undoing mistakes, and viewing the revision history.
This document provides an overview of Git commands and workflows:
- It introduces basic Git commands for setting up a local repository, adding and committing files, viewing the status and differences between commits, ignoring files, and more.
- Common workflows are demonstrated including cloning a repository, making changes and committing them locally, and pushing changes to a remote repository.
- More advanced topics are covered like branching, merging, rebasing, resolving conflicts, and using tools to help with these processes.
- Configuration options and tips are provided to customize Git behavior and inspect repositories.
Git is a version control system that stores snapshots of files rather than tracking changes between file versions. It allows for offline work and nearly all operations are performed locally. Files can exist in three states - committed, modified, or staged. Commits create snapshots of the staged files. Branches act as pointers to commits, with the default branch being master.
Git is a distributed version control system that records changes to files over time. It allows multiple developers to work together and tracks the version history. The document outlines the basic concepts and commands of Git including repositories, commits, branches, merging, cloning, pulling and pushing changes between a local and remote repository. Examples are provided to demonstrate how to initialize a local repository, add and commit changes, switch branches, and push updates to a remote server.
This document provides an introduction to Git basics and concepts. It covers version control systems and why distributed version control is useful. It then discusses how Git originated from the Linux kernel project. The document reviews basic Git commands and workflows for setting up a repository, tracking and committing changes. It also covers viewing differences between commits, staging files, and undoing or amending commits. Finally, it discusses sharing repositories remotely including adding remotes, pushing and pulling from remote repositories, and cloning repositories from remote URLs.
Git is a distributed version control system that allows developers to work collaboratively on projects. It works by creating snapshots of files in a project over time. Developers can commit changes locally and then push them to a remote repository to share with others. Key Git concepts include repositories, commits, branches, cloning repositories from remote locations, and commands like push, pull, commit, log and diff to manage changes.
Github - Git Training Slides: FoundationsLee Hanxue
Slide deck with detailed step breakdown that explains how git works, together with simple examples that you can try out yourself. Slides originated from http://teach.github.com/articles/course-slides/
Author: https://twitter.com/matthewmccull
This document provides an introduction to Git and GitHub. It outlines the basics of Git including initializing repositories, tracking changes, branching, merging, and resolving conflicts. It also covers GitHub concepts such as cloning repositories from GitHub to a local machine and pushing/pulling changes between local and remote repositories. The document explains how to collaborate on projects hosted on GitHub using Git.
The everyday developer's guide to version control with GitE Carter
Git is a distributed version control system that allows developers to track changes in source code. It provides tools to commit changes locally, branch code for parallel development, and collaborate remotely by pushing and pulling changes from a shared repository. Common Git commands include init to create a repository, add and commit to save changes locally, checkout to switch branches, pull to retrieve remote changes, and push to upload local changes. Git helps developers work efficiently by enabling features like branching, undoing mistakes, and viewing the revision history.
This document provides an introduction to using Git and GitHub for version control of documents and collaboration. It explains the basic workflow of creating, editing, and saving files individually. It then introduces Git as a tool to track changes to documents over time, including who made each change and when. The document outlines setting up Git locally and using basic commands like commit, diff, log, branch, merge, and push/pull to the remote GitHub repository. It highlights key GitHub features like the profile page, repository page, pull requests, and hosting websites for free using GitHub Pages.
This document summarizes a presentation given at DrupalCamp in Athens on December 12, 2010 about Git and GitHub. The presentation introduced Git as a distributed version control system designed for speed and efficiency. It explained some of Git's core concepts like snapshots, branches, merging, and its distributed nature. It also promoted GitHub as a social coding platform that improves collaboration and code hosting for both open source and private projects. The presentation aimed to help attendees learn Git for their own benefit and prepare for Drupal moving to GitHub.
This document summarizes several common Git commands:
- Git merge joins two or more development histories together in either a fast-forward or no fast-forward manner.
- Git log displays commit history and allows formatting and filtering options like oneline, decorate, stats, diffs, shortlog, graph and custom formats.
- Other commands covered include revert, checkout, reset, cherry-pick, rebase and filtering log output by amount, date, author, message, file, content and range.
This document provides an overview of version control and the distributed version control system Git. It discusses the history and benefits of version control, including backup and recovery, synchronization, undo capabilities, and tracking changes. Key aspects of Git are explained, such as branching and merging, the fast and efficient nature of Git, and how it allows for cheap local experimentation through branches. The document demonstrates Git workflows and commands and provides resources for further information.
A version control system stores and manages every revision of files and code, allowing developers to collaborate, manage releases, and rollback to previous versions when bugs are found. Git is a widely used version control system developed by Linus Torvalds that offers benefits like backups, synchronization, undo functionality, tracking changes and ownership. It works by having a repository that stores files, which users can check out, edit, and check back in with a commit message.
This document provides an outline for a course on learning Git version control. The course covers getting Git setup, the basic concepts and workflow of Git, branching and merging, resolving conflicts, working with remote repositories, and various Git commands. The document lists several modules that will be covered, including getting started, everyday Git usage, branching, merging and rebasing, additional tools and concepts, and advice on applying the skills learned. The goal is to teach participants how to install and use Git for version control on individual, local, and distributed projects.
Git and GitHub basics provides an overview of source control systems and how to use Git and GitHub. It discusses why to use source control, how to set up Git and GitHub on Windows, basic terminology, how to create repositories and push code to GitHub, ignoring files, reverting commits, forking repositories, and pulling changes in shared repositories. The document includes demonstrations of key commands like init, add, commit, push, status, clone and pull.
Version control systems like Git allow users to manage data by systematically keeping previous versions. Git is a popular version control system that allows users to collaborate, keep track of history, and easily rollback changes. Key Git terminology includes repository, commit, branch, conflict, merge, and tag.
Simple introduction for development teams familiar with Subversion.
Internal presentation licensed as CC-BY-NC-SA. Attribute to this URL or http://fittl.com/ if you re-publish, do *NOT* use commercially.
Git is a distributed revision control system that is widely used in the software development industry. The presentation was used in a lecture delivered in BITS-Pilani, India. The lecture served as a basic crash course on Git.
First, it sets off with a guide to install and configure git on various platforms.
Then, the basic working concepts of Git are explained.
This is followed by a detailed step-by-step guided demonstration of a sample workflow in Git.
Afterwards, Some auxillary commands that are frequently used are discussed briefly.
Finally, basic concepts of branching and merging are detailed.
The presentation ends with a few possible merge conflicts that occur in Git.
Introduction to Git & GitHub.
Agenda:
- What’s a Version Control System?
- What the heck is Git?
- Some Git commands
- What’s about GitHub?
- Git in Action!
Git Tutorial For Beginners | What is Git and GitHub? | DevOps Tools | DevOps ...Simplilearn
The document provides information on version control systems and Git concepts like distributed version control, forking and cloning repositories, adding collaborators, branching and merging in Git. It includes step-by-step instructions for setting up a Git demo to showcase creating a repository, adding and committing files, connecting to a remote repository on GitHub, forking a project and cloning it locally, creating and switching branches, adding a collaborator, pulling changes, and merging branches.
Version control systems allow recording changes to files over time. There are local, centralized, and distributed version control systems. Git is a free and open-source distributed version control system created by Linus Torvalds. It provides features like speed, support for non-linear development, and ability to handle large projects efficiently.
Do you know the basics of Git but wonder what all the hype is about? Do you want the ultimate control over your Git history? This tutorial will walk you through the basics of committing changes before diving into the more advanced and "dangerous" Git commands.
Git is an open source, distributed version control system used to track many different projects. You can use it to manage anything from a personal notes directory to a multi-programmer project.
This tutorial provides a short walk through of basic git commands and the Git philosophy to project management. Then we’ll dive into an exploration of the more advanced and “dangerous” Git commands. Watch as we rewrite our repository history, track bugs down to a specific commit, and untangle commits into an LKML-worthy patchset.
This document provides an overview of version control and Git. It discusses what version control is, why it is used, and common types including local, centralized, and distributed. It then focuses on Git, covering its history and origins from Linux kernel development. Key Git concepts are explained like data storage, file lifecycles, basic commands like clone, add, commit, branch, merge, and working with remotes. Tips are provided on installation, ignoring files, using with IDEs, and further learning resources.
At the end of this session, you will be able to:
* Install git
* Create a local git repository
* Add a file to the repo
* Add a file to staging
* Create a commit
* Create a new branch
* Create a GitHub repo
* Push a branch to GitHub
Git is a distributed version control system created by Linus Torvalds to manage changes to the Linux kernel. It allows developers to work independently and merge changes later. Git uses local repositories that can act as both clients and servers, avoiding the need to be connected to a central server. The basic Git workflow involves modifying files in the working directory, staging changes, and committing snapshots of the staged changes to the local repository. Common Git commands are used to add, commit, push, pull, branch, merge, and more. Key features of Git include being open source, distributed, providing security and speed, supporting non-linear development with branching and merging, and assuring data integrity.
This document provides an overview of version control systems and Git/GitHub basics. It defines centralized and distributed version control systems, and explains how Git is a distributed system. It then gives instructions for Git configuration, committing files, branching, merging, rebasing, stashing changes, and using GitHub as a remote repository.
This document provides an introduction to version control systems and Git/GitHub. It defines key terminology like centralized and distributed version control systems. It explains what Git and GitHub are and how they work. The document outlines the basic Git workflow and commands for initializing a repository, tracking changes, branching and merging, and more. It also discusses how features like stashing can help manage changes in Git.
This document provides an introduction to using Git and GitHub for version control of documents and collaboration. It explains the basic workflow of creating, editing, and saving files individually. It then introduces Git as a tool to track changes to documents over time, including who made each change and when. The document outlines setting up Git locally and using basic commands like commit, diff, log, branch, merge, and push/pull to the remote GitHub repository. It highlights key GitHub features like the profile page, repository page, pull requests, and hosting websites for free using GitHub Pages.
This document summarizes a presentation given at DrupalCamp in Athens on December 12, 2010 about Git and GitHub. The presentation introduced Git as a distributed version control system designed for speed and efficiency. It explained some of Git's core concepts like snapshots, branches, merging, and its distributed nature. It also promoted GitHub as a social coding platform that improves collaboration and code hosting for both open source and private projects. The presentation aimed to help attendees learn Git for their own benefit and prepare for Drupal moving to GitHub.
This document summarizes several common Git commands:
- Git merge joins two or more development histories together in either a fast-forward or no fast-forward manner.
- Git log displays commit history and allows formatting and filtering options like oneline, decorate, stats, diffs, shortlog, graph and custom formats.
- Other commands covered include revert, checkout, reset, cherry-pick, rebase and filtering log output by amount, date, author, message, file, content and range.
This document provides an overview of version control and the distributed version control system Git. It discusses the history and benefits of version control, including backup and recovery, synchronization, undo capabilities, and tracking changes. Key aspects of Git are explained, such as branching and merging, the fast and efficient nature of Git, and how it allows for cheap local experimentation through branches. The document demonstrates Git workflows and commands and provides resources for further information.
A version control system stores and manages every revision of files and code, allowing developers to collaborate, manage releases, and rollback to previous versions when bugs are found. Git is a widely used version control system developed by Linus Torvalds that offers benefits like backups, synchronization, undo functionality, tracking changes and ownership. It works by having a repository that stores files, which users can check out, edit, and check back in with a commit message.
This document provides an outline for a course on learning Git version control. The course covers getting Git setup, the basic concepts and workflow of Git, branching and merging, resolving conflicts, working with remote repositories, and various Git commands. The document lists several modules that will be covered, including getting started, everyday Git usage, branching, merging and rebasing, additional tools and concepts, and advice on applying the skills learned. The goal is to teach participants how to install and use Git for version control on individual, local, and distributed projects.
Git and GitHub basics provides an overview of source control systems and how to use Git and GitHub. It discusses why to use source control, how to set up Git and GitHub on Windows, basic terminology, how to create repositories and push code to GitHub, ignoring files, reverting commits, forking repositories, and pulling changes in shared repositories. The document includes demonstrations of key commands like init, add, commit, push, status, clone and pull.
Version control systems like Git allow users to manage data by systematically keeping previous versions. Git is a popular version control system that allows users to collaborate, keep track of history, and easily rollback changes. Key Git terminology includes repository, commit, branch, conflict, merge, and tag.
Simple introduction for development teams familiar with Subversion.
Internal presentation licensed as CC-BY-NC-SA. Attribute to this URL or http://fittl.com/ if you re-publish, do *NOT* use commercially.
Git is a distributed revision control system that is widely used in the software development industry. The presentation was used in a lecture delivered in BITS-Pilani, India. The lecture served as a basic crash course on Git.
First, it sets off with a guide to install and configure git on various platforms.
Then, the basic working concepts of Git are explained.
This is followed by a detailed step-by-step guided demonstration of a sample workflow in Git.
Afterwards, Some auxillary commands that are frequently used are discussed briefly.
Finally, basic concepts of branching and merging are detailed.
The presentation ends with a few possible merge conflicts that occur in Git.
Introduction to Git & GitHub.
Agenda:
- What’s a Version Control System?
- What the heck is Git?
- Some Git commands
- What’s about GitHub?
- Git in Action!
Git Tutorial For Beginners | What is Git and GitHub? | DevOps Tools | DevOps ...Simplilearn
The document provides information on version control systems and Git concepts like distributed version control, forking and cloning repositories, adding collaborators, branching and merging in Git. It includes step-by-step instructions for setting up a Git demo to showcase creating a repository, adding and committing files, connecting to a remote repository on GitHub, forking a project and cloning it locally, creating and switching branches, adding a collaborator, pulling changes, and merging branches.
Version control systems allow recording changes to files over time. There are local, centralized, and distributed version control systems. Git is a free and open-source distributed version control system created by Linus Torvalds. It provides features like speed, support for non-linear development, and ability to handle large projects efficiently.
Do you know the basics of Git but wonder what all the hype is about? Do you want the ultimate control over your Git history? This tutorial will walk you through the basics of committing changes before diving into the more advanced and "dangerous" Git commands.
Git is an open source, distributed version control system used to track many different projects. You can use it to manage anything from a personal notes directory to a multi-programmer project.
This tutorial provides a short walk through of basic git commands and the Git philosophy to project management. Then we’ll dive into an exploration of the more advanced and “dangerous” Git commands. Watch as we rewrite our repository history, track bugs down to a specific commit, and untangle commits into an LKML-worthy patchset.
This document provides an overview of version control and Git. It discusses what version control is, why it is used, and common types including local, centralized, and distributed. It then focuses on Git, covering its history and origins from Linux kernel development. Key Git concepts are explained like data storage, file lifecycles, basic commands like clone, add, commit, branch, merge, and working with remotes. Tips are provided on installation, ignoring files, using with IDEs, and further learning resources.
At the end of this session, you will be able to:
* Install git
* Create a local git repository
* Add a file to the repo
* Add a file to staging
* Create a commit
* Create a new branch
* Create a GitHub repo
* Push a branch to GitHub
Git is a distributed version control system created by Linus Torvalds to manage changes to the Linux kernel. It allows developers to work independently and merge changes later. Git uses local repositories that can act as both clients and servers, avoiding the need to be connected to a central server. The basic Git workflow involves modifying files in the working directory, staging changes, and committing snapshots of the staged changes to the local repository. Common Git commands are used to add, commit, push, pull, branch, merge, and more. Key features of Git include being open source, distributed, providing security and speed, supporting non-linear development with branching and merging, and assuring data integrity.
This document provides an overview of version control systems and Git/GitHub basics. It defines centralized and distributed version control systems, and explains how Git is a distributed system. It then gives instructions for Git configuration, committing files, branching, merging, rebasing, stashing changes, and using GitHub as a remote repository.
This document provides an introduction to version control systems and Git/GitHub. It defines key terminology like centralized and distributed version control systems. It explains what Git and GitHub are and how they work. The document outlines the basic Git workflow and commands for initializing a repository, tracking changes, branching and merging, and more. It also discusses how features like stashing can help manage changes in Git.
Version control systems allow recording changes to files over time and reverting files back to previous states. Git is an open source distributed version control system initially created by Linus Torvalds for Linux kernel development. Git stores project snapshots over time as differences from a base version of files and allows fully local operations without needing network access. Basic Git commands include add, commit, branch, checkout, merge, push and pull to manage changes to a local or remote repository.
This document provides an overview of version control systems and instructions for downloading, installing, and using the distributed version control system Git. It explains the basics of Git including configuring user information, choosing an editor, interacting with remote repositories, and common commands for viewing changes, staging files, committing changes, and viewing the commit history. Typical workflows and some helpful formatting options for the git log command are also demonstrated.
Git 101 Presentation
The presentation introduces Git version control system including:
[1] An overview of version control systems and the basics of Git such as snapshots, local operations, and three main states of files.
[2] A comparison of features between Git and SVN such as distributed development and branching workflows.
[3] Instructions on setting up Git locally and with GitHub, and basic commands for creating and managing repositories, branches, commits, and merges.
This document provides an introduction and overview of Git and GitHub. It discusses version control systems and the differences between centralized and distributed version control. Key Git concepts and commands are explained such as configuring Git, creating repositories, adding and committing files, branches, pulling and pushing changes. GitHub is introduced as a platform for hosting Git repositories and collaborating on projects. The document provides instructions for adding collaborators to a GitHub repository.
Version control systems track changes to source code over time by keeping a complete history of file versions in a database. Version control provides benefits like a change history, branching and merging, and traceability. Git is a distributed version control system that allows developers to work offline and collaborate by sharing changes. Developers use branches to work independently on features or bugs, then merge branches to combine changes.
This document provides an introduction to Git and common Git workflows. It discusses what Git is, how it stores data as snapshots rather than file changes, and its advantages as a distributed version control system where the full code history is stored locally. It then demonstrates basic Git commands like init, add, commit, status, branch, merge, tag and working with remotes. Key points covered include initializing and cloning repositories, tracking changes, committing work, branching and merging, and sharing code via remote repositories.
This document provides an overview of version control systems and instructions for downloading and using Git. It explains that version control systems manage multiple versions of documents and projects. Git is a distributed version control system that treats all repositories as equal. The document then provides step-by-step instructions for installing Git, configuring user settings, cloning repositories from a school server, making changes to code and committing/pushing those changes to the repository, and resolving merge conflicts when changes cannot be automatically merged. It also lists some helpful Git commands.
The document provides an overview of Git, including what it is, its benefits over centralized version control systems, basic workflows and commands, branching, tagging, and best practices. Git is an open source distributed version control system designed to manage source code and other files. It allows users to work offline and commit changes incrementally to a local repository before pushing to a remote server.
A small presentation for developers with good SVN knowledge that are going to working with Git.
The presentation also contains an example of repository creation on github and a simple scenario of collaboration between two developers
The document provides an introduction to version control systems and Git, describing Git as a free and open source distributed version control system initially created by Linus Torvalds for Linux kernel development. Key Git concepts are explained such as repositories, working copies, revisions, branches, tags, and the basic Git workflow of modifying files, staging changes, and committing snapshots. Basic Git commands are also outlined for configuring Git, cloning repositories, initializing and adding files, committing changes, branching, merging, and checking the status of work.
This document provides an overview of the version control system Git and how it works. It discusses local and centralized version control systems and introduces distributed version control systems like Git. It describes how Git stores versions in a local repository and allows synchronizing with remote repositories. The document outlines common Git commands for initializing and configuring a repository, tracking changes, branching, resetting commits, and interacting with remote servers. It also introduces the Bonobo Git Server for hosting local Git repositories.
This document provides an overview of Git and how to set it up for first use. It discusses the basics of Git including its distributed nature, snapshots instead of differences, and the three main states. It also covers installing Git, configuring user settings like name, email and tools, and getting help. The summary recommends having an understanding of Git and how it differs from CVCS, a working Git setup with identity, and being ready to learn basic Git commands.
Git is a distributed version control system that allows for both local and remote collaboration on code. It provides advantages like speed, simplicity, integrity, and support for parallel development through features like branching. Common Git commands include git init to start a new repository, git add to stage files, git commit to save changes, git push to upload local work to a remote repository, and git pull to download remote changes. GitHub is a popular hosting service for Git repositories that provides a graphical interface and social features.
This document provides an overview of Git and GitHub. It defines version control systems and their benefits like maintaining different versions and metadata. It describes Git as a free, open source distributed version control system and how it works by storing files and their development history locally. Key Git commands are explained like setup, initiating repositories, adding/committing files, branching and merging, inspecting changes. Finally, it briefly introduces GitHub as a platform for software development and collaboration that works with Git repositories and allows pull requests between developers.
The document discusses version control systems and Git. It provides an overview of centralized and distributed version control workflows. Key points include:
- Centralized VCSs involve committing changes to a central repository, while distributed VCSs allow users to commit locally and push changes.
- Git uses a distributed model where each user has a full local copy of the repository and commits changes locally before pushing.
- Common Git commands are add, commit, push, pull, status, diff, log, branch, tag, and remote for working with remote repositories.
A Beginner's Guide to Git and GitHub, CLI version.
What is Git?
What is Github
Basic commands
Difference between Central and Distributed Version Controlling System
In this slide, I have a fully explanation about what is Git and why use it. I also give a fully explanation about the basic command that mostly use with git.
Similar to GIT | Distributed Version Control System (20)
1) The document discusses the Longest Increasing Subsequence (LIS) problem to find the longest subsequence of a given sequence where elements are in increasing order. It provides an example LIS of length 6 for a sample input array. A dynamic programming table is used to store the LIS value for each array element.
2) The problem of counting the number of ways to make change for an amount N using coins of values in S is discussed. A 2D dynamic programming table is used where one dimension tracks coins and the other tracks the change value.
3) The 0-1 Knapsack problem is described, to find the maximum value subset of items fitting in a knapsack of capacity
The document discusses dynamic programming and provides examples of problems that can be solved using dynamic programming techniques. It describes characteristics of dynamic programming problems such as overlapping subproblems and optimal substructure properties. It also describes two common approaches to dynamic programming - top-down with memorization and bottom-up with tabulation. Finally, it lists 12 practice problems related to topics like staircase problem, tiling problem, friends pairing problem, house thief problem, minimum jumps problem, Catalan numbers, binomial coefficients, permutation coefficients, subset sum problem, 0/1 knapsack problem, longest common subsequence and edit distance that can be solved using dynamic programming.
The document discusses key graph concepts like connected graphs, connected components, strongly connected graphs, and strongly connected components. It also covers disjoint set data structures, including the operations of make-set, union, and find-set. It describes how linked lists and disjoint set forests can be used to represent disjoint sets and discusses techniques like union by rank and path compression that allow disjoint set operations to run in nearly linear time. Finally, it defines minimum spanning trees and covers Kruskal's and Prim's algorithms for finding minimum spanning trees in graphs.
The document discusses graphs and their representations using adjacency matrices and lists. It also describes different algorithms for solving the single-source shortest path problem on graphs, including breadth-first search (BFS), Dijkstra's algorithm, and Bellman-Ford algorithm. BFS runs in O(V+E) time and works when edge weights are equal. Dijkstra's algorithm uses a min-priority queue and runs in O(ElogV) time when implemented with a Fibonacci heap, handling graphs with positive edge weights. Bellman-Ford works for graphs with positive or negative edge weights, running in O(VE) time.
The document discusses three algorithms:
1) Quicksort partitions an array around a pivot element, recursively sorting the left and right subarrays.
2) Finding the maximum subarray sum divides an array in half at each step, calculating sums within and across the halves.
3) Finding the rotation count of a rotated sorted array returns the index of the minimum element, representing the number of rotations.
The document discusses the divide and conquer algorithm design paradigm and some examples of its applications. It describes divide and conquer as having three key steps: 1) divide the problem into subproblems, 2) solve the subproblems recursively, and 3) combine the solutions. It then lists several problems and their divide and conquer solutions, including merge sort, quick sort, calculating powers, randomized binary search, fast multiplication, finding maximum subarray sums, counting array inversions, and finding peak elements in an array.
The document provides examples of recursive code to solve various problems and asks the reader to write similar recursive code to solve related problems. It includes code to find the maximum value in an array, check if a string is a palindrome, calculate the greatest common divisor (GCD) of integers, solve the Tower of Hanoi problem, and calculate the number of ways to cover a distance moving units of 1, 2, or 3 each move. The reader is asked to write code for related problems such as finding the maximum digit in an integer, checking if an integer array is a palindrome, calculating the GCD of an integer array, solving Tower of Hanoi with two intermediate poles, and calculating ways to cover a distance moving specified
The document discusses recursion, defining it as a problem-solving technique where problems are solved by reducing them to smaller problems of the same type. It provides examples of different types of recursion like direct, indirect, tail, and tree recursion. It also lists 15 recursive problems and their solutions including finding maximum/minimum in an array, calculating factorials, Fibonacci numbers, and solving subset sum and coin change problems.
1. The document describes 3 programming tasks:
- Read characters from an adjacency list file and print them
- Build an adjacency list graph data structure from the file
- Implement a queue using two stacks
2. It provides code templates and instructions for building a queue that implements enqueue by pushing to one stack and dequeue by popping between two stacks.
3. The tasks are to read characters from a file into a graph, build the graph data structure, and implement a queue with two stacks that demonstrates pushing and popping values.
Mohammad Imam Hossain is a lecturer in the Department of Computer Science and Engineering at UIU. His email is provided. The document discusses C++ including its history and structure, input/output, file I/O, STL containers like vector, stack, queue and map, and strings. Key STL concepts covered are containers, iterators, insertion, deletion, searching and accessing elements.
The document discusses transactions and transaction management in database systems. It defines transactions as logical units of work that must follow the ACID properties of atomicity, consistency, isolation, and durability. Transactions access and update data using operations like read and write. The transaction model ensures concurrent transactions execute reliably by enforcing serializability through techniques like conflict analysis and precedence graphs. Maintaining serializability guarantees the isolation property and prevents anomalous behavior from transaction interleaving.
This slide explains the conversion procedure from ER Diagram to Relational Schema.
1. Entity set to Relation
2. Relationship set to Relation
3. Attributes to Columns, Primary key, Foreign Keys
1. What is Entity Relationship Model
2. Entity and Entity Set
3. Relationship and Relationship Set
4. Attributes and it's kinds
5. Participation Constraints and Mapping Cardinality
6. Aggregation, Specialization, and Generalization
7. Some Sample ERD models
This note includes the followings:
- Database Create, Drop Operations
- Database Table Create, Drop Operations
- Database Table Alter Operation
- Data insertion
- Data deletion
- Existing data update
- Searching data from data table (showing all record, specific columns, specific rows, column aliasing, sorting data, limiting data, distinct data)
- Aggregate functions
- Group by clause
- Having clause
- Types of table joins
- Table aliasing, Inner Join, Left/Right Join, Self Join
- Subquery operation (scalar subquery, column subquery, row subquery, correlated subquery, derived table)
This note contains some sample MySQL query practices based on the HR Schema database. The practice sections are from the following categories:
- DDL statements
- Basic Select statements
- Aggregate operations
- Join operations
This lecture slide contains:
- Difference between FA, PDA and TM
- Formal definition of TM
- TM transition function and configuration
- Designing TM for different languages
- Simulating TM for different strings
This slide contains,
1) Some terminologies like yields, derives, word, derivation
2) Leftmost and Rightmost derivation
3) Ambiguity checking
4) Parse tree generation and ambiguity checking
This presentation was provided by Racquel Jemison, Ph.D., Christina MacLaughlin, Ph.D., and Paulomi Majumder. Ph.D., all of the American Chemical Society, for the second session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session Two: 'Expanding Pathways to Publishing Careers,' was held June 13, 2024.
Philippine Edukasyong Pantahanan at Pangkabuhayan (EPP) CurriculumMJDuyan
(𝐓𝐋𝐄 𝟏𝟎𝟎) (𝐋𝐞𝐬𝐬𝐨𝐧 𝟏)-𝐏𝐫𝐞𝐥𝐢𝐦𝐬
𝐃𝐢𝐬𝐜𝐮𝐬𝐬 𝐭𝐡𝐞 𝐄𝐏𝐏 𝐂𝐮𝐫𝐫𝐢𝐜𝐮𝐥𝐮𝐦 𝐢𝐧 𝐭𝐡𝐞 𝐏𝐡𝐢𝐥𝐢𝐩𝐩𝐢𝐧𝐞𝐬:
- Understand the goals and objectives of the Edukasyong Pantahanan at Pangkabuhayan (EPP) curriculum, recognizing its importance in fostering practical life skills and values among students. Students will also be able to identify the key components and subjects covered, such as agriculture, home economics, industrial arts, and information and communication technology.
𝐄𝐱𝐩𝐥𝐚𝐢𝐧 𝐭𝐡𝐞 𝐍𝐚𝐭𝐮𝐫𝐞 𝐚𝐧𝐝 𝐒𝐜𝐨𝐩𝐞 𝐨𝐟 𝐚𝐧 𝐄𝐧𝐭𝐫𝐞𝐩𝐫𝐞𝐧𝐞𝐮𝐫:
-Define entrepreneurship, distinguishing it from general business activities by emphasizing its focus on innovation, risk-taking, and value creation. Students will describe the characteristics and traits of successful entrepreneurs, including their roles and responsibilities, and discuss the broader economic and social impacts of entrepreneurial activities on both local and global scales.
Beyond Degrees - Empowering the Workforce in the Context of Skills-First.pptxEduSkills OECD
Iván Bornacelly, Policy Analyst at the OECD Centre for Skills, OECD, presents at the webinar 'Tackling job market gaps with a skills-first approach' on 12 June 2024
THE SACRIFICE HOW PRO-PALESTINE PROTESTS STUDENTS ARE SACRIFICING TO CHANGE T...indexPub
The recent surge in pro-Palestine student activism has prompted significant responses from universities, ranging from negotiations and divestment commitments to increased transparency about investments in companies supporting the war on Gaza. This activism has led to the cessation of student encampments but also highlighted the substantial sacrifices made by students, including academic disruptions and personal risks. The primary drivers of these protests are poor university administration, lack of transparency, and inadequate communication between officials and students. This study examines the profound emotional, psychological, and professional impacts on students engaged in pro-Palestine protests, focusing on Generation Z's (Gen-Z) activism dynamics. This paper explores the significant sacrifices made by these students and even the professors supporting the pro-Palestine movement, with a focus on recent global movements. Through an in-depth analysis of printed and electronic media, the study examines the impacts of these sacrifices on the academic and personal lives of those involved. The paper highlights examples from various universities, demonstrating student activism's long-term and short-term effects, including disciplinary actions, social backlash, and career implications. The researchers also explore the broader implications of student sacrifices. The findings reveal that these sacrifices are driven by a profound commitment to justice and human rights, and are influenced by the increasing availability of information, peer interactions, and personal convictions. The study also discusses the broader implications of this activism, comparing it to historical precedents and assessing its potential to influence policy and public opinion. The emotional and psychological toll on student activists is significant, but their sense of purpose and community support mitigates some of these challenges. However, the researchers call for acknowledging the broader Impact of these sacrifices on the future global movement of FreePalestine.
A Visual Guide to 1 Samuel | A Tale of Two HeartsSteve Thomason
These slides walk through the story of 1 Samuel. Samuel is the last judge of Israel. The people reject God and want a king. Saul is anointed as the first king, but he is not a good king. David, the shepherd boy is anointed and Saul is envious of him. David shows honor while Saul continues to self destruct.
What is Digital Literacy? A guest blog from Andy McLaughlin, University of Ab...
GIT | Distributed Version Control System
1. GIT >> Version Control System
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
2. Version Control System - VCS
Version control is a system that records changes to a file or set of files over time so that you can recall
specific versions later.
▸ It allows you to revert selected files back to a previous state, revert the entire project back to a
previous state, compare changes over time, see who last modified something that might be causing a
problem, who introduced an issue and when, and more.
▸ Using a VCS also generally means that if you screw things up or lose files, you can easily recover.
2
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
3. Local VCS - LVCS
3
Local VCS maintains a simple database that
records all the changes to files under revision
control.
It keeps patch sets (i.e. the difference
between files) in a special format on disk; it
can then re-create what any file looked like at
any point in time by adding up all the patches.
Problem >>
How to collaborate with other developers?
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
4. Centralized VCS - CVCS
Centralized Version Control Systems
(CVCSs) have a single server that
contains all the versioned files, and a
number of clients that check out files
from that central place.
Problem >>
Centralized server is a single point of
failure.
4
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
5. Distributed VCS - DVCS
In a Distributed Version Control Systems (DVCSs)
clients don’t just check out the latest snapshot of the
files; rather, they fully mirror the repository, including
its full history.
if any server dies, and these systems were
collaborating via that server, any of the client
repositories can be copied back up to the server to
restore it. Every clone is really a full backup of all the
data.
5
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
6. DVCS >> GIT
▸ Git is a distributed version-control system for tracking changes in source code during software
development.
▸ It is designed for coordinating work among programmers, but it can be used to track changes in any
set of files.
▸ It was created by Linux Development Community (in particular, Linus Torvalds) in 2005 for
development of the Linux kernel when the relationship between the community and the BitKeeper
company broke down.
▸ Git naming:
▹ In British slang, unpleasant person
▹ Global information tracker
▹ Goddamn idiotic truckload of sh*t
6
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
7. GIT
▸ GIT thinks of its data more like a series of snapshots of a miniature filesystem.
▸ With Git, every time you commit, or save the state of your project, Git basically takes a picture of what
all your files look like at that moment and stores a reference to that snapshot.
▸ To be efficient, if files have not changed, Git doesn’t store the file again, just a link to the previous
identical file it has already stored.
7
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
8. GIT >> File States
▸ Each file in the working directory can be in 2 states:
▹ Tracked – files that were in the last snapshot.
▹ Untracked – everything else, not in the last snapshot and not in the staging area.
▸ Tracked file states:
▹ Unmodified/Committed – data is safely stored in the local database.
▹ Modified – you have changed the file but have not committed it to your database yet.
▹ Staged – you have marked a modified file in its current version to go into your next commit snapshot.
8
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
9. GIT >> Stage and Commit Process
▸ Staging the files computes the checksum for each one, stores that version of
the file in the Git repository and adds that checksum to the staging area.
▸ During git commit, git checksums each subdirectory and stores them as a tree
object in the Git repository.
▸ Git then creates a commit object containing metadata and pointer to the
project tree.
9
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
10. GIT >> Multiple Commits Process
▸ The scenario of multiple commits.
▸ Each new commit stores a pointer to the commit that came immediately before it.
10
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
11. 11
GIT Command Line
- only place you can run all Git commands
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
12. GIT CLI >> First-time Setup
12
▸ Version check: $ git --version
▸ Configuration scope:
▹ --system : values applied to every user on the system and all their repositories.
▹ --global : values specific personally to you and affects all the repositories you work with.
▹ --local : values specific to that single repository you are currently using.
▸ Get/Set Configuration variables :
▹ To view all the settings: $ git config --list
▹ To view all the settings with file path: $ git config --list --show-origin
▹ To check a specific variable value: $ git config <key>
▹ To set a specific variable value: $ git config --global <key> <value>
▸ First time setup:
$ git config --global user.name “username”
$ git config -- global user.email “useremail@gmail.com”
cause every git commit uses your name and email
▸ Getting help: $ git <verb> --help
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
13. GIT CLI >> Getting a GIT Repository
13
▸ Initialize an existing local directory:
Go within that directory and run - $ git init
▸ Clone an existing remote repository:
To clone the remote repository run - $ git clone <url>
To clone the remote repository into your directory run - $ git clone <url> <new-directory-name>
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
14. GIT CLI >> Creating a GIT Repository
14
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
15. GIT CLI >> Check/Add/Remove Remote Repository
15
▸ To show all the remote repositories you have configured
$ git remote –v
▸ To add new remote repositories
$ git remote add <shortname> <url>
git clone command implicitly adds the remote for you
▸ To remove remote repository
$ git remote remove <shortname>
▸ To rename remote repository
$ git remote rename <old-shortname> <new-shortname>
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
16. GIT CLI >> Fetch/Pull/Push Information
16
▸ To fetch
$ git fetch <remote>
This command only downloads the data to your local repository - it doesn’t automatically merge it.
▸ To pull
$ git pull <remote> <branch>
If your current branch(master) is set up to track a remote branch(remote master), then this command
automatically fetch and then merge that remote branch into your current branch.
▸ To push (pull/fetch before push)
$ git push <remote> <branch>
▸ Inspecting a remote,
$ git remote show <remote>
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
17. GIT CLI >> How git fetch Works
17
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
18. GIT CLI >> How git fetch Works
18
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
19. GIT CLI >> Recording Repository Changes
19
▸ To get the status of the files
$ git status
▸ To track new file/stage a file
$ git add <file-path>
To add changes from all the tracked and untracked files
$ git add -A
▸ To commit your staged changes (commit records the snapshot you set up in your staging area)
$ git commit –m <commit-message>
To skip the staging area and commit every tracked files(auto staged)
$ git commit –a –m <commit-message>
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
20. GIT CLI >> Ignoring Specific Files
20
▸ Create a file named .gitignore and
list the file names/patterns that you don’t want GIT to automatically add/even show you as being
untracked.
For example,
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
*.[oa] to ignore any files ending with .o or, .a
!lib.a to track lib.a file even though you are ignoring .a files
/TODO to ignore TODO file in the current directory, not subdirectory
build/ to ignore all files in any directory named build
doc/*.txt to ignore doc/notes.txt file, bit not doc/server/arch.txt, i.e. not within
subdirectory
doc/**/*.pdf To ignore all .pdf files in the doc/ directory and its subdirectory
21. GIT CLI >> Viewing the Changes
21
▸ To see what you’ve changed but not yet staged (diff. between staged and modified files)
$ git diff
▸ To see what you’ve staged that will go into the next commit (diff. between staged and committed files)
$ git diff --cached
▸ To rename a file in GIT
$ git mv <file_from> <file_to>
▸ To make a tracked file untracked
$ git rm --cached <file-name>
To remove a file from your working directory
$ git rm <file-name>
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
22. GIT CLI >> Commit History
22
▸ To list all the commits made in the repository in reverse chronological order,
$ git log
▸ To see some abbreviated stats for each commit
$ git log --stat
▸ To see the last 3 commit history
$ git log -3
▸ To see the difference introduced in each commit,
$ git log -p -2
▸ To show each commit in one line
$ git log --oneline
▸ To see the branch and graph history in the form of a graph
$ git log --pretty=format:”%h %s” --graph
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
23. GIT CLI >> git log Options
23
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
-<n> Show only the last n commits
--since, --after Limit commits to those made after the specified date
--until, --before Limit the commits to those made before the specified date
--author Only show commits in which the author entry matches the specified string
--committer Only show commits in which the committer entry matches the specified string
--grep Only show commits with a commit message containing the string
-S Only show commits adding or removing code matching the string
24. GIT CLI >> git log Options
24
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
-p Show the patch introduced in each commit
--stat Show statistics for files modified in each commit
--pretty Show commits in an alternate format. Oneline/short/full/fuller/format
--oneline Shorthand for --pretty=oneline --abbrev-commit
--graph Display an ASCII graph of the branch and merge history beside the log output
%H Commit hash %an, %ae, %ad Author name, email and date
%h Abbreviated commit hash %cn, %ce, %cd Committer name, email and date
%P Parent hashes %s Subject
%p Abbreviated parent hashes
25. GIT CLI >> Undoing Things
25
▸ To redo the last commit
$ git commit --amend -m “new commit message”
or
$ git commit –amend
▸ To unstage a staged file
$ git reset HEAD <file-name>
▸ To unmodify a modified file
$ git checkout -- <file-name>
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
26. GIT CLI >> Branching
26
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
▸ To list all the current branches
$ git branch
The * pointed branch indicates the branch currently HEAD points to
▸ To get the list of merged branches
$ git branch –merged
▸ To get the list of unmerged branches
$ git branch –no-merged
▸ To create a new branch
$ git branch <branch-name>
▸ To switch to new branch
$ git checkout <branch-name>
▸ To remove an already merged branch
$ git branch –d <branch-name>
▸ To remove an unmerged branch
$ git branch –D <branch-name>
27. GIT CLI >> Branching >> initial local repository
27
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
28. GIT CLI >> Branching >> creating a new branch
28
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
$ git branch <branch-name>
29. GIT CLI >> Branching >> switching to a new branch
29
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
$ git checkout <branch-name>
30. GIT CLI >> Branching >> staging & committing in the new branch
30
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
$ git commit –a –m “commit message”
31. GIT CLI >> Branching >> switching back to master branch
31
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
$ git checkout master
32. GIT CLI >> Branching >> staging and committing in master branch
32
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
$ git commit –a –m “commit message”
33. GIT CLI >> Branching >> example-step 1
33
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
34. GIT CLI >> Branching >> example-step 2
34
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Creating a new branch and switching to that branch
$ git checkout -b iss53
or,
$ git branch iss53
$ git checkout iss53
35. GIT CLI >> Branching >> example-step 3
35
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Committing in that new branch
$ git commit -a –m “commit message”
36. GIT CLI >> Branching >> example-step 4
36
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Switching back to master, creating new branch hotfix,
switching to that branch and performing a new commit
there
$ git checkout master
$ git checkout hotfix
$ git branch hotfix
$ git commit -a –m “commit message”
37. GIT CLI >> Branching >> example-step 5
37
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Switching back to branch master and merging with the hotfix branch
$ git checkout master
$ git merge hotfix
38. GIT CLI >> Branching >> example-step 6
38
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Deleting the hotfix branch, switching to iss53 branch and performing new commit there
$ git branch -d hotfix
$ git checkout iss53
$ git commit –a –m “commit message”
39. GIT CLI >> Branching >> example-step 7
39
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Going back to master branch
$ git checkout master
40. GIT CLI >> Branching >> example-step 8
40
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
Merging the master branch with iss53 branch
$ git merge iss53
If conflict occurs, then open and edit the conflicted file
remove the <<<<<<<, =======, >>>>>>> symbols, perform necessary
changes, finally stage and commit the changes
41. GIT CLI >> Revision Selection
41
▸ To show the details of a specific commit
$ git show <SHA-1 hash value of that commit>
▸ To see the log of where your HEAD and branch references have been for the last few months
$ git reflog
▸ To refer to the older commits from the current HEAD position
$ git show HEAD@{5}
▸ To show the first parent of a specific commit
$ git show HEAD^
To show the second parent(meaning other branch parent) of a specific commit
$ git show HEAD^2
▸ To show the first parent of a first parent
$ git show HEAD~2
▸ Difference between the second branch commits with first branch commits
$ git log br1..br2
▸ Difference between both of the branch commits
$ git log br1…br2
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
42. GIT CLI >>Temporarily saving changes at a Branch
42
To switch branches for a bit to work on something else. The problem is, you don’t want to do a commit of
half-done work just so you can get back to this point later. The answer to this issue is the git stash
command.
Stashing takes the dirty state of your working directory — that is, your modified tracked files and staged
changes — and saves it on a stack of unfinished changes that you can reapply at any time (even on a
different branch).
To save the current work
$ git stash push
To check all the stashes
$git stash list
To apply any certain stash changes to the current branch file
$ git stash apply
or, $ git stash apply stash@{2}
To delete a saved stash from the stack
$ git stash drop stash@{1}
To apply the stash changes and also delete from the stack at the same time
$ git stash pop stash@{1}
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
43. GIT CLI >>The Role of Reset
43
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
44. GIT CLI >>The Role of Reset
44
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
45. GIT CLI >>The Role of Reset
45
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
46. GIT CLI >>The Role of Reset
46
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
47. GIT CLI >>The Role of Reset
47
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
48. GIT CLI >>The Role of Reset
48
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
49. GIT CLI >>The Role of Reset
49
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
50. GIT CLI >>The Role of Reset
50
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
51. GIT CLI >>The Role of Reset
51
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU
52. GIT CLI >>The Role of Reset
52
Mohammad Imam Hossain | Lecturer, dept. of CSE | UIU