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.
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.
An 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.
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.
An 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: 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
Flash talk about « versions » a simple program to check version change in programs and let you know in your terminal. It was at sysadmin #8 in octobre 2018.
T3CON12 Flow and TYPO3 deployment with surfTobias Liebig
Video: http://t3con12.chaoscdn.de/T3CON12DE.Int.Automate.FLOW3.and.TYPO3.Deployment.with.Surf.mp4
TYPO3.Surf on Forge: http://forge.typo3.org/projects/show/package-typo3-surf
EXT:coreapi on Forge: http://forge.typo3.org/projects/show/extension-coreapi
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
Flash talk about « versions » a simple program to check version change in programs and let you know in your terminal. It was at sysadmin #8 in octobre 2018.
T3CON12 Flow and TYPO3 deployment with surfTobias Liebig
Video: http://t3con12.chaoscdn.de/T3CON12DE.Int.Automate.FLOW3.and.TYPO3.Deployment.with.Surf.mp4
TYPO3.Surf on Forge: http://forge.typo3.org/projects/show/package-typo3-surf
EXT:coreapi on Forge: http://forge.typo3.org/projects/show/extension-coreapi
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.
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/
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 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
E-commerce Application Development Company.pdfHornet Dynamics
Your business can reach new heights with our assistance as we design solutions that are specifically appropriate for your goals and vision. Our eCommerce application solutions can digitally coordinate all retail operations processes to meet the demands of the marketplace while maintaining business continuity.
Mobile App Development Company In Noida | Drona InfotechDrona Infotech
Looking for a reliable mobile app development company in Noida? Look no further than Drona Infotech. We specialize in creating customized apps for your business needs.
Visit Us For : https://www.dronainfotech.com/mobile-application-development/
Top Features to Include in Your Winzo Clone App for Business Growth (4).pptxrickgrimesss22
Discover the essential features to incorporate in your Winzo clone app to boost business growth, enhance user engagement, and drive revenue. Learn how to create a compelling gaming experience that stands out in the competitive market.
Software Engineering, Software Consulting, Tech Lead, Spring Boot, Spring Cloud, Spring Core, Spring JDBC, Spring Transaction, Spring MVC, OpenShift Cloud Platform, Kafka, REST, SOAP, LLD & HLD.
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.
Atelier - Innover avec l’IA Générative et les graphes de connaissancesNeo4j
Atelier - Innover avec l’IA Générative et les graphes de connaissances
Allez au-delà du battage médiatique autour de l’IA et découvrez des techniques pratiques pour utiliser l’IA de manière responsable à travers les données de votre organisation. Explorez comment utiliser les graphes de connaissances pour augmenter la précision, la transparence et la capacité d’explication dans les systèmes d’IA générative. Vous partirez avec une expérience pratique combinant les relations entre les données et les LLM pour apporter du contexte spécifique à votre domaine et améliorer votre raisonnement.
Amenez votre ordinateur portable et nous vous guiderons sur la mise en place de votre propre pile d’IA générative, en vous fournissant des exemples pratiques et codés pour démarrer en quelques minutes.
GraphSummit Paris - The art of the possible with Graph TechnologyNeo4j
Sudhir Hasbe, Chief Product Officer, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Globus Compute wth IRI Workflows - GlobusWorld 2024Globus
As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.
OpenMetadata Community Meeting - 5th June 2024OpenMetadata
The OpenMetadata Community Meeting was held on June 5th, 2024. In this meeting, we discussed about the data quality capabilities that are integrated with the Incident Manager, providing a complete solution to handle your data observability needs. Watch the end-to-end demo of the data quality features.
* How to run your own data quality framework
* What is the performance impact of running data quality frameworks
* How to run the test cases in your own ETL pipelines
* How the Incident Manager is integrated
* Get notified with alerts when test cases fail
Watch the meeting recording here - https://www.youtube.com/watch?v=UbNOje0kf6E
Need for Speed: Removing speed bumps from your Symfony projects ⚡️Łukasz Chruściel
No one wants their application to drag like a car stuck in the slow lane! Yet it’s all too common to encounter bumpy, pothole-filled solutions that slow the speed of any application. Symfony apps are not an exception.
In this talk, I will take you for a spin around the performance racetrack. We’ll explore common pitfalls - those hidden potholes on your application that can cause unexpected slowdowns. Learn how to spot these performance bumps early, and more importantly, how to navigate around them to keep your application running at top speed.
We will focus in particular on tuning your engine at the application level, making the right adjustments to ensure that your system responds like a well-oiled, high-performance race car.
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.
Graspan: A Big Data System for Big Code AnalysisAftab Hussain
We built a disk-based parallel graph system, Graspan, that uses a novel edge-pair centric computation model to compute dynamic transitive closures on very large program graphs.
We implement context-sensitive pointer/alias and dataflow analyses on Graspan. An evaluation of these analyses on large codebases such as Linux shows that their Graspan implementations scale to millions of lines of code and are much simpler than their original implementations.
These analyses were used to augment the existing checkers; these augmented checkers found 132 new NULL pointer bugs and 1308 unnecessary NULL tests in Linux 4.4.0-rc5, PostgreSQL 8.3.9, and Apache httpd 2.2.18.
- Accepted in ASPLOS ‘17, Xi’an, China.
- Featured in the tutorial, Systemized Program Analyses: A Big Data Perspective on Static Analysis Scalability, ASPLOS ‘17.
- Invited for presentation at SoCal PLS ‘16.
- Invited for poster presentation at PLDI SRC ‘16.
Large Language Models and the End of ProgrammingMatt Welsh
Talk by Matt Welsh at Craft Conference 2024 on the impact that Large Language Models will have on the future of software development. In this talk, I discuss the ways in which LLMs will impact the software industry, from replacing human software developers with AI, to replacing conventional software with models that perform reasoning, computation, and problem-solving.
1. an introduction to
git
(even for non-developers)
john sj anderson · @genehack · os101/columbia • 17 apr 2018
1 — intro to git — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @genehack
12. 12 — intro to git — os101/columbia — @genehack
13. revision control systems
(rcs, cvs, svn, tfs, git, etc)
are a fundamental
building block of software development.
13 — intro to git — os101/columbia — @genehack
14. <insert rant about how this
stuff should be taught in
school>
a brief
aside14 — intro to git — os101/columbia — @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 — os101/columbia — @genehack
16. 16 — intro to git — os101/columbia — @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 — os101/columbia — @genehack
19. git is also not
github.19 — intro to git — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @genehack
33. this is the github page for an
open source project -- one
that happen's 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 — os101/columbia — @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 — os101/columbia — @genehack
38. the other option for getting a
repository is to create a fresh,
new empty one
second option:
diy38 — intro to git — os101/columbia — @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 — os101/columbia — @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 — os101/columbia — @genehack
41. ok, now we have a repo! yay!
ok, now we have a
repo41 — intro to git — os101/columbia — @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.
let's add a README file with some basic info about
the project
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
to it42 — intro to git — os101/columbia — @genehack
43. 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
43 — intro to git — os101/columbia — @genehack
44. we need to ask git what's
going on with the repository.
the way we do that ...
next, we need to ask git
“sup?”44 — intro to git — os101/columbia — @genehack
45. ...is with a command called
git status
git status
45 — intro to git — os101/columbia — @genehack
46. 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)
46 — intro to git — os101/columbia — @genehack
47. so let's run that command
next, git add
git add README.md
47 — intro to git — os101/columbia — @genehack
48. and then check the status
again
git status
48 — intro to git — os101/columbia — @genehack
49. 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
49 — intro to git — os101/columbia — @genehack
50. if you look at the
documentation for git add,
you'll see something like this:
<read slide>
git add
stages
changes to be committed
50 — intro to git — os101/columbia — @genehack
51. there's another piece of jargon
to break down -- "staging
area" "
jargon:
staging area51 — intro to git — os101/columbia — @genehack
52. 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
52 — intro to git — os101/columbia — @genehack
53. to get this jargon, you need to
understand 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
53 — intro to git — os101/columbia — @genehack
54. as we saw, when we create a
new file, it ends up in a state
called "untracked".
untracked
staged
committed54 — intro to git — os101/columbia — @genehack
55. 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”55 — intro to git — os101/columbia — @genehack
56. so how do we go
from “staged” to
“committed”?
56 — intro to git — os101/columbia — @genehack
58. 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
58 — intro to git — os101/columbia — @genehack
59. by default, cli git uses
vimto write commit messages
59 — intro to git — os101/columbia — @genehack
61. instead you can use the -m
flag and give the commit
message as part of the
command
git commit -m "<your message here>"
61 — intro to git — os101/columbia — @genehack
62. to review, git add...
git add takes files
from “untracked”
to “staged”
62 — intro to git — os101/columbia — @genehack
63. ...and git commit
git commit takes files
from “staged”
to “committed”
63 — intro to git — os101/columbia — @genehack
64. so that covers adding a file to
the repo. what if we need to
revise it?
so, what about
edits?64 — intro to git — os101/columbia — @genehack
65. pretend we edit the file again,
and ...
emacs README.md
65 — intro to git — os101/columbia — @genehack
66. we ask git, "sup?"
git status
66 — intro to git — os101/columbia — @genehack
67. 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")
67 — intro to git — os101/columbia — @genehack
68. so let's return to our lifecycle...
the lifecycle of file changes
according to git
68 — intro to git — os101/columbia — @genehack
69. ...and we need to add a fourth
state, modified. so we have
untracked, staged, committed,
and modified.
untracked
staged
committed
modified
69 — intro to git — os101/columbia — @genehack
70. 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?”
70 — intro to git — os101/columbia — @genehack
71. and yes, it can, with a
command called 'git diff'.
git diff
71 — intro to git — os101/columbia — @genehack
72. <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
72 — intro to git — os101/columbia — @genehack
73. 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 different73 — intro to git — os101/columbia — @genehack
74. first we stage the changes
git add README.md
74 — intro to git — os101/columbia — @genehack
75. and then we commit them
git commit -m "<explain the change>"
75 — intro to git — os101/columbia — @genehack
76. 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?76 — intro to git — os101/columbia — @genehack
77. the way you look at the history
is with a command called git
log. running it ends up
looking like this:
git log
77 — intro to git — os101/columbia — @genehack
78. $ 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
78 — intro to git — os101/columbia — @genehack
79. 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
79 — intro to git — os101/columbia — @genehack
80. $ 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
80 — intro to git — os101/columbia — @genehack
81. 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
81 — intro to git — os101/columbia — @genehack
94. 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
94 — intro to git — os101/columbia — @genehack
95. 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
95 — intro to git — os101/columbia — @genehack