Describe how git works internally using small and perfect plumbing commands.
The slide have been used at GDG DevFest 2014 and SOSCON 2014.
The slide can be updated later. And, the latest version would always be provided from this page always.
This document provides an introduction to Git and GitHub. It discusses key features of Git including being a distributed version control system designed for speed and efficiency. It covers setting up Git locally and on GitHub, including configuring user information, initializing and cloning repositories, and pushing and pulling changes. The document also provides some basic Git commands and points to additional learning resources for beginners.
The document discusses Git internals and debugging. It provides an agenda that will cover Git areas like the working directory, staging area and repository. It will also discuss Git objects like blobs, trees and commits that make up Git's object graph and data structure. Finally, it will demonstrate debugging tools like blame, grep and bisect.
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 a summary of common Git commands for setting up and working with repositories, saving changes, inspecting history, undoing changes, rewriting history, syncing with remote repositories, branching, and merging. It discusses initializing and cloning repositories, adding and committing changes, viewing logs and checking out commits, reverting and resetting changes, amending commits and rebasing, fetching and pushing to remote repositories, branching, and merging branches. It also cautions against amending shared commits or force pushing to avoid overwriting others' work.
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.
A Git tutorial for rookies that covers most aspects of basic Git usage for a medium sized project.
This was originally a semestral lecture given at the TU Wien for the course "Software Engineering and Project Management"
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.
One of the biggest advantages of Git is its branching capabilities. Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow popular with many Git users.
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.
This document provides an introduction to using git for version control. It outlines three scenarios: 1) a single developer using a local repository, 2) a team of developers using a central remote repository, and 3) contributing to a software project hosted on GitHub. The document demonstrates how to initialize repositories, add and commit changes, branch, merge, resolve conflicts, push and pull from remote repositories, and set up a shared remote repository. It provides summaries of key git commands and demonstrations of workflows through examples.
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.
O documento discute Git e GitHub, ferramentas para controle de versão e colaboração em projetos. O Git permite armazenar diferentes versões de arquivos e projetos, enquanto o GitHub oferece repositórios online para hospedagem de projetos Git e funcionalidades sociais. O texto explica como instalar e configurar essas ferramentas, criar e sincronizar repositórios locais e remotos, e utilizar recursos como branches e merges.
GitHub is a Git repository hosting service, but it adds many of its own features. While Git is a command line tool, GitHub provides a Web-based graphical interface. It also provides access control and several collaboration features, such as a wikis and basic task management tools for every project.
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.
Introduction to Git/Github - A beginner's guideRohit Arora
Introduction to Git/Github - A beginner's guide
Agenda:
Installing Git
Introduction to Version Control
Git Basics
Creating a new local Git repository
Cloning a Git repository
Making use of Git commit history
Reverting files to previous states
Creating a Github Repository
Adding, Committing & Pushing changes
Branching
Merging Branches
Sending Pull Requests
Conflict Resolution
and 3 Exercises
I have evidence that using git and GitHub for documentation and community doc techniques can give us 300 doc changes in a month. I’ve bet my career on these methods and I want to share with you.
This document discusses using Git and GitHub for version control. It covers Git terminology and commands for initializing a Git repository, configuring Git, adding and committing files, branching and merging, and using an code editor with Git. Key points include using 'git init' to create a new local repository, 'git add' to stage files for committing, 'git commit' to save changes to the repository, and 'git branch', 'git checkout' and 'git merge' for managing branches. The document provides guidance on writing good commit messages and installing Git on different operating systems.
Este documento apresenta uma agenda para um workshop sobre Git para iniciantes, abordando conceitos como versionamento de arquivos, histórico de sistemas de versionamento, repositórios remotos, instalação do Git, criação de repositórios locais e remotos, entendimento de branches e merges.
Short introduction about vcs & git usage.
Aimed to introduce concept of version control system and git to people who didn't used git or vcs yet. Doesn't introduce deep part of git or operating policy for git. Just focus on simple introduction about main functionality and abstracted internal design.
Git is a distributed version control system that provides the following benefits:
- It is lightweight, distributed, offers security and code integrity, and allows for easy branching. Common Git commands include add, commit, push, pull, clone, and status.
- Remote repositories can be accessed via SSH or HTTP protocols. Common workflows involve cloning repositories, fetching and checking out branches, pushing local commits, and pruning remote branches.
- Branching allows developers to work independently on features or bugs without disrupting the main line of development. Branches can be merged back together when complete.
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.
A Git tutorial for rookies that covers most aspects of basic Git usage for a medium sized project.
This was originally a semestral lecture given at the TU Wien for the course "Software Engineering and Project Management"
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.
One of the biggest advantages of Git is its branching capabilities. Unlike centralized version control systems, Git branches are cheap and easy to merge. This facilitates the feature branch workflow popular with many Git users.
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.
This document provides an introduction to using git for version control. It outlines three scenarios: 1) a single developer using a local repository, 2) a team of developers using a central remote repository, and 3) contributing to a software project hosted on GitHub. The document demonstrates how to initialize repositories, add and commit changes, branch, merge, resolve conflicts, push and pull from remote repositories, and set up a shared remote repository. It provides summaries of key git commands and demonstrations of workflows through examples.
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.
O documento discute Git e GitHub, ferramentas para controle de versão e colaboração em projetos. O Git permite armazenar diferentes versões de arquivos e projetos, enquanto o GitHub oferece repositórios online para hospedagem de projetos Git e funcionalidades sociais. O texto explica como instalar e configurar essas ferramentas, criar e sincronizar repositórios locais e remotos, e utilizar recursos como branches e merges.
GitHub is a Git repository hosting service, but it adds many of its own features. While Git is a command line tool, GitHub provides a Web-based graphical interface. It also provides access control and several collaboration features, such as a wikis and basic task management tools for every project.
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.
Introduction to Git/Github - A beginner's guideRohit Arora
Introduction to Git/Github - A beginner's guide
Agenda:
Installing Git
Introduction to Version Control
Git Basics
Creating a new local Git repository
Cloning a Git repository
Making use of Git commit history
Reverting files to previous states
Creating a Github Repository
Adding, Committing & Pushing changes
Branching
Merging Branches
Sending Pull Requests
Conflict Resolution
and 3 Exercises
I have evidence that using git and GitHub for documentation and community doc techniques can give us 300 doc changes in a month. I’ve bet my career on these methods and I want to share with you.
This document discusses using Git and GitHub for version control. It covers Git terminology and commands for initializing a Git repository, configuring Git, adding and committing files, branching and merging, and using an code editor with Git. Key points include using 'git init' to create a new local repository, 'git add' to stage files for committing, 'git commit' to save changes to the repository, and 'git branch', 'git checkout' and 'git merge' for managing branches. The document provides guidance on writing good commit messages and installing Git on different operating systems.
Este documento apresenta uma agenda para um workshop sobre Git para iniciantes, abordando conceitos como versionamento de arquivos, histórico de sistemas de versionamento, repositórios remotos, instalação do Git, criação de repositórios locais e remotos, entendimento de branches e merges.
Short introduction about vcs & git usage.
Aimed to introduce concept of version control system and git to people who didn't used git or vcs yet. Doesn't introduce deep part of git or operating policy for git. Just focus on simple introduction about main functionality and abstracted internal design.
Git is a distributed version control system that provides the following benefits:
- It is lightweight, distributed, offers security and code integrity, and allows for easy branching. Common Git commands include add, commit, push, pull, clone, and status.
- Remote repositories can be accessed via SSH or HTTP protocols. Common workflows involve cloning repositories, fetching and checking out branches, pushing local commits, and pruning remote branches.
- Branching allows developers to work independently on features or bugs without disrupting the main line of development. Branches can be merged back together when complete.
This document summarizes key concepts of Git including snapshots, histories as sequences of snapshots, parallel universes/histories, and basic Git commands like init, add, commit, branch, checkout, merge, rebase, remote repositories, and free hosting services. The document uses diagrams and examples to explain how Git conceptually implements versions as snapshots and allows managing parallel software histories through branches.
Présentation de GIT par Sébastien Dawans, Senior Engineer R&D au Cetic. http://www.cetic.be
Présenté le 26 Novembre 2013 à Louvain-la-Neuve
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.
Wrapped in a single session, you'll find the concepts and techniques that convert the average Git practitioner into a master of the craft. We'll go from technical topics like "efficient conflict resolution" and "effective code cleanup," to the often-asked "how to handle project dependencies with Git" and "how to manage massive repositories." And much more.
Git is a distributed version control system that is used for software development, and allows many software developers to work on a given project without requiring them to share a common network.
This presentation helps you to know what is Git, how it works, and how you can use it.
This document provides an introduction to version control with Git. It discusses the basic Git model and workflow, including cloning repositories, making local changes, staging files, and committing changes. It compares Git to centralized version control systems like Subversion and highlights Git's distributed and non-linear development advantages. Basic Git commands are explained like add, commit, status, diff, log, pull and push. Branching and merging with Git are also introduced.
The document provides an introduction and overview of Git. It begins with an introduction of the presenter and then asks poll questions to gauge who is and isn't using source code management systems. It then proceeds to explain what Git is, why it's useful, how to configure and set up a Git repository, how to add and commit changes, create and switch branches, undo changes, and work with remote repositories and resolve conflicts.
This document discusses version control and Git. It explains that version control allows developers to maintain stability and continuity in websites/applications by saving versions. Git tracks differences between commits, is distributed for less server overhead, and makes complex workflows easier to manage. The document provides examples of basic Git commands and realistic workflows for development, deployment, using branches, merging, and other "cool stuff" like hooks, stash, and reset. Resources are also included for learning more about Git vs Subversion and deploying with Git.
Git Anti-Patterns: How To Mess Up With Git and Love it Again - DevoxxPL 2017Lemi Orhan Ergin
This document contains the slides from a presentation on best practices for using Git and avoiding common antipatterns. It discusses how Git works internally and the different objects it uses to store files, references, and commits. It then covers strategies for committing code early and often in small batches, rebasing regularly to integrate changes, squashing commits before merging back to the main branch, and using feature flags to disable unreleased features. The overall message is to leverage Git's power effectively while avoiding long-lived topic branches, loose commit histories, and other issues that can arise from not understanding Git's model.
Git Magic: Versioning Files like a Bosstmacwilliam
This document provides an overview of using Git for version control. It discusses setting up Git, making commits, branching, merging, resolving conflicts, reverting changes, collaborating remotely, and using hooks. Key aspects covered include distributed version control, non-linear development with branches, committing snapshots of a project's files, and resolving incompatible changes during merges.
This document provides an overview of version control, specifically Git. It discusses what version control is, why it is useful, and where it is used. It then describes how to set up and use many of the basic Git commands and workflows, including setting up a local repository, tracking changes, committing changes to the project history, branching and merging, and undoing changes when needed. The goal is to introduce the reader to the basics of using version control with Git.
Git Anti-Patterns: How To Mess Up With Git and Love it AgainLemi Orhan Ergin
Git is one of the most powerful tool in developers' toolbox. If you use it correctly, it dramatically increases productivity of developers and eliminates the waste products continuously. Developers cultivate a development culture on top Git most of the time.
It's powerful but its power is untamed. Many teams fall into several traps of misusing commands and therefore feel uncomfortable while using Git. We mess up Git history, the codebase and the whole preferred branching strategy in seconds. We use branches, merge/rebase strategies, creating commits in wrong ways. Even we never take committing paradigms into account while using Git.
As a software craftsman, I've been using Git for years and I've already educated Git to hundreds of developers in all levels. I'm so lucky; I had a chance to experience huge amount of anti-patterns in time. In this talk, I will talk about what those anti-patterns are and what should we do in order not to fall into them.
This document provides tips and techniques for becoming a Git master, including:
1. Creating aliases to simplify common Git commands like committing and adding remotes. Aliases allow parameters and bash functions for complex commands.
2. Using features like assume-unchanged to hide files from Git and rerere to automate resolving similar conflicts.
3. Interactive rebasing to polish commit histories by squashing, rewording, and fixing up commits. Rebasing rewrites history so care is needed.
4. Techniques for preventing history tampering like reject force pushes and signing tags for verification. GPG keys can be stored and imported in Git.
5. Handling project dependencies with build tools or
This document provides an introduction and overview of using Git for version control. It discusses the basics of version control systems including local version control, centralized version control, and distributed version control. It then walks through setting up Git locally and configuring it, generating SSH keys, creating repositories on GitHub, forking repositories, and basic Git commands and workflows for branching, merging, and working with remotes.
Biscuit: an operating system written in goSeongJae Park
Biscuit is a monolithic operating system kernel that is written in Go. This talk introduces the kernel and demonstrate how to build, install, and analyze the code.
GCMA: Guaranteed Contiguous Memory AllocatorSeongJae Park
This document summarizes a presentation about GCMA, a Guaranteed Contiguous Memory Allocator for Linux kernels. GCMA aims to provide fast and guaranteed contiguous memory allocation while maintaining good memory utilization. It designates "discardable" pages used by frontswap and clean cache as secondary clients that can be quickly vacated from the reserved area. Evaluations show GCMA provides significantly faster allocation latency and system performance compared to CMA, especially under memory pressure or fragmentation. The presenter is working to upstream GCMA code and provide further evaluation results.
The document discusses the Linux kernel memory model (LKMM). It provides an overview of LKMM, including that it defines ordering rules for the Linux kernel due to weaknesses in the C language standard and need to support multiple hardware architectures. It describes ordering primitives like atomic operations and memory barriers provided by LKMM and how the LKMM was formalized into an executable model that can prove properties of parallel code against the LKMM.
An Introduction to the Formalised Memory Model for Linux KernelSeongJae Park
Linux kernel provides executable and formalized memory model. These slides describe the nature of parallel programming in the Linux kernel and what memory model is and why it is necessary and important for kernel programmers. The slides were used at KOSSCON 2018 (https://kosscon.kr/).
Design choices of golang for high scalabilitySeongJae Park
This document summarizes some key design choices of the Go programming language that enable it to achieve high scalability. It discusses how Go uses lightweight goroutines instead of operating system threads to minimize context switching overhead. Goroutines only switch contexts in well-defined situations and have very small and dynamically sized stacks for efficient memory usage. The document also covers how Go uses cooperative scheduling and runs goroutines in user space for high performance without kernel transitions.
Kselftest is a developer-friendly test framework and set of tests for the Linux kernel. It aims to help developers test the kernel more easily and frequently. Tests are contained in the kernel source code and can be built, run, installed, and packaged quickly and easily. Writing new tests and using the test code as documentation makes kselftest a good starting point for new kernel developers.
Understanding of linux kernel memory modelSeongJae Park
SeongJae Park introduces himself and his work contributing to the Linux kernel memory model documentation. He developed a guaranteed contiguous memory allocator and maintains the Korean translation of the kernel's memory barrier documentation. The document discusses how the increasing prevalence of multi-core processors requires careful programming to ensure correct parallel execution given relaxed memory ordering. It notes that compilers and CPUs optimize for instruction throughput over programmer goals, and memory accesses can be reordered in ways that affect correctness on multi-processors. Understanding the memory model is important for writing high-performance parallel code.
Let the contribution begin (EST futures)SeongJae Park
The document discusses contributing to open source software as a newcomer. It recommends getting the source code, making small, targeted changes like fixing coding style issues, and submitting patches for review. The Linux kernel is presented as a popular project to start contributing to. Topic branches in version control are introduced as a way to develop changes separately before submitting them for merging.
gcma: guaranteed contiguous memory allocatorSeongJae Park
This document presents GCMA, a Guaranteed Contiguous Memory Allocator that improves upon the current Contiguous Memory Allocator (CMA) solution in Linux. CMA can have unpredictable latency and even fail when allocating contiguous memory, especially under memory pressure or with background workloads. GCMA guarantees fast latency for contiguous memory allocation, success of allocation, and reasonable memory utilization by using discardable memory as its secondary client instead of movable pages. Experimental results on a Raspberry Pi 2 show that GCMA has significantly faster allocation latency than CMA, keeps camera latency fast even with background workloads, and can improve overall system performance compared to CMA.
This document provides an introduction to the Go programming language by SeongJae Park. It discusses why Go was developed, including to address pains with dependency management, build speeds, type safety, garbage collection and multi-core support in other languages. It then demonstrates Go concepts like packages, functions, variables, structs and interfaces through a live coding example of a web server. Finally, it references a presentation that further explains Go's advantages for multicore programming.
The document discusses using Golang for mobile application development. It provides an example of building a pure Golang Android app without Java by compiling Golang code to a shared object library and using the NativeActivity. It also provides an example of using Golang as a library in a Java Android app by generating bindings between Golang and Java code. Additionally, it proposes an approach for running a standalone Golang process on Android by cross-compiling Golang code to ARM/Linux and executing it from an Android app.
This document summarizes different approaches for using the Go programming language to build Android applications. It discusses building a pure Go app using the NativeActivity class, integrating Go as a library using bindings, and spawning separate Go processes from an Android app using inter-process communication. Code examples are provided for each approach. While Go support for Android is still unstable, these techniques allow Go to be used for simple Android projects as an alternative to Java.
The document discusses the author's experience installing software both with and without Docker. Installing without Docker was a "miserable experience" with issues like the software not working, needing to install additional dependencies, modifying sources and rebuilding, incorrect path configurations, installing other versions, and eventually reinstalling the OS just to get it to work, though the reason it finally worked was unknown. Installing with Docker was much simpler - just install Docker, get the Docker image or Dockerfile for the app, and run it. With Docker, containers are isolated so new installations never conflict with existing ones. The author concludes that Docker makes installation a better experience.
(Live) build and run golang web server on android.aviSeongJae Park
Presented from gdg devfair 2014 and gdg korea golang seoul meetup 2015.
Added explanation about go 1.4 official android support a little from gdg korea golang seoul meetup presentation.
This document discusses Git and provides an introduction to its basic concepts and functionality. It begins by introducing Git as a distributed version control system created by Linus Torvalds to manage Linux code. It then notes that many projects use Git because it is powerful. Finally, it summarizes that at its core, Git is a content-addressable file system based around blobs, trees, commits and references.
Experimental android hacking using reflectionSeongJae Park
This document discusses using reflection in Android to access hidden and restricted features. It describes how Android separates interfaces for third-party and built-in apps. It then explains how reflection can be used to change the interface and allow third-party apps to access features usually only available to built-in apps, with examples of how to end a call via reflection. However, it notes reflection has limitations like performance overhead and may not work on all devices.
This document introduces "ash", a shell that allows controlling multiple devices with a single interface. Ash uses a text-based command language to send commands over a network to remotely control devices installed with the ash application. The architecture includes an evaluator that parses commands, a user interface, and device controllers. Commands can register functions and callbacks. The code is structured as lists, and ash supports interfaces from Android, Ubuntu, OSX, and Windows.
This document provides information about hacking with Arduino and the Android Open Accessory Development Kit (ADK). It includes instructions on installing the ADK, debugging Arduino code, and an example code walkthrough. Suggested hack projects include building a keyboard that takes input from an Android device's screen and controls LEDs and tones on an Arduino board.
Describe how to contribute to open source projects.
Provide example process using two hot open source project, linux and AOSP(Android Open Source Project)
How Valletta helped healthcare SaaS to transform QA and compliance to grow wi...Egor Kaleynik
This case study explores how we partnered with a mid-sized U.S. healthcare SaaS provider to help them scale from a successful pilot phase to supporting over 10,000 users—while meeting strict HIPAA compliance requirements.
Faced with slow, manual testing cycles, frequent regression bugs, and looming audit risks, their growth was at risk. Their existing QA processes couldn’t keep up with the complexity of real-time biometric data handling, and earlier automation attempts had failed due to unreliable tools and fragmented workflows.
We stepped in to deliver a full QA and DevOps transformation. Our team replaced their fragile legacy tests with Testim’s self-healing automation, integrated Postman and OWASP ZAP into Jenkins pipelines for continuous API and security validation, and leveraged AWS Device Farm for real-device, region-specific compliance testing. Custom deployment scripts gave them control over rollouts without relying on heavy CI/CD infrastructure.
The result? Test cycle times were reduced from 3 days to just 8 hours, regression bugs dropped by 40%, and they passed their first HIPAA audit without issue—unlocking faster contract signings and enabling them to expand confidently. More than just a technical upgrade, this project embedded compliance into every phase of development, proving that SaaS providers in regulated industries can scale fast and stay secure.
Microsoft AI Nonprofit Use Cases and Live Demo_2025.04.30.pdfTechSoup
In this webinar we will dive into the essentials of generative AI, address key AI concerns, and demonstrate how nonprofits can benefit from using Microsoft’s AI assistant, Copilot, to achieve their goals.
This event series to help nonprofits obtain Copilot skills is made possible by generous support from Microsoft.
What You’ll Learn in Part 2:
Explore real-world nonprofit use cases and success stories.
Participate in live demonstrations and a hands-on activity to see how you can use Microsoft 365 Copilot in your own work!
This presentation explores code comprehension challenges in scientific programming based on a survey of 57 research scientists. It reveals that 57.9% of scientists have no formal training in writing readable code. Key findings highlight a "documentation paradox" where documentation is both the most common readability practice and the biggest challenge scientists face. The study identifies critical issues with naming conventions and code organization, noting that 100% of scientists agree readable code is essential for reproducible research. The research concludes with four key recommendations: expanding programming education for scientists, conducting targeted research on scientific code quality, developing specialized tools, and establishing clearer documentation guidelines for scientific software.
Presented at: The 33rd International Conference on Program Comprehension (ICPC '25)
Date of Conference: April 2025
Conference Location: Ottawa, Ontario, Canada
Preprint: https://arxiv.org/abs/2501.10037
PDF Reader Pro Crack Latest Version FREE Download 2025mu394968
🌍📱👉COPY LINK & PASTE ON GOOGLE https://dr-kain-geera.info/👈🌍
PDF Reader Pro is a software application, often referred to as an AI-powered PDF editor and converter, designed for viewing, editing, annotating, and managing PDF files. It supports various PDF functionalities like merging, splitting, converting, and protecting PDFs. Additionally, it can handle tasks such as creating fillable forms, adding digital signatures, and performing optical character recognition (OCR).
Douwan Crack 2025 new verson+ License codeaneelaramzan63
Copy & Paste On Google >>> https://dr-up-community.info/
Douwan Preactivated Crack Douwan Crack Free Download. Douwan is a comprehensive software solution designed for data management and analysis.
⭕️➡️ FOR DOWNLOAD LINK : http://drfiles.net/ ⬅️⭕️
Maxon Cinema 4D 2025 is the latest version of the Maxon's 3D software, released in September 2024, and it builds upon previous versions with new tools for procedural modeling and animation, as well as enhancements to particle, Pyro, and rigid body simulations. CG Channel also mentions that Cinema 4D 2025.2, released in April 2025, focuses on spline tools and unified simulation enhancements.
Key improvements and features of Cinema 4D 2025 include:
Procedural Modeling: New tools and workflows for creating models procedurally, including fabric weave and constellation generators.
Procedural Animation: Field Driver tag for procedural animation.
Simulation Enhancements: Improved particle, Pyro, and rigid body simulations.
Spline Tools: Enhanced spline tools for motion graphics and animation, including spline modifiers from Rocket Lasso now included for all subscribers.
Unified Simulation & Particles: Refined physics-based effects and improved particle systems.
Boolean System: Modernized boolean system for precise 3D modeling.
Particle Node Modifier: New particle node modifier for creating particle scenes.
Learning Panel: Intuitive learning panel for new users.
Redshift Integration: Maxon now includes access to the full power of Redshift rendering for all new subscriptions.
In essence, Cinema 4D 2025 is a major update that provides artists with more powerful tools and workflows for creating 3D content, particularly in the fields of motion graphics, VFX, and visualization.
TestMigrationsInPy: A Dataset of Test Migrations from Unittest to Pytest (MSR...Andre Hora
Unittest and pytest are the most popular testing frameworks in Python. Overall, pytest provides some advantages, including simpler assertion, reuse of fixtures, and interoperability. Due to such benefits, multiple projects in the Python ecosystem have migrated from unittest to pytest. To facilitate the migration, pytest can also run unittest tests, thus, the migration can happen gradually over time. However, the migration can be timeconsuming and take a long time to conclude. In this context, projects would benefit from automated solutions to support the migration process. In this paper, we propose TestMigrationsInPy, a dataset of test migrations from unittest to pytest. TestMigrationsInPy contains 923 real-world migrations performed by developers. Future research proposing novel solutions to migrate frameworks in Python can rely on TestMigrationsInPy as a ground truth. Moreover, as TestMigrationsInPy includes information about the migration type (e.g., changes in assertions or fixtures), our dataset enables novel solutions to be verified effectively, for instance, from simpler assertion migrations to more complex fixture migrations. TestMigrationsInPy is publicly available at: https://github.com/altinoalvesjunior/TestMigrationsInPy.
What Do Contribution Guidelines Say About Software Testing? (MSR 2025)Andre Hora
Software testing plays a crucial role in the contribution process of open-source projects. For example, contributions introducing new features are expected to include tests, and contributions with tests are more likely to be accepted. Although most real-world projects require contributors to write tests, the specific testing practices communicated to contributors remain unclear. In this paper, we present an empirical study to understand better how software testing is approached in contribution guidelines. We analyze the guidelines of 200 Python and JavaScript open-source software projects. We find that 78% of the projects include some form of test documentation for contributors. Test documentation is located in multiple sources, including CONTRIBUTING files (58%), external documentation (24%), and README files (8%). Furthermore, test documentation commonly explains how to run tests (83.5%), but less often provides guidance on how to write tests (37%). It frequently covers unit tests (71%), but rarely addresses integration (20.5%) and end-to-end tests (15.5%). Other key testing aspects are also less frequently discussed: test coverage (25.5%) and mocking (9.5%). We conclude by discussing implications and future research.
Adobe Master Collection CC Crack Advance Version 2025kashifyounis067
🌍📱👉COPY LINK & PASTE ON GOOGLE http://drfiles.net/ 👈🌍
Adobe Master Collection CC (Creative Cloud) is a comprehensive subscription-based package that bundles virtually all of Adobe's creative software applications. It provides access to a wide range of tools for graphic design, video editing, web development, photography, and more. Essentially, it's a one-stop-shop for creatives needing a broad set of professional tools.
Key Features and Benefits:
All-in-one access:
The Master Collection includes apps like Photoshop, Illustrator, InDesign, Premiere Pro, After Effects, Audition, and many others.
Subscription-based:
You pay a recurring fee for access to the latest versions of all the software, including new features and updates.
Comprehensive suite:
It offers tools for a wide variety of creative tasks, from photo editing and illustration to video editing and web development.
Cloud integration:
Creative Cloud provides cloud storage, asset sharing, and collaboration features.
Comparison to CS6:
While Adobe Creative Suite 6 (CS6) was a one-time purchase version of the software, Adobe Creative Cloud (CC) is a subscription service. CC offers access to the latest versions, regular updates, and cloud integration, while CS6 is no longer updated.
Examples of included software:
Adobe Photoshop: For image editing and manipulation.
Adobe Illustrator: For vector graphics and illustration.
Adobe InDesign: For page layout and desktop publishing.
Adobe Premiere Pro: For video editing and post-production.
Adobe After Effects: For visual effects and motion graphics.
Adobe Audition: For audio editing and mixing.
Secure Test Infrastructure: The Backbone of Trustworthy Software DevelopmentShubham Joshi
A secure test infrastructure ensures that the testing process doesn’t become a gateway for vulnerabilities. By protecting test environments, data, and access points, organizations can confidently develop and deploy software without compromising user privacy or system integrity.
Download YouTube By Click 2025 Free Full Activatedsaniamalik72555
Copy & Past Link 👉👉
https://dr-up-community.info/
"YouTube by Click" likely refers to the ByClick Downloader software, a video downloading and conversion tool, specifically designed to download content from YouTube and other video platforms. It allows users to download YouTube videos for offline viewing and to convert them to different formats.
F-Secure Freedome VPN 2025 Crack Plus Activation New Versionsaimabibi60507
Copy & Past Link 👉👉
https://dr-up-community.info/
F-Secure Freedome VPN is a virtual private network service developed by F-Secure, a Finnish cybersecurity company. It offers features such as Wi-Fi protection, IP address masking, browsing protection, and a kill switch to enhance online privacy and security .
How to Batch Export Lotus Notes NSF Emails to Outlook PST Easily?steaveroggers
Migrating from Lotus Notes to Outlook can be a complex and time-consuming task, especially when dealing with large volumes of NSF emails. This presentation provides a complete guide on how to batch export Lotus Notes NSF emails to Outlook PST format quickly and securely. It highlights the challenges of manual methods, the benefits of using an automated tool, and introduces eSoftTools NSF to PST Converter Software — a reliable solution designed to handle bulk email migrations efficiently. Learn about the software’s key features, step-by-step export process, system requirements, and how it ensures 100% data accuracy and folder structure preservation during migration. Make your email transition smoother, safer, and faster with the right approach.
Read More:- https://www.esofttools.com/nsf-to-pst-converter.html
WinRAR Crack for Windows (100% Working 2025)sh607827
copy and past on google ➤ ➤➤ https://hdlicense.org/ddl/
WinRAR Crack Free Download is a powerful archive manager that provides full support for RAR and ZIP archives and decompresses CAB, ARJ, LZH, TAR, GZ, ACE, UUE, .
Exceptional Behaviors: How Frequently Are They Tested? (AST 2025)Andre Hora
Exceptions allow developers to handle error cases expected to occur infrequently. Ideally, good test suites should test both normal and exceptional behaviors to catch more bugs and avoid regressions. While current research analyzes exceptions that propagate to tests, it does not explore other exceptions that do not reach the tests. In this paper, we provide an empirical study to explore how frequently exceptional behaviors are tested in real-world systems. We consider both exceptions that propagate to tests and the ones that do not reach the tests. For this purpose, we run an instrumented version of test suites, monitor their execution, and collect information about the exceptions raised at runtime. We analyze the test suites of 25 Python systems, covering 5,372 executed methods, 17.9M calls, and 1.4M raised exceptions. We find that 21.4% of the executed methods do raise exceptions at runtime. In methods that raise exceptions, on the median, 1 in 10 calls exercise exceptional behaviors. Close to 80% of the methods that raise exceptions do so infrequently, but about 20% raise exceptions more frequently. Finally, we provide implications for researchers and practitioners. We suggest developing novel tools to support exercising exceptional behaviors and refactoring expensive try/except blocks. We also call attention to the fact that exception-raising behaviors are not necessarily “abnormal” or rare.
4. Git
DVCS(Distributed Version Control System)
Made-by Linus Torvalds For Linux
http://git-scm.com/images/logos/downloads/Git-Logo-2Color.png
http://cdn.memegenerator.net/instances/400x/37078331.jpg
5. Git
Many Projects Use Git Because It’s Awesome
http://blog.appliedis.com/wp-content/uploads/2013/11/android1.png
http://upload.wikimedia.org/wikipedia/en/4/40/Octocat,_a_Mascot_of_Github.jpg
http://upload.wikimedia.org/wikipedia/commons/thumb/3/35/Tux.svg/512px-Tux.svg.png
http://git-scm.com/images/logos/downloads/Git-Logo-2Color.png
6. Git
Hard To Learn
Confusing For CVCS Users
Push? Pull? Fetch? Rebase? HEAD???
http://www.quickmeme.com/img/fd/fd09e17b3393b2ea1cd7e52af1ad7c77f3c2d7a83e9f47d4b90ba3af52dde329.jpg
http://git-scm.com/images/logos/downloads/Git-Logo-2Color.png
7. Git: The Information Manager From Hell
http://www.youblob.com/sites/default/files/styles/large/public/field/image/frontlego1.png?itok=XA5CXt84
8. Git: The Information Manager From Hell
$ git log e83c516
commit e83c5163316f89bfbde7d9ab23ca2e25604af290
Author: Linus Torvalds <[email protected]>
Date: Thu Apr 7 15:13:13 2005 -0700
Initial revision of "git", the information manager from hell
http://www.youblob.com/sites/default/files/styles/large/public/field/image/frontlego1.png?itok=XA5CXt84
9. Git: The Information Manager From Hell
That’s Why So Confusing And Hard To Learn
$ git log e83c516
commit e83c5163316f89bfbde7d9ab23ca2e25604af290
Author: Linus Torvalds <[email protected]>
Date: Thu Apr 7 15:13:13 2005 -0700
Initial revision of "git", the information manager from hell
http://www.youblob.com/sites/default/files/styles/large/public/field/image/frontlego1.png?itok=XA5CXt84
10. This Time, We Will...
See How Git Works From The Scratch
https://lh4.googleusercontent.com/gBpfuABUjSNi2RagtJrGi8TW-pmtgak_0qtGOGubihvKH-5-umreO9C
wJgjX2kaA9E7RkLwtEwiDnoMtOgm4iMJ0IWhvXlzlKL1kNVUYWuNa-gLRtRoyNjkVYg
11. This Time, We Will...
See How Git Works From The Scratch
Just For Fun
...Or To Be Friend Of Git
https://lh4.googleusercontent.com/gBpfuABUjSNi2RagtJrGi8TW-pmtgak_0qtGOGubihvKH-5-umreO9C
wJgjX2kaA9E7RkLwtEwiDnoMtOgm4iMJ0IWhvXlzlKL1kNVUYWuNa-gLRtRoyNjkVYg
12. This Time, We Will...
See How Git Works From The Scratch
Just For Fun
...Or To Be Friend Of Git
Forget About The
Complicated Commands
This Time
https://lh4.googleusercontent.com/gBpfuABUjSNi2RagtJrGi8TW-pmtgak_0qtGOGubihvKH-5-umreO9C
wJgjX2kaA9E7RkLwtEwiDnoMtOgm4iMJ0IWhvXlzlKL1kNVUYWuNa-gLRtRoyNjkVYg
13. In Short,
Git Is A Content-Addressable Storage System
http://www.juliagiff.com/wp-content/uploads/2014/03/tld
r_trollcat.jpg
14. In Short,
Git Is A Content-Addressable Storage System
Blob, Tree, Commit, Reference. That’s It =3
http://www.juliagiff.com/wp-content/uploads/2014/03/tld
r_trollcat.jpg
15. Plumbers: Unsung Heroes Behind
● Git Looks Graceful Owing To Plumbing
Commands Consisting Them
http://cfile4.uf.tistory.com/image/182FF7244CFDDFB33CC999
http://cfile29.uf.tistory.com/image/18574F224CFDD89B163073
16. Plumbers: Unsung Heroes Behind
● Git Looks Graceful Owing To Plumbing
Commands Consisting Them
○ The Wounded Foots Are What We Interested In
http://cfile4.uf.tistory.com/image/182FF7244CFDDFB33CC999
http://cfile29.uf.tistory.com/image/18574F224CFDD89B163073
33. Brute-force Idea
Rename / Backup Every Files Whenever
Change Made
$ ls
foo.c
foo_20140111.c
foo_final.c
34. Brute-force Idea
Rename / Backup Every Files Whenever
Change Made
$ ls
foo.c
foo_20140111.c
foo_final.c
foo_realfinal.c
foo_planb.c
foo_finalfinal.c
35. Brute-force Idea
Rename / Backup Every Files Whenever
Change Made
$ ls
foo.c
foo_20140111.c
foo_final.c
foo_realfinal.c
foo_planb.c
foo_finalfinal.c
36. Brute-force Idea + History Isolation
Keep Working / History Directory Seperately.
37. Brute-force Idea + History Isolation
Keep Working / History Directory Seperately.
Better, But...
$ find . -type f
./working/foo.c
./history/foo_20140111.c
./history/foo_final.c
./history/foo_realfinal.c
./history/foo_planb.c
./history/foo_finalfinal.c
49. What `hash-object -w` did
hash_object_w(‘homern’)
# Save compressed header + content at sha1 path
def hash_object_w(content):
header = ‘blob %d0’ % len(content)
store = header + content
sha1 = sha.new(store).hexdigest()
50. What `hash-object -w` did
hash_object_w(‘homern’)
# Save compressed header + content at sha1 path
def hash_object_w(content):
header = ‘blob %d0’ % len(content)
store = header + content
sha1 = sha.new(store).hexdigest()
dir = ‘.git/objects/’ + sha1[0:2] + ‘/’
filename = sha1[2:]
51. What `hash-object -w` did
hash_object_w(‘homern’)
# Save compressed header + content at sha1 path
def hash_object_w(content):
header = ‘blob %d0’ % len(content)
store = header + content
sha1 = sha.new(store).hexdigest()
dir = ‘.git/objects/’ + sha1[0:2] + ‘/’
filename = sha1[2:]
open(dir + filename, ‘w’).write(
zlib.compress(store))
52. Version Control Using Hash Value
$ echo “bart” > son
$ git hash-object -w son
e00ddae83bdab443f4267426623aa34636c935f2
$
53. Version Control Using Hash Value
$ echo “bart” > son
$ git hash-object -w son
e00ddae83bdab443f4267426623aa34636c935f2
$ echo “hugo” > son
$ git hash-object -w son
8e1e2f09585e021c9727585af72e10871d7be7ce
$
54. Version Control Using Hash Value
$ echo “bart” > son
$ git hash-object -w son
e00ddae83bdab443f4267426623aa34636c935f2
$ echo “hugo” > son
$ git hash-object -w son
8e1e2f09585e021c9727585af72e10871d7be7ce
$
# Need former version, “bart”
$ git cat-file -p e00dd > son
$ cat son
bart
55. TODOs From Version Control Using FS
Use Storage Space-Efficiently
Easy History Searching
56. Version Control Using Hash Value
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
57. Version Control Using Hash Value
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
● TODO
○ Support Directory Structure
○ History Management
○ Better Reference Than Hash Value
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
59. WAIT!
Q: What If Small Changes Inside A Big File?
$ du -h bigfile.c
188Kbigfile.c
$ du -sh
408K.
$ echo ‘/* small change */’ >> bigfile.c
$ git commit -as -m “small change, big difference”
$ du -sh
496K.
$
60. WAIT!
Q: What If Small Change Inside A Big File?
A: Git Pick up Diff-Only If Necessary
But, Don’t Forget To Keep It Small, Simple
$ du -sh
496K.
$ git gc
Counting objects: 6, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (4/4), done.
Writing objects: 100% (6/6), done.
Total 6 (delta 1), reused 0 (delta 0)
$ du -sh
388K.
63. tree Object
Point Other Objects(Using Hash) With Name
tree
blob blob tree
blob
a113f2
mommy b8934
son
c9240
pets
d9b13
cat
64. tree Object
Point Other Objects(Using Hash) With Name
“A Root tree Object Is A Snapshot”
tree
blob blob tree
blob
a113f2
mommy b8934
son
c9240
pets
d9b13
cat
I’m a
snapshot
70. Version Control Using tree Object
$ echo “bart” > son
$ git update-index --add son
$ git write-tree
661e6ad514a7f05c46c2931280cb78a339d34ee2
$
71. Version Control Using tree Object
$ echo “bart” > son
$ git update-index --add son
$ git write-tree
661e6ad514a7f05c46c2931280cb78a339d34ee2
$ git cat-file -p 661e6
040000 tree 85ab72cf1946dc56392718a1aafb3c6f66c02072 pets
100644 blob e00ddae83bdab443f4267426623aa34636c935f2 son
$
72. Version Control Using tree Object
$ echo “bart” > son
$ git update-index --add son
$ git write-tree
661e6ad514a7f05c46c2931280cb78a339d34ee2
$ git cat-file -p 661e6
040000 tree 85ab72cf1946dc56392718a1aafb3c6f66c02072 pets
100644 blob e00ddae83bdab443f4267426623aa34636c935f2 son
$ git cat-file -p e00dd
bart
$
75. Version Control Using Hash Value
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
● TODO
○ Support Directory Structure
○ History Management
○ Better Reference Than Hash Value
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
76. Version Control Using tree Object
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
○ Support Directory Structure
● TODO
○ History Management
○ Better Reference Than Hash Value
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
78. commit Object
Describe Who / When / Why The Change Made
http://modthink.com/wp-content/uploads/2013/05/WhoWhatWhenWhereWHY.jpg
79. commit Object
Describe Who / When / Why The Change Made
Point A tree Object With Information Above
http://modthink.com/wp-content/uploads/2013/05/WhoWhatWhenWhereWHY.jpg
82. commit Object
$ echo '1st commit' | git commit-tree 661e6
0ca7304ad6f5a40f8a26ba05b10b514ff2d8d8a0
$
$ git cat-file -p d075c
tree 661e6ad514a7f05c46c2931280cb78a339d34ee2
author SeongJae Park <s**@gmail.com> 1410527921 +0900
committer SeongJae Park <s**@gmail.com> 1410527921 +0900
1st commit
$
Who When
Why
83. Version Control Using commit Object
$ echo '2nd commit' | git commit-tree 15ee7 -p 0ca73
003b5e66caa89a6228c7b4d91e0475e56bf1bdf6
$
$ git cat-file -p 003b5
tree 15ee76ed3e744b6796950d07f26283d033ea3ea7
parent 0ca7304ad6f5a40f8a26ba05b10b514ff2d8d8a0
author SeongJae Park <s**@gmail.com> 1410528231 +0900
committer SeongJae Park <s**@gmail.com> 1410528231 +0900
2nd commit
$
84. Internal Data Structure
That’s Why People Says, “A Commit is a
snapshot”
tree
blob tree
blob
tree
blob
commit commit
tree
parent
tree
85ab7
pets
8e1e2
son
85ab7
pets
6a1f9
cat
e00dd
son
85. Version Control Using tree Object
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
○ Support Directory Structure
● TODO
○ History Management
○ Better Reference Than Hash Value
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
86. Version Control Using commit Object
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
○ Support Directory Structure
○ Manage History Well
● TODO
○ Better Reference Than Hash Value
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
97. Internal Data Structure
tree
blob tree
blob
tree
blob
commit commit
tree
parent
tree
85ab7
pets
8e1e2
son
85ab7
pets
e00dd
son
6a1f9
cat
98. Internal Data Structure
tree
blob tree
blob
tree
blob
commit commit
tree
parent
tree
refs/heads/
master
refs/heads/
first
85ab7
pets
8e1e2
son
85ab7
pets
e00dd
son
6a1f9
cat
99. Version Control Using commit Object
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
○ Support Directory Structure
○ Manage History Well
● TODO
○ Better Reference Than Hash Value
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
100. Version Control Using Reference
● DONE
○ Efficient Space Usage
○ Safe Record / Checkout Of History
○ Support Directory Structure
○ Manage History Well
○ Easy To Remember Specific Snapshot
● TODO
○ ...cooperation?
https://www.sciencenews.org/sites/default/files/main/articles/sad_opener.jpg
107. HEAD
$ cat .git/HEAD
ref: refs/heads/master
$ git branch
first
* master
$
$ git symbolic-ref HEAD refs/heads/first
$ cat .git/HEAD
ref: refs/heads/first
$ git branch
* first
master
108. Internal Data Structure
tree
blob tree
blob
tree
blob
commit commit
tree
parent
tree
refs/heads/
master
refs/heads/
first
85ab7
pets
8e1e2
son
85ab7
pets
e00dd
son
6a1f9
cat
109. Internal Data Structure
tree
blob tree
blob
tree
blob
commit commit
tree
parent
tree
refs/heads/
master
refs/heads/
first
.git/HEAD
85ab7
pets
8e1e2
son
85ab7
pets
e00dd
son
6a1f9
cat
112. Fetch
● Just Fetch Remote Repository’s Objects And
References To Local Git Internal Storage
113. Fetch
● Just Fetch Remote Repository’s Objects And
References To Local Git Internal Storage
● If You Need The Changes On Your Working
Directory,
114. Fetch
● Just Fetch Remote Repository’s Objects And
References To Local Git Internal Storage
● If You Need The Changes On Your Working
Directory,
○ Manually Merge Them Using git-merge Or,
○ Checkout
116. Fetch: Before
url = git://10.0.0.1/git/simpsons.git
fetch = +refs/heads/*:refs/remotes/origin/*
tree
blob tree
blob
a134f
son
799cf
pets
7cc07
cat
tree
blob
65464
son
799cf
pets
commit commit
tree
parent
tree
refs/
heads/
master
.git/
HEAD
git://10.0.0.1/git/simpsons.git
tree
blob tree
blob
a134f
son
799cf
pets
7cc07
cat
commit
tree
refs/
heads/
master
.git/
HEAD
file:///home/sjpark/simpsons
117. Fetch: After
url = git://10.0.0.1/git/simpsons.git
fetch = +refs/heads/*:refs/remotes/origin/*
tree
blob tree
blob
a134f
son
799cf
pets
7cc07
cat
tree
blob
65464
son
799cf
pets
commit commit
tree
parent
tree
refs/
heads/
master
.git/
HEAD
git://10.0.0.1/git/simpsons.git
tree
blob tree
blob
a134f
son
799cf
pets
7cc07
cat
tree
blob
65464
son
799cf
pets
commit commit
tree
parent
tree
refs/
remotes/
origin/
master
refs/
heads/
master
.git/
HEAD
file:///home/sjpark/simpsons
118. git merge origin/master
tree
blob tree
blob
a134f
son
799cf
pets
7cc07
cat
tree
blob
65464
son
799cf
pets
commit commit
tree
parent
tree
refs/
remotes/
origin/
master
refs/
heads/
first
.git/
HEAD
tree
blob tree
blob
a134f
son
799cf
pets
7cc07
cat
tree
blob
65464
son
799cf
pets
commit commit
tree
parent
tree
refs/
remotes/
origin/
master
refs/
heads/
first
.git/
HEAD
119. Pull
Pull Is Just An Abbrev Of Fetch && Merge
May Merge Conflict Occur…
Pull Is Sufficient For Simple Project
121. In Short,
Git Is A Content-Addressable File System
Blob, Tree, Commit, Reference. That’s It =3
http://www.juliagiff.com/wp-content/uploads/2014/03/tld
r_trollcat.jpg
125. This slide has been used for
Samsung Open Source CONference 2014
126. This work by SeongJae Park is licensed under the
Creative Commons Attribution-ShareAlike 3.0 Unported
License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-sa/3.0/.