The document discusses the basics of Git version control system. It begins with an overview of key Git concepts like snapshots of the project files rather than file differences. It then demonstrates Git functionality through a simple example of adding, modifying and renaming files in a sample project. The example shows how Git records the changes through commits and is able to reconstruct previous versions of the files from snapshots. It also touches on concepts like branches and merges.
My Notes from https://www.codeschool.com/courses/git-realEneldo Serrata
This document contains notes from a Git tutorial on CodeSchool. It outlines the steps and commands for various Git workflows including initializing a repository, staging and committing files, branching and merging, resolving conflicts, tagging releases, and more. The notes are formatted as questions with the corresponding Git commands to perform each task.
Git is a distributed version control system that allows developers to work on codebases simultaneously and merge changes easily. It uses a local repository that can be synced to remote repositories hosted on services like GitHub. Developers clone repositories, make changes on branches, commit locally, and push updates to the remote. Git addresses issues like file locking and enables features like easy merging and reverting changes. Stashing is used to temporarily store uncommitted changes when switching branches. GUI clients and documentation on sites like GitHub help users learn and use Git's powerful capabilities for collaboration.
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.
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.
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.
Deep dark-side of git: How git works internallySeongJae Park
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.
GIT: Content-addressable filesystem and Version Control SystemTommaso Visconti
Git presentation, internals, advanced use and workflow examples.
Presentation by Tommaso Visconti http://www.tommyblue.it for DrWolf srl http://www.drwolf.it
Working with Git – a simple introduction for those used to working with a VCS like Subversion. Explains concepts and shows examples. Feel free to steal slides for your own purposes.
My Notes from https://www.codeschool.com/courses/git-realEneldo Serrata
This document contains notes from a Git tutorial on CodeSchool. It outlines the steps and commands for various Git workflows including initializing a repository, staging and committing files, branching and merging, resolving conflicts, tagging releases, and more. The notes are formatted as questions with the corresponding Git commands to perform each task.
Git is a distributed version control system that allows developers to work on codebases simultaneously and merge changes easily. It uses a local repository that can be synced to remote repositories hosted on services like GitHub. Developers clone repositories, make changes on branches, commit locally, and push updates to the remote. Git addresses issues like file locking and enables features like easy merging and reverting changes. Stashing is used to temporarily store uncommitted changes when switching branches. GUI clients and documentation on sites like GitHub help users learn and use Git's powerful capabilities for collaboration.
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.
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.
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.
Deep dark-side of git: How git works internallySeongJae Park
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.
GIT: Content-addressable filesystem and Version Control SystemTommaso Visconti
Git presentation, internals, advanced use and workflow examples.
Presentation by Tommaso Visconti http://www.tommyblue.it for DrWolf srl http://www.drwolf.it
Working with Git – a simple introduction for those used to working with a VCS like Subversion. Explains concepts and shows examples. Feel free to steal slides for your own purposes.
The document discusses common mistakes made in file input/output (I/O) that can lead to data loss. It notes that asynchronous I/O is faster than synchronous I/O but introduces consistency issues. File systems provide weaker consistency guarantees than databases, and operations like close() and rename() do not guarantee data is flushed to disk. The document recommends using transactions and writing to a temporary file followed by renaming to improve data durability.
This document provides an introduction to using Git. Some key points:
- Git is a distributed version control system that is different from CVS/SVN in that nearly every operation is local and Git stores snapshots of files rather than differences.
- The basics of using Git involve recording changes by checking status, adding files, committing changes, and working with remotes like origin.
- Additional topics covered include undoing changes, working with others through branching and merging, tagging versions, and using tools like interactive mode and stashing.
Git commands allow users to manage source code repositories. Some key commands include git init to create a new local repository, git clone to download an existing repository, and git status to check the status. Other useful commands allow viewing commit history and filtering it, adding and committing files, creating and switching branches, merging branches, and pushing/pulling from remote repositories.
Introduction to Git (even for non-developers!)John Anderson
Git is a revision control system that is used for many Open Source projects. Having a basic understanding of Git is essential to being able to join an Open Source project and become a contributor. It's also super useful for many other activities! This talk will explore the basics of Git, assuming no existing background experience. Via analogies to other, familiar technolgies, the basic principles of using Git will be explained in an approachable, understandable fashion. People who attend this talk should come away ready to make an initial contribution to an Open Source project, and will leave with a list of additional resources to explore to learn more.
This document provides an overview of using Git version control system, including:
1. The different types of version control systems like local (LVCS), centralized (CVCS), and distributed (DVCS) like Git.
2. Basic Git commands and workflows for creating a repository, adding/committing files, tagging versions, branching, merging, and working with remotes.
3. Examples of common branching workflows for topics, long-running branches, hotfixes, and merging branches with conflicts.
4. How to push/pull from remote repositories, delete remote branches, and work with tracking branches.
Git & Github Workshop - Le Wagon MelbournePaal Ringstad
This document provides an introduction to Git and GitHub for beginners. It covers the basics of version control using Git locally including initializing a repository, making commits, and branching. It then demonstrates how to use Git with GitHub for collaboration by cloning a remote repository, making changes on a branch, and opening a pull request. The document includes challenges for learning Git and GitHub hands-on through pair programming exercises like creating a new project, committing changes, merging branches, and contributing to an open source project on GitHub.
This document introduces Git and its advantages over other version control systems like Subversion. It discusses how Git allows for faster operations, offline work, collaboration through branching and merging, compatibility with SVN, and powerful tools for tasks like bisecting commits. Key features of Git like staging changes, committing to the local repository, pushing and pulling from remote repositories, and using commands entirely offline are also outlined.
The document discusses adding source control to development workflows. It recommends using a version control system like Git to manage code and collaborate with others. It provides instructions for setting up a local Git repository, branching, committing changes, merging branches, and pushing code to remote repositories hosted on servers or GitHub. The document aims to demonstrate how source control can improve productivity and make development workflows more robust.
Introducing Git to your FTP workflow covers some basic Git concepts and then shows couple of schemes to use git for publishing web content. Not much words, so I will try to write some blog post to complement it.
Git is a distributed version control system that stores snapshots of files rather than changes, allows for local branching and merging, and uses a three-way merge algorithm. It allows for both local and remote operations including branching, committing, pushing, pulling and merging changes. Enterprise adoption of Git requires secure access controls, user management, visualization and other features provided by specialized hosting services or add-ons like Gitolite, Gitosis or GitEnterprise.
This document is about Unix commands for bioinformaticians. It discusses Unix folders and files, processes, and redirection. It provides examples of commands for listing, moving, copying, reading and editing files. It also demonstrates running processes, controlling processes, and redirecting inputs/outputs. The goal is to introduce basic Unix skills like navigating the filesystem, working with files, and running programs needed for bioinformatics tasks.
The document provides an introduction to version control and Git. It discusses key Git concepts like snapshots vs deltas, local operations, and integrity checks via SHA-1 hashes. It covers setting up Git, creating and cloning repositories, tracking file status and changes, committing files, viewing commit history, branching and merging, and working with remote repositories by fetching, pulling and pushing changes.
GIT is a distributed version control system that allows for collaboration by keeping track of changes made to source code over time. It keeps snapshots of files and allows users to work offline or disconnected from servers. Unlike centralized systems, GIT considers data as snapshots of files rather than file-based changes, and each user has a full copy of the repository. Users can commit changes to their local repository and then push them to remote repositories. Common commands include add, commit, push, pull, branch, merge, and status.
Курс Java-2016. Занятие 04 (часть 2). Git и GitHub7bits
This document discusses setting up and using Git and GitHub for version control of a Java project. It explains how to initialize a Git repository, add and commit files, configure user information, check status and history, ignore files, connect to a remote GitHub repository, authenticate with SSH keys, and push code to GitHub. The steps taken are initializing a Git repository, adding files, committing with a message, configuring user details, viewing status and log, ignoring files, connecting to a remote repository, generating and adding SSH keys, and pushing the local code to the remote GitHub repository.
This document provides an overview of graphs and how they relate to Git. It explains that Git objects like blobs, trees, and commits form a directed acyclic graph (DAG). It discusses how working directory changes are staged and committed to create new commits in the repository. It also covers branching workflows and rewriting history using commands like rebase and reset. Key Git commands are demonstrated including add, commit, clone, pull, checkout, merge, rebase, reset, reflog, log and show.
lwref: insane idea on reference countingGleb Smirnoff
My presentation at BSDCan 2014 on very cheap reference counting mechanism for multiprocessor kernel. Based on a function that can be restarted due to being atomic to memory, despite being several instructions long.
The document describes a series of divide and merge operations performed on a set of numbers. The numbers are initially divided into smaller groups, then merged back together into a single sorted list of all the original numbers by the end.
The document provides an outline on installing and configuring Git, introduces common Git concepts and commands, discusses various Git workflows and hosting options on GitHub and Bitbucket, and includes examples of using Git in case studies. It covers topics such as setting up a local and global Git configuration, interacting with the staging area and working directory, branching and merging, and resolving conflicts. The document is intended to teach users the basics of using the popular version control system Git.
The document discusses common mistakes made in file input/output (I/O) that can lead to data loss. It notes that asynchronous I/O is faster than synchronous I/O but introduces consistency issues. File systems provide weaker consistency guarantees than databases, and operations like close() and rename() do not guarantee data is flushed to disk. The document recommends using transactions and writing to a temporary file followed by renaming to improve data durability.
This document provides an introduction to using Git. Some key points:
- Git is a distributed version control system that is different from CVS/SVN in that nearly every operation is local and Git stores snapshots of files rather than differences.
- The basics of using Git involve recording changes by checking status, adding files, committing changes, and working with remotes like origin.
- Additional topics covered include undoing changes, working with others through branching and merging, tagging versions, and using tools like interactive mode and stashing.
Git commands allow users to manage source code repositories. Some key commands include git init to create a new local repository, git clone to download an existing repository, and git status to check the status. Other useful commands allow viewing commit history and filtering it, adding and committing files, creating and switching branches, merging branches, and pushing/pulling from remote repositories.
Introduction to Git (even for non-developers!)John Anderson
Git is a revision control system that is used for many Open Source projects. Having a basic understanding of Git is essential to being able to join an Open Source project and become a contributor. It's also super useful for many other activities! This talk will explore the basics of Git, assuming no existing background experience. Via analogies to other, familiar technolgies, the basic principles of using Git will be explained in an approachable, understandable fashion. People who attend this talk should come away ready to make an initial contribution to an Open Source project, and will leave with a list of additional resources to explore to learn more.
This document provides an overview of using Git version control system, including:
1. The different types of version control systems like local (LVCS), centralized (CVCS), and distributed (DVCS) like Git.
2. Basic Git commands and workflows for creating a repository, adding/committing files, tagging versions, branching, merging, and working with remotes.
3. Examples of common branching workflows for topics, long-running branches, hotfixes, and merging branches with conflicts.
4. How to push/pull from remote repositories, delete remote branches, and work with tracking branches.
Git & Github Workshop - Le Wagon MelbournePaal Ringstad
This document provides an introduction to Git and GitHub for beginners. It covers the basics of version control using Git locally including initializing a repository, making commits, and branching. It then demonstrates how to use Git with GitHub for collaboration by cloning a remote repository, making changes on a branch, and opening a pull request. The document includes challenges for learning Git and GitHub hands-on through pair programming exercises like creating a new project, committing changes, merging branches, and contributing to an open source project on GitHub.
This document introduces Git and its advantages over other version control systems like Subversion. It discusses how Git allows for faster operations, offline work, collaboration through branching and merging, compatibility with SVN, and powerful tools for tasks like bisecting commits. Key features of Git like staging changes, committing to the local repository, pushing and pulling from remote repositories, and using commands entirely offline are also outlined.
The document discusses adding source control to development workflows. It recommends using a version control system like Git to manage code and collaborate with others. It provides instructions for setting up a local Git repository, branching, committing changes, merging branches, and pushing code to remote repositories hosted on servers or GitHub. The document aims to demonstrate how source control can improve productivity and make development workflows more robust.
Introducing Git to your FTP workflow covers some basic Git concepts and then shows couple of schemes to use git for publishing web content. Not much words, so I will try to write some blog post to complement it.
Git is a distributed version control system that stores snapshots of files rather than changes, allows for local branching and merging, and uses a three-way merge algorithm. It allows for both local and remote operations including branching, committing, pushing, pulling and merging changes. Enterprise adoption of Git requires secure access controls, user management, visualization and other features provided by specialized hosting services or add-ons like Gitolite, Gitosis or GitEnterprise.
This document is about Unix commands for bioinformaticians. It discusses Unix folders and files, processes, and redirection. It provides examples of commands for listing, moving, copying, reading and editing files. It also demonstrates running processes, controlling processes, and redirecting inputs/outputs. The goal is to introduce basic Unix skills like navigating the filesystem, working with files, and running programs needed for bioinformatics tasks.
The document provides an introduction to version control and Git. It discusses key Git concepts like snapshots vs deltas, local operations, and integrity checks via SHA-1 hashes. It covers setting up Git, creating and cloning repositories, tracking file status and changes, committing files, viewing commit history, branching and merging, and working with remote repositories by fetching, pulling and pushing changes.
GIT is a distributed version control system that allows for collaboration by keeping track of changes made to source code over time. It keeps snapshots of files and allows users to work offline or disconnected from servers. Unlike centralized systems, GIT considers data as snapshots of files rather than file-based changes, and each user has a full copy of the repository. Users can commit changes to their local repository and then push them to remote repositories. Common commands include add, commit, push, pull, branch, merge, and status.
Курс Java-2016. Занятие 04 (часть 2). Git и GitHub7bits
This document discusses setting up and using Git and GitHub for version control of a Java project. It explains how to initialize a Git repository, add and commit files, configure user information, check status and history, ignore files, connect to a remote GitHub repository, authenticate with SSH keys, and push code to GitHub. The steps taken are initializing a Git repository, adding files, committing with a message, configuring user details, viewing status and log, ignoring files, connecting to a remote repository, generating and adding SSH keys, and pushing the local code to the remote GitHub repository.
This document provides an overview of graphs and how they relate to Git. It explains that Git objects like blobs, trees, and commits form a directed acyclic graph (DAG). It discusses how working directory changes are staged and committed to create new commits in the repository. It also covers branching workflows and rewriting history using commands like rebase and reset. Key Git commands are demonstrated including add, commit, clone, pull, checkout, merge, rebase, reset, reflog, log and show.
lwref: insane idea on reference countingGleb Smirnoff
My presentation at BSDCan 2014 on very cheap reference counting mechanism for multiprocessor kernel. Based on a function that can be restarted due to being atomic to memory, despite being several instructions long.
The document describes a series of divide and merge operations performed on a set of numbers. The numbers are initially divided into smaller groups, then merged back together into a single sorted list of all the original numbers by the end.
The document provides an outline on installing and configuring Git, introduces common Git concepts and commands, discusses various Git workflows and hosting options on GitHub and Bitbucket, and includes examples of using Git in case studies. It covers topics such as setting up a local and global Git configuration, interacting with the staging area and working directory, branching and merging, and resolving conflicts. The document is intended to teach users the basics of using the popular version control system Git.
VLAN memungkinkan pembagian jaringan secara virtual tanpa terbatas lokasi fisik, mengurangi biaya administrasi jaringan dan meningkatkan keamanan komunikasi karena tujuan yang lebih spesifik.
This document provides information about two transportation projects being considered by a state government.
The first project involves constructing a 25km road over 2 years with an estimated cost of RM900 million. Benefits include reduced vehicle operating costs and travel time savings. The project is economically viable with a benefit-cost ratio of 4.47 and internal rate of return of 47%.
The second project involves constructing a 95km highway over 2 years with an estimated cost of RM998 million. The project will be privatized with a 17-year concession. Computations are provided to calculate the net present value of costs and benefits over the concession period using discount rates of 8% and 19%. The benefit-cost ratio is 1.0 and
This document discusses the Raspberry Pi single board computer. It provides details on the Raspberry Pi's specifications including its ARM processor, RAM, and Linux operating system. It describes possible uses for Raspberry Pi like home servers, web servers, and prototyping. The document outlines how to set up networking, install Java, and deploy web applications to a Raspberry Pi remotely. It also covers connecting hardware like reading analog sensors and controlling devices with digital outputs.
The document discusses a presentation about version control systems and intellectual property rights using Git as an example. It provides an overview of Git basics, comparing its snapshot-based model to Subversion's patch-based approach. It demonstrates how Git stores project files and changes as snapshots at different commit points, allowing access to previous versions.
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 is a presentation on Git and GitHub given by Olmo Maldonado. It introduces version control and why it is useful, especially for collaboration. It describes what Git and GitHub are and how they work together. The presentation walks through finding and following projects and users on GitHub. It also covers basic Git commands like cloning a repository, making changes, adding/committing, pushing changes to a remote repository, and creating/merging branches. It emphasizes using GitHub and pull requests for collaboration on projects.
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 and introduces the basics of using Git for version control. It discusses centralized and decentralized version control systems and why version control is useful. It then demonstrates how to set up and use basic Git commands like configuring user information, initializing a repository, adding and committing files, viewing logs and status, branching and merging, and resolving conflicts. Remote repositories on services like Beanstalk are also covered at a basic level.
Fun with Github webhooks: verifying Signed-off-byJeff Squyres
An overview of an afternoon project I noodled around with one day to play with Ruby and Github Webhooks. I surprised myself by creating something somewhat actually useful.
Presentation given to the Kentucky Open Source Society (KyOSS) on July 8, 2015.
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.
The document discusses a presentation on Git given by Colin Harrington at SpringOne 2GX 2010. It introduces Git as a free and open source distributed version control system. It highlights features such as branching and merging. It also contrasts Git with centralized version control systems like SVN and discusses basic Git commands and fundamentals like SHA hashes and the tree structure. The presentation includes demonstrations of using Git and interacting with remote repositories. It also discusses using Git with SVN repositories and contributing to projects like Grails.
FLOW3 spearheaded a move towards Git adoption within the TYPO3 project, and we are more pleased every day with the decision to turn away from Subversion and toward GIt.
In this session I explain the workflow we adopted using Git and the code review system Gerrit. I will show how it makes collaborative development more productive and improves code quality at the same time.
Git 101, or, how to sanely manage your Koha customizationsIan Walls
Git is a version control system that allows for distributed development and management of changes to source code. It can be used to manage customizations to the Koha integrated library system. Developers can clone the Koha repository, make changes on a branch, commit changes locally, and submit patches for review and inclusion in the main codebase. The process involves filing bug reports, attaching patches, getting sign-off from others, and keeping branches up to date with the main code.
Feedback en continu grâce au TDD et au AsCodeHaja R
The document discusses the concepts of test-driven development (TDD), continuous integration, infrastructure as code, and documentation as code. It provides examples of writing specifications, documentation, build pipelines, and infrastructure using code and formats like Markdown, YAML, Puppet, Ansible, Dockerfiles, and Docker Compose files. Emphasizing that treating all aspects of software development as code enables continuous feedback, communication, and versioning.
Oleksandr Yefremov Continuously delivering mobile projectАліна Шепшелей
This document discusses best practices for continuously delivering mobile projects. It outlines a CI/CD workflow that includes running tests and manual QA on pull requests, notifying stakeholders, automatically generating changelogs and version bumps, preparing release artifacts, and publishing them to stores or S3. Key steps are running tests on pull requests, using strict PR naming conventions, notifying teams in Slack, automating versioning and publishing with scripts and Fastlane, and deploying beta builds to Fabric/Crashlytics. The full workflow aims to streamline mobile releases by automating repetitive tasks and integrating all steps.
This document provides an introduction to Git and GitHub. It discusses what GitHub is and how it relates to Git. It then covers how to perform common Git and GitHub tasks like creating a repository, pushing and pulling changes, forking repositories, and making pull requests. The document also includes sections on Markdown formatting and resources for learning more about Git and GitHub.
This document provides instructions for getting started with Git and GitHub. It outlines the steps to install Git, create a GitHub account, download repositories from GitHub, fork repositories, create branches, create pull requests, and create your own repository. It also explains key Git concepts like version control, local and remote repositories, and the three trees in Git. The document recommends configuring user information and SSH keys. It demonstrates common Git commands like init, status, add, commit, push, pull, clone and checkout. It discusses merge conflicts and meaningful commit messages. Finally, it points to additional resources and provides a practice project for following the GitHub flow.
This document discusses Biicode, a code reuse platform that allows developers to easily share and reuse code across projects. It provides examples of how Biicode works, including creating a new project, adding dependencies on existing code, resolving dependencies, building projects, and publishing code for others to reuse. Biicode aims to simplify code reuse through features like automatic dependency management, versioning, collaboration tools, and metrics.
Distributing UI Libraries: in a post Web-Component worldRachael L Moore
Modern UI Component libraries influenced by Web Components will rely more heavily on package management than last generation UI Frameworks. In this 15 minute session we'll introduce package management for web graphical user interfaces, talk about the best package contents for a UI component, and some tactics for making smooth releases.
For video, skip to 57 minutes, 13 seconds (57:13), http://www.youtube.com/watch?v=BhP86d5IiM4&t=57m13s
Version Control Systems with git (and github) as an exampleGaurav Kumar Garg
Version control systems are programs or software to manage the source code of computer programs. Most of the open source projects are now hosted on github. So learning about git and github is very much necessary to learning and start contributing to the open source projects. In this presentation I hope to get the audience introduced to the basics of version control systems and learn the basics of git.
http://shdlr.com/conferences/talk/20332
Free The Enterprise With Ruby & Master Your Own DomainKen Collins
On the heals of Luis Lavena's RailsConf talk "Infiltrating Ruby Onto The Enterprise Death Star Using Guerilla Tactics" comes a local and frank talk about the current state of Open Source Software (OSS) participation from Windows developers. Learn what OSS is, what motivates its contributors, and how OSS can make you a stronger developer. Be prepared to fall in love with writing software again!
We will start off with a 101 introduction to both the Ruby programming language and the Ruby on Rails web application framework. You will learn about ActiveRecord, a powerful ORM that maps rich objects to your databases, and the latest components to use it with SQL Server. As a Rails core contributor and author of the SQL Server stack, I will give you a modern insight into both that will allow you to leverage your legacy data with Ruby.
Lastly, I will review the bleeding edge tools being actively created for Windows developers to ease the transition to Ruby, Rails and OSS from a POSIX driven world. Many things have changed. It is time to learn and perform some occupational maintenance.
Intro to Git Devnet-1080 Cisco Live 2018Ashley Roach
The document provides an overview of Git and version control. It discusses how Git allows for snapshots of files and safe experimentation. It then covers the basics of Git including configuring user information, cloning repositories, adding and committing files, branching and merging, and sharing changes through pushes. The presentation aims to introduce developers to the fundamentals of using Git and its various commands and features.
This document discusses Java EE 7 and the future of Java EE. It provides an overview of the new features in Java EE 7 including JMS 2.0, Java API for WebSocket, JSON processing, Bean Validation 1.1, JAX-RS 2.0, JPA 2.1, JSF 2.2, batch applications processing and more. It also discusses the Java EE 8 survey results and possibilities for Java EE 8 such as alignment with web standards, cloud, CDI and Java SE 8.
Oracle Application Development Framework (ADF) is a framework for building web and mobile applications. The document discusses the history of ADF starting in 1970 and its architecture which includes features like ADF Model, Controller, View, Business Services, and support for technologies like JavaServer Faces, Java EE, XML, and web services. It also promotes additional resources for learning more about ADF like tutorials, samples, and documentation on Oracle's website.
This document provides an overview of Java EE 7 technologies including Servlets, JSF, JMS, CDI, WebSocket, JSON, JPA, JAX-RS, and batch applications. It discusses the key features and changes in Java EE 7 for each technology compared to previous versions. These include enhancements to Servlets 3.1 like async processing, JSF 2.2 additions like file upload and HTML5 markup support, and JPA 2.1 features such as schema generation and stored procedures.
2014 yılının sonunda sonlandırılması beklenen HTML standardının 5. sürümü çoktandır tarayıcılar tarafından destekleniyor. HTML5 ile gelen Canvas, Websockets ve diğer özelliklerle nasıl daha canlı, daha Flash uygulamalarına benzer, web uygulamaları geliştirebileceğimizi inceledik.
AnkaraJUG Aralık 2012 - Agile, Adaptasyon ve DönüşümAnkara JUG
Geçmişi 10-15 sene öncesine dayanan, değeri yavaş yavaş anlaşılmış ve günümüzde gittikçe popülerleşmeye başlayan Agile terimi ve Agile Metodolojiler (özellikle Scrum) hakkında genel bilgi paylaşımında bulunulacak, organizasyonel ve kurumsal seviyede agile adaptasyon ve dönüşüm konularında bilgiler sunulmaktadır.
PrimeFaces, JavaServer Faces icin gelistirllen ve dunya capinda populer olan zengin bir arayuz kutuphanesidir. Bu sunumda PrimeFaces Bilesenleri, Mobil, Ajax Push, Tema Destegi gibi modullerin yani sira PrimeFaces ekibinin gelistirdigi yeni jQuery javascript kutuphanesi PrimeUI'da tanitilmaktadir.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Enchancing adoption of Open Source Libraries. A case study on Albumentations.AIVladimir Iglovikov, Ph.D.
Presented by Vladimir Iglovikov:
- https://www.linkedin.com/in/iglovikov/
- https://x.com/viglovikov
- https://www.instagram.com/ternaus/
This presentation delves into the journey of Albumentations.ai, a highly successful open-source library for data augmentation.
Created out of a necessity for superior performance in Kaggle competitions, Albumentations has grown to become a widely used tool among data scientists and machine learning practitioners.
This case study covers various aspects, including:
People: The contributors and community that have supported Albumentations.
Metrics: The success indicators such as downloads, daily active users, GitHub stars, and financial contributions.
Challenges: The hurdles in monetizing open-source projects and measuring user engagement.
Development Practices: Best practices for creating, maintaining, and scaling open-source libraries, including code hygiene, CI/CD, and fast iteration.
Community Building: Strategies for making adoption easy, iterating quickly, and fostering a vibrant, engaged community.
Marketing: Both online and offline marketing tactics, focusing on real, impactful interactions and collaborations.
Mental Health: Maintaining balance and not feeling pressured by user demands.
Key insights include the importance of automation, making the adoption process seamless, and leveraging offline interactions for marketing. The presentation also emphasizes the need for continuous small improvements and building a friendly, inclusive community that contributes to the project's growth.
Vladimir Iglovikov brings his extensive experience as a Kaggle Grandmaster, ex-Staff ML Engineer at Lyft, sharing valuable lessons and practical advice for anyone looking to enhance the adoption of their open-source projects.
Explore more about Albumentations and join the community at:
GitHub: https://github.com/albumentations-team/albumentations
Website: https://albumentations.ai/
LinkedIn: https://www.linkedin.com/company/100504475
Twitter: https://x.com/albumentations
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
For the full video of this presentation, please visit: https://www.edge-ai-vision.com/2024/06/building-and-scaling-ai-applications-with-the-nx-ai-manager-a-presentation-from-network-optix/
Robin van Emden, Senior Director of Data Science at Network Optix, presents the “Building and Scaling AI Applications with the Nx AI Manager,” tutorial at the May 2024 Embedded Vision Summit.
In this presentation, van Emden covers the basics of scaling edge AI solutions using the Nx tool kit. He emphasizes the process of developing AI models and deploying them globally. He also showcases the conversion of AI models and the creation of effective edge AI pipelines, with a focus on pre-processing, model conversion, selecting the appropriate inference engine for the target hardware and post-processing.
van Emden shows how Nx can simplify the developer’s life and facilitate a rapid transition from concept to production-ready applications.He provides valuable insights into developing scalable and efficient edge AI solutions, with a strong focus on practical implementation.
20 Comprehensive Checklist of Designing and Developing a WebsitePixlogix Infotech
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Cosa hanno in comune un mattoncino Lego e la backdoor XZ?Speck&Tech
ABSTRACT: A prima vista, un mattoncino Lego e la backdoor XZ potrebbero avere in comune il fatto di essere entrambi blocchi di costruzione, o dipendenze di progetti creativi e software. La realtà è che un mattoncino Lego e il caso della backdoor XZ hanno molto di più di tutto ciò in comune.
Partecipate alla presentazione per immergervi in una storia di interoperabilità, standard e formati aperti, per poi discutere del ruolo importante che i contributori hanno in una comunità open source sostenibile.
BIO: Sostenitrice del software libero e dei formati standard e aperti. È stata un membro attivo dei progetti Fedora e openSUSE e ha co-fondato l'Associazione LibreItalia dove è stata coinvolta in diversi eventi, migrazioni e formazione relativi a LibreOffice. In precedenza ha lavorato a migrazioni e corsi di formazione su LibreOffice per diverse amministrazioni pubbliche e privati. Da gennaio 2020 lavora in SUSE come Software Release Engineer per Uyuni e SUSE Manager e quando non segue la sua passione per i computer e per Geeko coltiva la sua curiosità per l'astronomia (da cui deriva il suo nickname deneb_alpha).
Full-RAG: A modern architecture for hyper-personalizationZilliz
Mike Del Balso, CEO & Co-Founder at Tecton, presents "Full RAG," a novel approach to AI recommendation systems, aiming to push beyond the limitations of traditional models through a deep integration of contextual insights and real-time data, leveraging the Retrieval-Augmented Generation architecture. This talk will outline Full RAG's potential to significantly enhance personalization, address engineering challenges such as data management and model training, and introduce data enrichment with reranking as a key solution. Attendees will gain crucial insights into the importance of hyperpersonalization in AI, the capabilities of Full RAG for advanced personalization, and strategies for managing complex data integrations for deploying cutting-edge AI solutions.
In his public lecture, Christian Timmerer provides insights into the fascinating history of video streaming, starting from its humble beginnings before YouTube to the groundbreaking technologies that now dominate platforms like Netflix and ORF ON. Timmerer also presents provocative contributions of his own that have significantly influenced the industry. He concludes by looking at future challenges and invites the audience to join in a discussion.
23. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
README.txt
hello.c
hola.c
5 Haziran 13 Çarşamba
24. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
README.txt
hello.c
hola.c
5 Haziran 13 Çarşamba
25. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
README.txt
hello.c
hola.c
5 Haziran 13 Çarşamba
26. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
README.txt
hello.c
hola.c
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
README.txt
hello.c
hola.c
5 Haziran 13 Çarşamba
27. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
README.txt
hello.c
hola.c
5 Haziran 13 Çarşamba
28. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
README.txt
hello.c
hola.c
5 Haziran 13 Çarşamba
29. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
README.txt
hello.c
hola.c
hola.c
5 Haziran 13 Çarşamba
30. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
README.txt
hello.c
hola.c (rename)
5 Haziran 13 Çarşamba
31. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
README.txt
hello.c
hola.c (rename)
5 Haziran 13 Çarşamba
32. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
-Hello
+Hola
Commit
D
README.txt
hello.c
hola.c (rename)
(copy)
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
README.txt
hello.c
hola.c (rename)
5 Haziran 13 Çarşamba
33. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
-Hello
+Hola
Commit
D
README.txt
hello.c
hola.c (rename)
(copy)
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
README.txt
hello.c
hola.c (rename)
5 Haziran 13 Çarşamba
34. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
-Hello
+Hola
Commit
D
README.txt
hello.c
hola.c (rename)
(copy)
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
5 Haziran 13 Çarşamba
36. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
5 Haziran 13 Çarşamba
37. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
CHECKSUM
5 Haziran 13 Çarşamba
38. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
CHECKSUM
5 Haziran 13 Çarşamba
39. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
5 Haziran 13 Çarşamba
40. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
5 Haziran 13 Çarşamba
41. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
5 Haziran 13 Çarşamba
42. #include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
5 Haziran 13 Çarşamba
43. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
5 Haziran 13 Çarşamba
44. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
5 Haziran 13 Çarşamba
45. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
5 Haziran 13 Çarşamba
46. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
5 Haziran 13 Çarşamba
47. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hello.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
5 Haziran 13 Çarşamba
48. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
5 Haziran 13 Çarşamba
49. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
5 Haziran 13 Çarşamba
50. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
5 Haziran 13 Çarşamba
51. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
5 Haziran 13 Çarşamba
52. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
5 Haziran 13 Çarşamba
53. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
5 Haziran 13 Çarşamba
54. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hello project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
5 Haziran 13 Çarşamba
55. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
This is Scott's
Hola project.
Licensed under
GPL.
84f
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
5 Haziran 13 Çarşamba
56. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
This is Scott's
Hola project.
Licensed under
GPL.
84f
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
5 Haziran 13 Çarşamba
57. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
This is Scott's
Hola project.
Licensed under
GPL.
84f
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
5 Haziran 13 Çarşamba
58. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
This is Scott's
Hola project.
Licensed under
GPL.
84f
Commit
D
84f README.txt
6d4 hola.c
6d4 hello.c
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
5 Haziran 13 Çarşamba
59. #include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
This is Scott's
Hola project.
Licensed under GPL.
README.txt hola.c
Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
This is Scott's
Hola project.
Licensed under
GPL.
84f
Commit
D
84f README.txt
6d4 hola.c
6d4 hello.c
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
hello.c
5 Haziran 13 Çarşamba
60. Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
-Hello
+Hola
Commit
D
README.txt
hello.c
hola.c (rename)
(copy)
5 Haziran 13 Çarşamba
61. Commit
A
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
c3d
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
f13
#include<stdio.h>
int main(void) {
printf("Holan");
return 0;
}
6d4
Commit
B
c3d README.txt
6d4 hello.c
Commit
C
c3d README.txt
6d4 hola.c
This is Scott's
Hola project.
Licensed under
GPL.
84f
Commit
D
84f README.txt
6d4 hola.c
6d4 hello.c
Commit
A
This is Scott's Hello
project.
Licensed under GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
- printf("Holan");
+ printf("Holan");
Commit
B
Commit
C
-Hello
+Hola
Commit
D
README.txt
hello.c
hola.c (rename)
(copy)
5 Haziran 13 Çarşamba
86. A Basic Workflow
Edit files
Stage the changes
Review your changes
Commit the changes
vim / emacs / etc
git add (file)
repo status
git commit
5 Haziran 13 Çarşamba
87. A Basic Workflow
Edit files
Stage the changes
Review your changes
Commit the changes
vim / emacs / etc
git add (file)
repo status
git commit
5 Haziran 13 Çarşamba
88. A Basic Workflow
Edit files
Stage the changes
Review your changes
Commit the changes
vim / emacs / etc
git add (file)
repo status
git commit
5 Haziran 13 Çarşamba
89. A Basic Workflow
Edit files
Stage the changes
Review your changes
Commit the changes
vim / emacs / etc
git add (file)
git status / git diff
git commit
5 Haziran 13 Çarşamba
90. A Basic Workflow
Edit files
Stage the changes
Review your changes
Commit the changes
vim / emacs / etc
git add (file)
git status / git diff
git commit
5 Haziran 13 Çarşamba
91. A Basicerer Workflow
Edit files
Stage and Commit
vim / emacs / etc
git commit -a
5 Haziran 13 Çarşamba
101. 77d3001a1de6bf8f5e431972fe4d25b01e595c0b
commit size
ae668..
tree
parent
author
committer
my commit message goes here
and it is really, really cool
c4ec5
a149e
Scott
Scott
tree c4ec543b0322744e55c5efc9b6c4e449d398dbff
parent a149e2160b3f7573768cdc2fce24d0881f3577e1
author Scott Chacon <schacon@gmail.com> 1223402504 -0700
committer Scott Chacon <schacon@gmail.com> 1223402504 -0700
descriptive commit message
5 Haziran 13 Çarşamba
106. commit size
ae668..
tree
parent
author
committer
my commit message goes here
and it is really, really cool
c4ec5
a149e
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the previous commit
and I am very proud of it
2de54
38def
Scott
Scott
5 Haziran 13 Çarşamba
107. commit size
ae668..
tree
parent
author
committer
my commit message goes here
and it is really, really cool
c4ec5
a149e
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the previous commit
and I am very proud of it
2de54
38def
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
5 Haziran 13 Çarşamba
108. commit size
ae668..
tree
parent
author
committer
my commit message goes here
and it is really, really cool
c4ec5
a149e
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the previous commit
and I am very proud of it
2de54
38def
Scott
Scott
commit size
tree
parent
author
committer
this is the commit before that
and I'm not sure why
2fe65
90ecd
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the commit before that
and I'm not sure why
2fe65
90ecd
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
5 Haziran 13 Çarşamba
109. commit size
ae668..
tree
parent
author
committer
my commit message goes here
and it is really, really cool
c4ec5
a149e
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the previous commit
and I am very proud of it
2de54
38def
Scott
Scott
commit size
tree
parent
author
committer
this is the commit before that
and I'm not sure why
2fe65
90ecd
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the commit before that
and I'm not sure why
2fe65
90ecd
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
48e 77da1438d
c4e
3d5
1d3
03e
f46
23f
30e
67e
32a
5b1
5 Haziran 13 Çarşamba
110. commit size
ae668..
tree
parent
author
committer
my commit message goes here
and it is really, really cool
c4ec5
a149e
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the previous commit
and I am very proud of it
2de54
38def
Scott
Scott
commit size
tree
parent
author
committer
this is the commit before that
and I'm not sure why
2fe65
90ecd
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
commit size
tree
parent
author
committer
this is the commit before that
and I'm not sure why
2fe65
90ecd
Scott
Scott
app.yaml
index.yaml
main.py
./ c4e
03e
1d3
3d5
48e
77d
a14
38d
c4e
3d5
1d3
03e
f46
23f 30e
67e
32a
5b1
5 Haziran 13 Çarşamba
133. Commit
98ca9
master
HEAD
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
98ca9
i18n
master
HEAD
git branch i18n
5 Haziran 13 Çarşamba
134. Commit
98ca9
master
HEAD
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
98ca9
i18n
master
HEAD
git branch i18n
5 Haziran 13 Çarşamba
135. Commit
98ca9
master
HEAD
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
98ca9
i18n
master
HEAD
git branch
5 Haziran 13 Çarşamba
136. $ git branch
* master
i18n
Commit
98ca9
master
HEAD
c3d README.txt
f13 hello.c
This is Scott's
Hello project.
Licensed under
GPL.
#include<stdio.h>
int main(void) {
printf("Hellon");
return 0;
}
98ca9
i18n
master
HEAD
git branch
5 Haziran 13 Çarşamba
196. $ git merge iss53
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.
5 Haziran 13 Çarşamba
197. $ git merge iss53
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.
5 Haziran 13 Çarşamba
198. $ git merge iss53
Auto-merging index.html
CONFLICT (content): Merge conflict in index.html
Automatic merge failed; fix conflicts and then commit the result.
$ git status
index.html: needs merge
# On branch master
# Changed but not updated:
# (use "git add <file>..." to update what will be committed)
# (use "git checkout -- <file>..." to discard changes in
working directory)
#
#! unmerged: index.html
#
5 Haziran 13 Çarşamba
199. <<<<<<< HEAD:index.html
<div id="footer">contact :
email.support@github.com</div>
=======
<div id="footer">
please contact us at support@github.com
</div>
>>>>>>> iss53:index.html
5 Haziran 13 Çarşamba
201. $ git status
# On branch master
# Changes to be committed:
# (use "git reset HEAD <file>..." to unstage
#
#!modified: index.html
#
5 Haziran 13 Çarşamba