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.
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.
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 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.
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 technologies, 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.
IBM Agile Engineering Summit 18: How to Integrate IBM Rational® Team Concert ...Bartosz Chrabski
Are you are using Git for source code management in software development projects? Why not integrate it with other tools that organizations use on a daily basis? If your organization is considering an integration between IBM Rational Team Concert and Git, this session is perfect for you. It describes the concept and architecture of an RTC-Git integration and highlights step-by-step the setup and configuration for such an integration. You will leave with all the information you need to set up your environment and start working. Join us to learn about the advantages of using RTC and Git together.
Don't be a git - the essentials you should know about git to use it correctly
Presentation by Otto Kekäläinen held at Vincit Teatime on Nov 11th 2015
http://www.vincitteatime.fi/
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.
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 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.
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 technologies, 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.
IBM Agile Engineering Summit 18: How to Integrate IBM Rational® Team Concert ...Bartosz Chrabski
Are you are using Git for source code management in software development projects? Why not integrate it with other tools that organizations use on a daily basis? If your organization is considering an integration between IBM Rational Team Concert and Git, this session is perfect for you. It describes the concept and architecture of an RTC-Git integration and highlights step-by-step the setup and configuration for such an integration. You will leave with all the information you need to set up your environment and start working. Join us to learn about the advantages of using RTC and Git together.
Don't be a git - the essentials you should know about git to use it correctly
Presentation by Otto Kekäläinen held at Vincit Teatime on Nov 11th 2015
http://www.vincitteatime.fi/
Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
This Tech Talk covers basic, intermediate and some advanced concepts of Git. Basic Git includes about types of version control system, three states of git, getting git repositories, recording changes, viewing staged and unstaged changes, committing changes, viewing commit history, working with remotes and Tagging.
Git's Killer Feature Branching has been discussed in detail; about branches in git, creating branches, switching branches, merging branches, rebasing, resolving merge conflicts and remote branches.
Other than that some useful features like Staging patches, stashing and cleaning, cherry-pick, git reset, git revert, interactive rebase and undoing merges have been discussed.
This informative tech talk was given at Atlogys by Tech Lead - Mr. Anoop Malav. It is also available on the Atlogys YouTube channel.
Describe how to contribute to open source projects.
Provide example process using two hot open source project, linux and AOSP(Android Open Source Project)
Git and github - Verson Control for the Modern DeveloperJohn Stevenson
An introduction to Git and Github, tools for distributed version control that give an easy to use and highly collaborative approach to version code and configuration.
Introduction to Git for Non-Developers
John Anderson
Infinity Interactive - VP, Technology
Find more by John Anderson: https://www.slideshare.net/genehackdotorg
Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency.
This Tech Talk covers basic, intermediate and some advanced concepts of Git. Basic Git includes about types of version control system, three states of git, getting git repositories, recording changes, viewing staged and unstaged changes, committing changes, viewing commit history, working with remotes and Tagging.
Git's Killer Feature Branching has been discussed in detail; about branches in git, creating branches, switching branches, merging branches, rebasing, resolving merge conflicts and remote branches.
Other than that some useful features like Staging patches, stashing and cleaning, cherry-pick, git reset, git revert, interactive rebase and undoing merges have been discussed.
This informative tech talk was given at Atlogys by Tech Lead - Mr. Anoop Malav. It is also available on the Atlogys YouTube channel.
Describe how to contribute to open source projects.
Provide example process using two hot open source project, linux and AOSP(Android Open Source Project)
Git and github - Verson Control for the Modern DeveloperJohn Stevenson
An introduction to Git and Github, tools for distributed version control that give an easy to use and highly collaborative approach to version code and configuration.
Introduction to Git for Non-Developers
John Anderson
Infinity Interactive - VP, Technology
Find more by John Anderson: https://www.slideshare.net/genehackdotorg
Vincit Teatime 2015.2 - Otto Kekäläinen: Don't be a gitVincitOy
Otto Kekäläinen from Seravo Oy gave a talk on how to use git correctly.
Don't be a git or The essentials you should know about git to use it correctly
Git on Linus Torvaldsin kehittämä versionhallintatyökalu, jonka ominaisuudet riittävät maailman laajimman ohjelmistoprojektin tarpeisiin. Git itsessään on hyvä lähtökohta jatkuvan integraation, laadunvalvonnan ja tehokkaan monen kehittäjän ympäristön pohjatyökaluksi. Tehokas käyttö ja yhteistyö vaatii kumminkin työkalun hallinnan. Ovatko branching, merging, rebasing ja bisecting varmasti tuttuja käsitteitä? Kuule kokeneelta kehittäjältä parhaat vinkit ja ota git haltuun.
Git Tutorial A Comprehensive Guide for Beginners.pdfuzair
flicts
If there are conflicts when merging changes, Git will prompt you to resolve them. You can use a variety of tools to resolve conflicts, including text editors and graphical merge tools.
Advanced Git Commands
git diff
The git diff command shows the differences between two different versions of a file:
phpCopy code
git diff <commit1> <commit2> <file>
git reset
The git reset command is used to reset the state of the repository to a specific commit:
perlCopy code
git reset <commit>
git stash
The git stash command is used to temporarily save changes that you are not yet ready to commit:
Copy code
git stash
Git Best Practices
Committing frequently
It is important to commit your changes frequently, rather than waiting until you have completed a large amount of work. This makes it easier to track changes and identify problems.
Writing meaningful commit messages
Your commit messages should be descriptive and provide context for the changes that you have made.
Creating descriptive branch names
Your branch names should be descriptive and provide context for the changes that you are working on.
Conclusion
In this guide, we have covered the basic concepts of Git, how to install it, and the
Git can be a complex tool, but with practice and experience, you will become more comfortable using it. If you have any questions or run into any issues, there is a wealth of resources available online, including documentation, forums, and tutorials.
Thank you for reading this comprehensive guide to Git for beginners.
FAQ
It provides a number of benefits, including the ability to collaborate with others, maintain a history of your code, and easily revert changes if necessary.
What is a repository in Git? A repository is a central location where your code is stored and managed. It contains all of the files and directories that make up your project, as well as a history of changes made to those files.
What is branching in Git? Branching is the process of creating a new line of development for your code. It allows you to work on new features or changes without affecting the main branch of your code.
How do I resolve merge conflicts in Git? When merging changes from one branch into another, you may encounter conflicts between different versions of the same file. Git provides tools to help you resolve these conflicts, including text editors and graphical meflicts
If there are conflicts when merging changes, Git will prompt you to resolve them. You can use a variety of tools to resolve conflicts, including text editors and graphical merge tools.
Advanced Git Commands
git diff
The git diff command shows the differences between two different versions of a file:
phpCopy code
git diff <commit1> <commit2> <file>
git reset
The git reset command is used to reset the state of the repository to a specific commit:
perlCopy code
git reset <commit>
git stash
The git stash command is used to temporarily save changes that you are not yet ready to commit:
Copy code
git sta
Git Bash is a command line interface that allows you to interact with Git, a version control system that tracks changes in your code and lets you collaborate with other developers. Git Bash is based on a popular Unix shell called Bash, and it works on Windows operating systems. With Git Bash, you can create and manage Git repositories, stage and commit your code, push and pull from remote servers, create and merge branches, and much more. In this article, I will give you an introduction to Git Bash and show you how to use some basic commands. ¹²³
المصدر: محادثة مع Bing، 29/9/2023
(1) Git bash: Definition, commands, & getting started | Atlassian. https://www.atlassian.com/git/tutorials/git-bash.
(2) An introduction to Git: what it is, and how to use it - freeCodeCamp.org. https://www.freecodecamp.org/news/what-is-git-and-how-to-use-it-c341b049ae61/.
(3) Introduction to Git Bash: A Beginner's Guide to Using the Command Line .... https://marketsplash.com/tutorials/git/git-bash/.
(4) undefined. https://git-scm.com/book/en/v2/Getting-Started-Installing-Git.
We will learn how to create repository, pushing, cloning and creating branches. Additionally we will talk about various workflows that are used by teams while collaborating in a project.
Git is an important part of daily programming (especially if you're working with a team) and is widely used in the software industry. Since there are many various commands you can use, mastering Git takes time. But some commands are used more frequently (some daily). So in this post, I will share and explain the most used Git commands that every developer should know. Note: To understand this PDF, you need to know the basics and advances of Git. https://www.9series.com/
People are frequently encouraged to get into public speaking to advance their careers -- and public speaking can be great for that. But it can also be hard to figure out how to get started. This talk gives you the inside scoop on the speaker life.
Git is a powerful, critical, yet poorly understood tool that virtually all Open Source developers use. One of the key features that git provides is a powerful and comprehensive log that displays the history of all the changes that have happened in a project, including potential developments that weren't ever merged, details about former versions of software that can inform future development, and even such mundane details as whether development on feature A started before or after development of bugfix B.
Despite the power and utility of git's log, few developers take full advantage of it. Worse, some common practices that developers have adopted in the name of convenience (or just plain cargo culting) can actually destroy this useful information. Moreover, if developers are following the common exhortation to "commit often", they may end up with logs full of uninteresting noise, as all the details of debugging attempts and experiments are inadvertently recorded.
This talk will:
* detail the potential benefits of having informative and well structured logs
* discuss common developer habits that can make logs less useful
* explain techniques to preserve informative development history
Logs Are Magic: Why Git Workflows and Commit Structure Should Matter To YouJohn Anderson
Git is a powerful, critical, yet poorly understood tool that virtually all Open Source developers use. One of the key features that git provides is a powerful and comprehensive log that displays the history of all the changes that have happened in a project, including potential developments that weren't ever merged, details about former versions of software that can inform future development, and even such mundane details as whether development on feature A started before or after development of bugfix B.
Despite the power and utility of git's log, few developers take full advantage of it. Worse, some common practices that developers have adopted in the name of convenience (or just plain cargo culting) can actually destroy this useful information. Moreover, if developers are following the common exhortation to "commit often", they may end up with logs full of uninteresting noise, as all the details of debugging attempts and experiments are inadvertently recorded.
This talk will:
* detail the potential benefits of having informative and well structured logs
* discuss common developer habits that can make logs less useful
* explain techniques to preserve informative development history
A static site generator should be your next language learning projectJohn Anderson
When learning a new language, some folks prefer to read the language documentation, or work through simple exercises like you might find on http://exercism.io — but I prefer to have something more like an actual project. I find that holds my focus a little better, and that I do a better job of absorbing the new language syntax and features if I’m using them for something real.
In this talk, I’m going to outline why writing a static website generator is the perfect task for this sort of language learning project. I’ll cover the code you’ll need to write in order to develop a simple template-based website generation system, and show how this particular project actually manages to hit all the points you need to understand to claim basic understanding of a language.
You got chocolate in my peanut butter! .NET on Mac & LinuxJohn Anderson
Microsoft has open sourced .NET and made it cross-platform on Mac and Linux, and done a surprisingly great job of it. In this talk I'll walk you through creating a simple .NET app — LIVE — on a Mac, and I won't use the mouse even once — that's how good the CLI support is. It's easy, and more importantly, it's useful.
The .NET Core tooling has made a believer of me — come see for yourself just how good the new open source .NET Core is!
A static site generator should be your next language learning projectJohn Anderson
When learning a new language, some folks prefer to read the language documentation, or work through simple exercises like you might find on http://exercism.io -- but I prefer to have something more like an actual project. I find that holds my focus a little better, and that I do a better job of absorbing the new language syntax and features if I'm using them for something *real*.
In this talk, I'm going to outline why writing a static website generator is the perfect task for this sort of language learning project. I'll cover the code you'll need to write in order to develop a simple template-based website generation system, and show how this particular project actually manages to hit all the points you need to understand to claim basic understanding of a language.
Old Dogs & New Tricks: What's New with Perl5 This CenturyJohn Anderson
Perl5? Isn't that language dead? No, wait, wasn't it replaced by Perl6? Neither is true, but if you haven't paid attention to the Perl world since a year beginning with the digit '1', you've missed a lot of great new stuff! This talk will get you up to speed on Perl5 in 2018, with a focus on new language features, best practices, and even why you might want to learn Perl if you don't know it.
Swift was originally released in 2014, and Open Sourced by Apple in late 2015. The Open Source release generated an explosion of community interest and support, resulting in ports to other platforms and significant language changes. Swift version 3, which reflects the results of much of this work, was released in September of 2016, bringing with it some significant refinements to the core language and a new package manager.
Swift is a multi-paradigm language, supporting imperative, functional, and object-oriented programming styles. The language is strongly typed but has extensive support for type inference and substantial tooling available in XCode to identify and in some cases automatically fix common programming errors. Swift uses a memory management strategy called automatic reference counting (ARC), freeing programmers from the tedium of manually managing memory allocation. This combination of strong typing, maximal type inference, automatic reference counting (ARC), and excellent tooling results in an experience that can be described as “the Macintosh of programming languages”.
This talk will present some of the history of the development of Swift with emphasis on how the Open Source release of the language kick-started activity, review the basic syntax of Swift (with comparisons to similar languages that attendees may be more familiar with), and describe what tools are available to help learn the language, including XCode, the Swift REPL available from XCode, and the new Swift Playgrounds for iPad that debuted with Swift 3 and iOS10. After attending this talk, an attendee with no previous Swift experience will understand exactly why they should be excited about this relatively new programming language and be up to date on exactly what they need to do to dive into Swift coding for themselves.
A static site generator should be your next language learning projectJohn Anderson
When learning a new language, some folks prefer to read the language documentation, or work through simple exercises like you might find on http://exercism.io -- but I prefer to have something more like an actual project. I find that holds my focus a little better, and that I do a better job of absorbing the new language syntax and features if I'm using them for something real.
In this talk, I'm going to outline why writing a static website generator is the perfect task for this sort of language learning project. I'll cover the code you'll need to write in order to develop a simple template-based website generation system, and show how this particular project actually manages to hit all the points you need to understand to claim basic understanding of a language.
Logs Are Magic: Why Git Workflows and Commit Structure Should Matter To YouJohn Anderson
Git is a powerful, critical, yet poorly understood tool that virtually all Open Source developers use. One of the key features that git provides is a powerful and comprehensive log that displays the history of all the changes that have happened in a project, including potential developments that weren't ever merged, details about former versions of software that can inform future development, and even such mundane details as whether development on feature A started before or after development of bugfix B.
Despite the power and utility of git's log, few developers take full advantage of it. Worse, some common practices that developers have adopted in the name of convenience (or just plain cargo culting) can actually destroy this useful information. Moreover, if developers are following the common exhortation to "commit often", they may end up with logs full of uninteresting noise, as all the details of debugging attempts and experiments are inadvertently recorded.
This talk will:
* detail the potential benefits of having informative and well structured logs
* discuss common developer habits that can make logs less useful
* explain techniques to preserve informative development history
JSON Web Tokens, or JWTs, are a standardized way of representing a JSON-based data structure and transmitting it between two parties. JWTs rely on cryptographic signatures which ensure that the data transmitted in the JWT isn’t modified during transit. JWTs are designed to be extremely compact—small enough to be transmitted in an HTTP header, for example—and can be used in a variety of ways: as authorization tokens, client-side data storage, or even for the implementation of single sign on (SSO) solutions. They’re based on a very simple and elegant algorithm that’s easy to understand and quickly put to use. JWT implementations are available in virtually every programming language in common use for Web and mobile development.
Unfortunately, learning how to use JWTs can be complicated by the terminology that’s commonly used. “Claims,” “signatures,” “body,” “payload”—a large part of learning how JWTs work is deciphering these buzzwords and understanding how they map onto more familiar programming terms. This talk will focus on reducing this barrier to entry and making JWTs understandable to any programmer.
This talk will cover:
the structure of a JSON Web Token
the algorithm for generating one
available libraries and tooling
some common scenarios where JWTs can be used.
Particular emphasis will be given as to when and why JWTs provide for better solutions than other methods. Attendees should come away from this talk with a full understanding of how to use JWTs for a variety of purposes, and be ready and eager to put JWTs into use in both personal and professional contexts.
Old Dogs & New Tricks: What's New With Perl5 This CenturyJohn Anderson
The Perl programming language has a somewhat checkered reputation. People enjoy ranting about the supposed “read-only” nature of the language, and war stories of having to maintain horrible legacy Perl codebases are a popular feature of after-hours gatherings at programming conferences around the world. But, as Bjarne Stroustrup notes, “There are only two kinds of languages: the ones people complain about and the ones nobody uses”—and Perl also enjoys a reputation as a language that gets pulled out when you need just a bit more “oomph” on the command line than you can muster up with bash, sed, awk, and friends.
The thing that most people don’t realize is that the Perl5 community, after a brief period of reduced activity in the early 2000s, has regained velocity and organization, and has produced new stable language releases (with new features!) for the last 6 years (and counting). During that period of time, the community consensus around issues such as installation management, deployment, and other best practices has undergone significant evolution. New libraries and frameworks have been introduced and have replaced older standards that you may be familiar with. (CGI.pm? No more!) As people from the Perl community have gained experience with newer languages and frameworks, they’ve brought new ideas from those systems back into the Perl fold, either adding them to the core language or to libraries available on the CPAN. The result combines all the stability from Perl’s overarching commitment to backwards compatibility with support for the newest protocols and programming paradigms.
This talk will summarize significant new features that have been added to the core language, discuss tooling options for managing Perl installations, explain the community consensus on best practices around deployments and which competing libraries to use for particular purposes, and generally get you up to speed on how the Perl5 community thinks about development in Perl in 2017.
As presented at KCDC 2017:
Swift was originally released in 2014, and Open Sourced by Apple in late 2015. The Open Source release generated an explosion of community interest and support, resulting in ports to other platforms and significant language changes. Swift version 3, which reflects the results of much of this work, was released in September of 2016, bringing with it some significant refinements to the core language and a new package manager.
Swift is a multi-paradigm language, supporting imperative, functional, and object-oriented programming styles. The language is strongly typed but has extensive support for type inference and substantial tooling available in XCode to identify and in some cases automatically fix common programming errors. Swift uses a memory management strategy called automatic reference counting (ARC), freeing programmers from the tedium of manually managing memory allocation. This combination of strong typing, maximal type inference, automatic reference counting (ARC), and excellent tooling results in an experience that can be described as "the Macintosh of programming languages".
This talk will present some of the history of the development of Swift with emphasis on how the Open Source release of the language kick-started activity, review the basic syntax of Swift (with comparisons to similar languages that attendees may be more familiar with), and describe what tools are available to help learn the language, including XCode, the Swift REPL available from XCode, and the new Swift Playgrounds for iPad that debuted with Swift 3 and iOS10. After attending this talk, an attendee with no previous Swift experience will understand exactly why they should be excited about this relatively new programming language and be up to date on exactly what they need to do to dive into Swift coding for themselves.
Logs Are Magic: Why Git Workflows and Commit Structure Should Matter To YouJohn Anderson
Git is a powerful, critical, yet poorly understood tool that virtually all Open Source developers use. One of the key features that git provides is a powerful and comprehensive log that displays the history of all the changes that have happened in a project, including potential developments that weren't ever merged, details about former versions of software that can inform future development, and even such mundane details as whether development on feature A started before or after development of bugfix B.
Despite the power and utility of git's log, few developers take full advantage of it. Worse, some common practices that developers have adopted in the name of convenience (or just plain cargo culting) can actually destroy this useful information. Moreover, if developers are following the common exhortation to "commit often", they may end up with logs full of uninteresting noise, as all the details of debugging attempts and experiments are inadvertently recorded.
This talk will:
* detail the potential benefits of having informative and well structured logs
* discuss common developer habits that can make logs less useful
* explain techniques to preserve informative development history
Friends Don't Let Friends Browse Unencrypted: Running a VPN for friends and f...John Anderson
In late March 2017, Congress passed a law making it possible for your ISP to sell sensitive private information about their customers -- including their detailed browsing history. Interest in VPN services immediately spiked. But using a VPN doesn't actually solve this problem, it just pushes it further downstream -- because there's nothing preventing your VPN provider from doing similiar undesirable things. That's not to mention that more than half the VPNs in the Google Play store don't actually encrypt your web traffic.
So, how are you going to protect yourself? More over, how are you going to help your less technically sophisticated friends and family protect themselves? Chances are, if you're at this conference, you have the technical skills to set up and run your own VPN service, which you can also make available to friends and family. (There's even a chance that all of you using the VPN together might provide better cover for your collective privacy.)
Attendees at this talk will learn about various Open Source alternatives that simplify setting up a VPN. The talk will discuss the pros and cons of hosting this VPN service within the US, versus outside the US. Enabling the VPN on a per-computer basis versus a whole network approach will also be discussed. Other, related, privacy-enhancing services (such as centralized ad blocking) will also be covered.
With great nerdery comes great responsibility -- come learn how you can help yourself and your friends and family preserve their privacy!
As presented at OpenWest, 12 Jul 2017
Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...Globus
The U.S. Geological Survey (USGS) has made substantial investments in meeting evolving scientific, technical, and policy driven demands on storing, managing, and delivering data. As these demands continue to grow in complexity and scale, the USGS must continue to explore innovative solutions to improve its management, curation, sharing, delivering, and preservation approaches for large-scale research data. Supporting these needs, the USGS has partnered with the University of Chicago-Globus to research and develop advanced repository components and workflows leveraging its current investment in Globus. The primary outcome of this partnership includes the development of a prototype enterprise repository, driven by USGS Data Release requirements, through exploration and implementation of the entire suite of the Globus platform offerings, including Globus Flow, Globus Auth, Globus Transfer, and Globus Search. This presentation will provide insights into this research partnership, introduce the unique requirements and challenges being addressed and provide relevant project progress.
We describe the deployment and use of Globus Compute for remote computation. This content is aimed at researchers who wish to compute on remote resources using a unified programming interface, as well as system administrators who will deploy and operate Globus Compute services on their research computing infrastructure.
In software engineering, the right architecture is essential for robust, scalable platforms. Wix has undergone a pivotal shift from event sourcing to a CRUD-based model for its microservices. This talk will chart the course of this pivotal journey.
Event sourcing, which records state changes as immutable events, provided robust auditing and "time travel" debugging for Wix Stores' microservices. Despite its benefits, the complexity it introduced in state management slowed development. Wix responded by adopting a simpler, unified CRUD model. This talk will explore the challenges of event sourcing and the advantages of Wix's new "CRUD on steroids" approach, which streamlines API integration and domain event management while preserving data integrity and system resilience.
Participants will gain valuable insights into Wix's strategies for ensuring atomicity in database updates and event production, as well as caching, materialization, and performance optimization techniques within a distributed system.
Join us to discover how Wix has mastered the art of balancing simplicity and extensibility, and learn how the re-adoption of the modest CRUD has turbocharged their development velocity, resilience, and scalability in a high-growth environment.
Check out the webinar slides to learn more about how XfilesPro transforms Salesforce document management by leveraging its world-class applications. For more details, please connect with sales@xfilespro.com
If you want to watch the on-demand webinar, please click here: https://www.xfilespro.com/webinars/salesforce-document-management-2-0-smarter-faster-better/
Providing Globus Services to Users of JASMIN for Environmental Data AnalysisGlobus
JASMIN is the UK’s high-performance data analysis platform for environmental science, operated by STFC on behalf of the UK Natural Environment Research Council (NERC). In addition to its role in hosting the CEDA Archive (NERC’s long-term repository for climate, atmospheric science & Earth observation data in the UK), JASMIN provides a collaborative platform to a community of around 2,000 scientists in the UK and beyond, providing nearly 400 environmental science projects with working space, compute resources and tools to facilitate their work. High-performance data transfer into and out of JASMIN has always been a key feature, with many scientists bringing model outputs from supercomputers elsewhere in the UK, to analyse against observational or other model data in the CEDA Archive. A growing number of JASMIN users are now realising the benefits of using the Globus service to provide reliable and efficient data movement and other tasks in this and other contexts. Further use cases involve long-distance (intercontinental) transfers to and from JASMIN, and collecting results from a mobile atmospheric radar system, pushing data to JASMIN via a lightweight Globus deployment. We provide details of how Globus fits into our current infrastructure, our experience of the recent migration to GCSv5.4, and of our interest in developing use of the wider ecosystem of Globus services for the benefit of our user community.
Custom Healthcare Software for Managing Chronic Conditions and Remote Patient...Mind IT Systems
Healthcare providers often struggle with the complexities of chronic conditions and remote patient monitoring, as each patient requires personalized care and ongoing monitoring. Off-the-shelf solutions may not meet these diverse needs, leading to inefficiencies and gaps in care. It’s here, custom healthcare software offers a tailored solution, ensuring improved care and effectiveness.
Unleash Unlimited Potential with One-Time Purchase
BoxLang is more than just a language; it's a community. By choosing a Visionary License, you're not just investing in your success, you're actively contributing to the ongoing development and support of BoxLang.
Enhancing Research Orchestration Capabilities at ORNL.pdfGlobus
Cross-facility research orchestration comes with ever-changing constraints regarding the availability and suitability of various compute and data resources. In short, a flexible data and processing fabric is needed to enable the dynamic redirection of data and compute tasks throughout the lifecycle of an experiment. In this talk, we illustrate how we easily leveraged Globus services to instrument the ACE research testbed at the Oak Ridge Leadership Computing Facility with flexible data and task orchestration capabilities.
Into the Box Keynote Day 2: Unveiling amazing updates and announcements for modern CFML developers! Get ready for exciting releases and updates on Ortus tools and products. Stay tuned for cutting-edge innovations designed to boost your productivity.
Globus Connect Server Deep Dive - GlobusWorld 2024Globus
We explore the Globus Connect Server (GCS) architecture and experiment with advanced configuration options and use cases. This content is targeted at system administrators who are familiar with GCS and currently operate—or are planning to operate—broader deployments at their institution.
OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoamtakuyayamamoto1800
In this slide, we show the simulation example and the way to compile this solver.
In this solver, the Helmholtz equation can be solved by helmholtzFoam. Also, the Helmholtz equation with uniformly dispersed bubbles can be simulated by helmholtzBubbleFoam.
How to Position Your Globus Data Portal for Success Ten Good PracticesGlobus
Science gateways allow science and engineering communities to access shared data, software, computing services, and instruments. Science gateways have gained a lot of traction in the last twenty years, as evidenced by projects such as the Science Gateways Community Institute (SGCI) and the Center of Excellence on Science Gateways (SGX3) in the US, The Australian Research Data Commons (ARDC) and its platforms in Australia, and the projects around Virtual Research Environments in Europe. A few mature frameworks have evolved with their different strengths and foci and have been taken up by a larger community such as the Globus Data Portal, Hubzero, Tapis, and Galaxy. However, even when gateways are built on successful frameworks, they continue to face the challenges of ongoing maintenance costs and how to meet the ever-expanding needs of the community they serve with enhanced features. It is not uncommon that gateways with compelling use cases are nonetheless unable to get past the prototype phase and become a full production service, or if they do, they don't survive more than a couple of years. While there is no guaranteed pathway to success, it seems likely that for any gateway there is a need for a strong community and/or solid funding streams to create and sustain its success. With over twenty years of examples to draw from, this presentation goes into detail for ten factors common to successful and enduring gateways that effectively serve as best practices for any new or developing gateway.
A Comprehensive Look at Generative AI in Retail App Testing.pdfkalichargn70th171
Traditional software testing methods are being challenged in retail, where customer expectations and technological advancements continually shape the landscape. Enter generative AI—a transformative subset of artificial intelligence technologies poised to revolutionize software testing.
Accelerate Enterprise Software Engineering with PlatformlessWSO2
Key takeaways:
Challenges of building platforms and the benefits of platformless.
Key principles of platformless, including API-first, cloud-native middleware, platform engineering, and developer experience.
How Choreo enables the platformless experience.
How key concepts like application architecture, domain-driven design, zero trust, and cell-based architecture are inherently a part of Choreo.
Demo of an end-to-end app built and deployed on Choreo.
Quarkus Hidden and Forbidden ExtensionsMax Andersen
Quarkus has a vast extension ecosystem and is known for its subsonic and subatomic feature set. Some of these features are not as well known, and some extensions are less talked about, but that does not make them less interesting - quite the opposite.
Come join this talk to see some tips and tricks for using Quarkus and some of the lesser known features, extensions and development techniques.
Software Engineering, Software Consulting, Tech Lead.
Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Security,
Spring Transaction, Spring MVC,
Log4j, REST/SOAP WEB-SERVICES.
Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...Globus
Large Language Models (LLMs) are currently the center of attention in the tech world, particularly for their potential to advance research. In this presentation, we'll explore a straightforward and effective method for quickly initiating inference runs on supercomputers using the vLLM tool with Globus Compute, specifically on the Polaris system at ALCF. We'll begin by briefly discussing the popularity and applications of LLMs in various fields. Following this, we will introduce the vLLM tool, and explain how it integrates with Globus Compute to efficiently manage LLM operations on Polaris. Attendees will learn the practical aspects of setting up and remotely triggering LLMs from local machines, focusing on ease of use and efficiency. This talk is ideal for researchers and practitioners looking to leverage the power of LLMs in their work, offering a clear guide to harnessing supercomputing resources for quick and effective LLM inference.
How Recreation Management Software Can Streamline Your Operations.pptxwottaspaceseo
Recreation management software streamlines operations by automating key tasks such as scheduling, registration, and payment processing, reducing manual workload and errors. It provides centralized management of facilities, classes, and events, ensuring efficient resource allocation and facility usage. The software offers user-friendly online portals for easy access to bookings and program information, enhancing customer experience. Real-time reporting and data analytics deliver insights into attendance and preferences, aiding in strategic decision-making. Additionally, effective communication tools keep participants and staff informed with timely updates. Overall, recreation management software enhances efficiency, improves service delivery, and boosts customer satisfaction.
Code reviews are vital for ensuring good code quality. They serve as one of our last lines of defense against bugs and subpar code reaching production.
Yet, they often turn into annoying tasks riddled with frustration, hostility, unclear feedback and lack of standards. How can we improve this crucial process?
In this session we will cover:
- The Art of Effective Code Reviews
- Streamlining the Review Process
- Elevating Reviews with Automated Tools
By the end of this presentation, you'll have the knowledge on how to organize and improve your code review proces
1. an introduction to
git
(even for non-developers)
john sj anderson · @genehack · the perl conference · 18 jun 2018
1 — intro to git — tpc 2018 — @genehack
2. vp of tech, infinity interactive
custom software development
and technology consulting
hi, i’m john.
also known as
@genehack
2 — intro to git — tpc 2018 — @genehack
3. do you identify as a non-developer?
developer? something in between?
no experience with git? some
experience? consider yourself a git
expert?
for those w/git experience, how
many of you are anxious about git?
let’s start out with
an audience
survey3 — intro to git — tpc 2018 — @genehack
4. simplify and de-mystify git
open source desperately needs non-
developer contributions, but git anxiety
can block or slow down otherwise
helpful contributions. i'd like to help
people understand git a little bit better,
to work to reduce that barrier to entry
my goals for this
talk4 — intro to git — tpc 2018 — @genehack
5. going to talk about how you get a git
repository to work on
adding and changing files
sending changes back up to the original
branching and merging
saving your bacon when things go pear-
shaped
additional resources
talkoverview5 — intro to git — tpc 2018 — @genehack
6. this is a tough topic. there's lots of
jargon
i'm going to try to explain things in
different terms than are normally used to
ease that a bit.
trying really hard to avoid saying "just",
"simple", "easy", etc. please help me
here.
ground
rules6 — intro to git — tpc 2018 — @genehack
8. this definition has the unique
combination of being 100% accurate
and also being completely useless
unless you already know what it means.
so if you don't already know what it
means, you will be forgiven if your
reaction to this definition is ...
distributed
revision
control
system
8 — intro to git — tpc 2018 — @genehack
11. let's break this down into a
couple of parts. first, let's
consider 'revision control
system'.
what's a revision control
system?
distributed
revision
control
system
11 — intro to git — tpc 2018 — @genehack
13. revision control systems
(rcs, cvs, svn, tfs, git, etc)
are a fundamental
building block of software development.
13 — intro to git — tpc 2018 — @genehack
14. <insert rant about how this
stuff should be taught in
school>
a brief
aside14 — intro to git — tpc 2018 — @genehack
15. ok, so that's 'revision control
system' -- what about the
'distributed' part? what's that
mean?
distributed
revision
control
system
15 — intro to git — tpc 2018 — @genehack
18. git is a really nice fit for any kind of text-
based stuff that changes over time --
websites, recipes, writing, your resume,
etc.
git will even work okay with binary
formats, it's just a bit harder to see
some of the changes that happen that
way.
git’s not only for
code.18 — intro to git — tpc 2018 — @genehack
19. git is also not
github.19 — intro to git — tpc 2018 — @genehack
20. also not bitbucker, not team
foundation server
all of these are sites that provide
hosting for git-based projects
along with a number of other
project management tools.
git is also not
gitlab.20 — intro to git — tpc 2018 — @genehack
21. they're way bigger than the scope of
this talk, and the material in this talk
applies equally to any of them. i
encourage you to initially focus on
learning the basics of git, and only
then start to focus on the git hosting
site you (or the project you've chosen
to work on) have decided to use.
learning the basics
of git will help you
regardless of what git hosting is used
21 — intro to git — tpc 2018 — @genehack
22. so, one of the initial things you
need to do, if you don't already
have git installed, is to get git.
getting
git22 — intro to git — tpc 2018 — @genehack
23. you can do this by going to git-
scm.com...
note that i will put these slides up
for download after the talk, and
tweet out the location, so you
don't need to worry about writing
down each url...
git-scm.com
24. where they will have links to install it for
whatever platform you're on.
if you're running something with a
package manager (linux, mac with brew,
etc.) just using the package manager
may be easier.
you may also see that they have links
here to 'Mac GUIs'...
25. ...so this is a good time to talk about GUI git versus CLI git.
after thinking about this for a bit, i decided to give all the
examples in this talk in terms of the CLI. that was for a few
reasons:
when you need to do a net search for help with something,
most of the results will be given in terms of the CLI, so having
a basic understanding will help
showing a GUI in addition to the CLI examples would
effectively halve the amount of stuff i can get through (and the
talk is already groaning when jammed into a 30 minute slot)
there are a bunch of Git GUIs and this way i didn't have to pick
just one to show
cli
versus
gui25 — intro to git — tpc 2018 — @genehack
26. aside: if you're not familiar with the CLI,
it's a useful skill to have as an open
source contributor, even as a non-
developer. Tracy Osborn, who has
done some nice intro web design and
web programming books, just recently
released a free e-book called "really
friendly command line intro"
26
27. you can grab a copy here --
and again, slides available
online later, so you don't have
to copy this down.
hellowebbooks.com/learn-command-line
27
28. before we do anything else,
we need to tell git
who we are
28 — intro to git — tpc 2018 — @genehack
29. git config is a git command for modifying
configuration values. in this case, we're giving it the --
global flag to indicate that we want to modify the
configuration for any use of git. and then we set the
user.name and user.email values to our name and email.
this information is needed because once we start
making changes (here in a few slides), git is going to
track who made what change. if you don't provide these
values for it, sometimes git will try to guess, and it will
probably get it wrong. (and when it doesn't guess, it will
just refuse to work until you run the above commands.)
git config --global user.name "Put your name here"
git config --global user.email "email@example.com"
29 — intro to git — tpc 2018 — @genehack
30. now that we've got the
required git configuration
done, we need to get a
repository to work on.
step one: obtaining a
repository
30 — intro to git — tpc 2018 — @genehack
31. oh, wait, there's some jargon. what's a
"repository"?
a repository is just what git calls a
project, or a directory where the
contents are under the control of git
you'll also hear people say "repo"
because "repository" is an annoyingly
long word to have to type out a bunch
jargon:
repository31 — intro to git — tpc 2018 — @genehack
32. 'clone' is what git calls making a copy
of somebody else's existing repository.
this is typically what you'll do if you
want to contribute to an open source
project -- you'll make a clone of the
project's repo so that you can look at
what's there, and possibly change it
and contribute it back to the project.
first option:
clone32 — intro to git — tpc 2018 — @genehack
33. this is the github page for an
open source project -- one
that happens to be one of
mine, a perl module for
interacting with git. if you click
this green button here...
35. ...and in fact this little circled
button here does just that,
copies the URL to the
clipboard for you.
36. then you can open up a
terminal and run the following
command to clone the
repository
git clone <url>
36 — intro to git — tpc 2018 — @genehack
37. and here's the output you'll see
when you do. this first line tells you
it's cloning into a directory named
'Git-Wrapper' in the current
working directory, and the other
lines here are just stats about the
size of the repository, basically.
$ git clone https://github.com/genehack/Git-Wrapper.git
Cloning into 'Git-Wrapper'...
remote: Counting objects: 4067, done.
remote: Compressing objects: 100% (23/23), done.
remote: Total 4067 (delta 16), reused 33 (delta 16), pack-reused 4028
Receiving objects: 100% (4067/4067), 3.20 MiB | 5.80 MiB/s, done.
Resolving deltas: 100% (1917/1917), done.
37 — intro to git — tpc 2018 — @genehack
38. the other option for getting a
repository is to create a fresh,
new empty one
second option:
diy38 — intro to git — tpc 2018 — @genehack
39. you do that with the 'git init'
command. it will create a new
repo in a directory named for
the project
git init <project-name>
39 — intro to git — tpc 2018 — @genehack
40. so, as you can see here, when we run the
command, it creates the directory for us
the directory contains only .git
.git contains a bunch of stuff
you can ignore all of this for the moment, but you
need to understand that the .git directory is where
git stores all the data about the repository itself. if
you remove the .git directory, you turn the repo
into just an ordinary directory containing files.
$ git init my-new-project
Initialized empty Git repository in /Users/genehack/my-new-project/.git/
$ ls -a my-new-project
./ ../ .git/
$ ls -a my-new-project/.git
./ ../ HEAD branches/ config description hooks/ info/ objects/ refs/
40 — intro to git — tpc 2018 — @genehack
41. ok, now we have a repo! yay!
ok, now we have a
repo41 — intro to git — tpc 2018 — @genehack
42. let's keep working with the
fresh new empty repo. the first
thing we need to do is add a
file to it.
...but first let's talk about the
lifecycle of files according to git
let’s
add a file
to it42 — intro to git — tpc 2018 — @genehack
43. here are the different states git
thinks files can be in, or the
lifecycle that a file moves
through
the lifecycle of file changes
according to git
43 — intro to git — tpc 2018 — @genehack
44. when we create a new file, it
ends up in a state called
"untracked".
untracked
staged
committed44 — intro to git — tpc 2018 — @genehack
45. so, let's add a README file
README files are traditionally found in
the top level of a repository and contain
basic introductory material about the
project -- what problems it aims to solve,
how to use it, maybe instructions on how
to contribute back to the project, etc.
so let's make that file...
let’s
add a file
45 — intro to git — tpc 2018 — @genehack
46. yes, yes, i'm an emacs user.
so, let's pretend we write some
basic stuff in the README.md and
save it
photo credit: https://
www.flickr.com/photos/rore/
4457009838 (cc/by/2.0)
emacs README.md
46 — intro to git — tpc 2018 — @genehack
47. we need to ask git what's
going on with the repository.
the way we do that ...
next, we need to ask git
“sup?”47 — intro to git — tpc 2018 — @genehack
48. ...is with a command called
git status
git status
48 — intro to git — tpc 2018 — @genehack
49. when we run git status, we see that
git is telling us, "hey, there's this file here,
but you haven't told me to track it or
anything -- just letting you know, i see it"
git also helpfully tells you, "hey, if you
want me to be be tracking it, you need to
git add it"...
$ git status
On branch master
No commits yet
Untracked files:
(use "git add <file>..." to include in what will be committed)
README.md
nothing added to commit but untracked files present (use "git add" to track)
49 — intro to git — tpc 2018 — @genehack
50. so let's run that command
next, git add
git add README.md
50 — intro to git — tpc 2018 — @genehack
51. and then check the status
again
git status
51 — intro to git — tpc 2018 — @genehack
52. and now we can see git is
telling us, "yo, got a new file
here!"
$ git status
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: README.md
52 — intro to git — tpc 2018 — @genehack
53. if you look at the
documentation for git add,
you'll see something like this:
<read slide>
git add
stages
changes to be committed
53 — intro to git — tpc 2018 — @genehack
54. there's another piece of jargon
to break down -- "staging
area" "
jargon:
staging area54 — intro to git — tpc 2018 — @genehack
55. you can even see here, in the
git status output, git is
telling us how to "unstage"
something
On branch master
No commits yet
Changes to be committed:
(use "git rm --cached <file>..." to unstage)
new file: README.md
55 — intro to git — tpc 2018 — @genehack
56. and git add is what takes us out of that
"untracked" state, and puts us into "staged".
"staged" is an area in between 'untracked'
and 'committed', which allows you to build
up what's going to be in a commit piece by
piece. this isn't something you'll care too
much about when you're just getting
started.
‘git add’ takes you
from “untracked” to
“staged”56 — intro to git — tpc 2018 — @genehack
57. so how do we go
from “staged” to
“committed”?
57 — intro to git — tpc 2018 — @genehack
59. the commit message is going to
describe what's in the commit, and
possibly why the change is being made
this is the part where your name and
email address -- the stuff we fed into
git config way back when --
comes into play
git wants commits to
have an accompanying
commit message
59 — intro to git — tpc 2018 — @genehack
60. by default, cli git uses
vimto write commit messages
60 — intro to git — tpc 2018 — @genehack
62. instead you can use the -m
flag and give the commit
message as part of the
command
git commit -m "<your message here>"
62 — intro to git — tpc 2018 — @genehack
63. to review, git add...
git add takes files
from “untracked”
to “staged”
63 — intro to git — tpc 2018 — @genehack
64. ...and git commit
git commit takes files
from “staged”
to “committed”
64 — intro to git — tpc 2018 — @genehack
67. offers easier, more flexible
committing. also refines the
branching model to be a bit
more intuitive
anybody already using gitless?
maybe check out
gitless
(gitless.com)
67 — intro to git — tpc 2018 — @genehack
68. so that covers adding a file to
the repo. what if we need to
revise it?
so, what about
edits?68 — intro to git — tpc 2018 — @genehack
69. pretend we edit the file again,
and ...
emacs README.md
69 — intro to git — tpc 2018 — @genehack
70. we ask git, "sup?"
git status
70 — intro to git — tpc 2018 — @genehack
71. and we see something new!
git tells us the file has been
modified
$ git status
On branch master
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git checkout -- <file>..." to discard changes in working directory)
modified: README.md
no changes added to commit (use "git add" and/or "git commit -a")
71 — intro to git — tpc 2018 — @genehack
72. so let's return to our lifecycle...
the lifecycle of file changes
according to git
72 — intro to git — tpc 2018 — @genehack
73. ...and we need to add a fourth
state, modified. so we have
untracked, staged, committed,
and modified.
untracked
staged
committed
modified
73 — intro to git — tpc 2018 — @genehack
74. you might wonder, since git
knows the file is changed, can
it tell you how it was changed?
can we ask git
“yo, what changed?”
74 — intro to git — tpc 2018 — @genehack
75. and yes, it can, with a
command called 'git diff'.
git diff
75 — intro to git — tpc 2018 — @genehack
76. <briefly walk through diff>
$ git diff
diff --git a/README.md b/README.md
index bf3d7ca..9a71af8 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,3 @@
# My Awesome New Project
+
+**FIXME:** write README
76 — intro to git — tpc 2018 — @genehack
77. at this point, to get the changes to
README.md committed, you're
going to do the exact same steps as
with adding the file for the first time:
you're going to use 'git add' to stage
the change, and then you're going
to use 'git commit' to commit it.
adding and editing files is
notvery different77 — intro to git — tpc 2018 — @genehack
78. first we stage the changes
git add README.md
78 — intro to git — tpc 2018 — @genehack
79. and then we commit them
git commit -m "<explain the change>"
79 — intro to git — tpc 2018 — @genehack
80. git records the commit messages and then
lets you look back at them. this is called the
'history' of the repository.
when you're first getting involved with a new
open source project, taking some time to read
over the recent history of the repo is a great
way to get up to speed -- you'll see which
files have changed recently, and see who's
actually doing the work to put in the changes
so, what's going on with those
commit
messages?80 — intro to git — tpc 2018 — @genehack
81. the way you look at the history
is with a command called git
log. running it ends up
looking like this:
git log
81 — intro to git — tpc 2018 — @genehack
82. $ git log
commit f2645941f26ab276bed99b12f170e97ca9c90106
Author: John SJ Anderson <john@genehack.org>
Date: Sat Apr 14 17:04:36 2018 -0400
Update README with FIXME
commit 3e805602660713b8f98f610cf178df70c2ceb91f
Author: John SJ Anderson <john@genehack.org>
Date: Sun Apr 15 07:00:14 2018 -0400
Add README.md
82 — intro to git — tpc 2018 — @genehack
83. you can also include the -p
flag -- for patch -- to ask git
to show you the exact lines
that were changed in each
commit. that looks like...
git log -p
83 — intro to git — tpc 2018 — @genehack
84. $ git log -p
commit f2645941f26ab276bed99b12f170e97ca9c90106
Author: John SJ Anderson <john@genehack.org>
Date: Sat Apr 14 17:04:36 2018 -0400
Update README with FIXME
diff --git a/README.md b/README.md
index bf3d7ca..9a71af8 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,3 @@
# My Awesome New Project
+
+**FIXME:** write README
84 — intro to git — tpc 2018 — @genehack
85. commit 3e805602660713b8f98f610cf178df70c2ceb91f
Author: John SJ Anderson <john@genehack.org>
Date: Sun Apr 15 07:00:14 2018 -0400
Add README.md
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..bf3d7ca
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+# My Awesome New Project
85 — intro to git — tpc 2018 — @genehack
101. the first approach is good when you've
got things into a bad state and you
think you know the fix but are worried
that you're going to mess things up
worse: make a copy, try the fix on the
copy, and then if it works, do it to actual
directory. (and if it fails, throw away the
copy and try something else!)
one:
make a copy of your repo
& try a fix
on the copy
101 — intro to git — tpc 2018 — @genehack
102. if you have modified files in the "bad" copy, don't
forget to copy those out and into the newly cloned
copy
i'm a fairly sophisticated git user. i've been using it for
over 10 year, have given multiple conference talks on
git, have led trainings on git, and i've managed to
screw things up in a repo so badly that i've done this
"just re-clone it" more than once in the last year.
there's no shame in doing this; sometimes things just
get so bollixed up that it's easier to start over than to
unbollix them.
two: rename your repo directory
(from ‘repo’ to ‘repo.bad’)
and then re-clone the repo
102 — intro to git — tpc 2018 — @genehack