Video 2 - Version Control Basics

Loading...

来自 University of New Mexico 的课程

Web Application Development: Basic Concepts

120 个评分

University of New Mexico

Web Application Development: Basic Concepts

120 个评分

This is the first course in a Coursera Specialization track involving Web Application Architectures. This course will give you the basic background, terminology and fundamental concepts that you need to understand in order to build modern full stack web applications. A full stack web developer is familiar with each "layer" of the software technologies involved in a web application, including data modeling and database technologies, the web server environment and middleware components, network protocols, the user interface and basic visual design and user interaction concepts. In this course we will learn by doing. We will start by learning the major components of web application architectures, along with the fundamental design patterns and philosophies that are used to organize them. You will build and continually refine a fully functional full-stack web application as we progress through the modules in this course. Along the way you will be exposed to agile software development practices, numerous tools that software engineers are expected to know how to use, and a modern web application development framework. This course is also available in Spanish. To join the Spanish version, visit this page: https://www.coursera.org/learn/apliweb.

从本节课中

Module #2 - Web Applications Frameworks

In this module you will learn about web application frameworks. We will start by talking about the evolution of software and programming languages, and then talk about software application frameworks. The fundamental trade-off we will consider is programmer productivity versus program efficiency. Next you will learn about web application frameworks, as well as the model-view-controller design pattern that is the backbone for many of these frameworks. We will also consider how these frameworks support the agile programming principles associated with modern software practice. This will include a discussion of distributed version control systems and you will learn how to use the popular Git system. We will also demonstrate how to use Git with a Ruby on Rails application. We will use Git to submit all of the programming applications in this specialization.

Version Control - An Overview0:19

Video 1 - Why Version Control3:22

Video 2 - Version Control Basics2:52

Video 3 - Git Introduction7:50

Video 4 - Git in Practice4:51

与讲师见面

Greg Heileman
Professor and Associate Provost
Electrical and Computer Engineering
Manel Martínez-Ramón
Professor
Electrical and Computer Engineering

[MUSIC]

>> Let's go over some basic concepts associated with version control.

I'll talk about the theory behind centralized version control systems, and

then I'll go over the theory associated with the more recent distributed

control systems.

Even if you're a single developer,

working on your own, you need some type of version control to keep track of

the versions associated with the software you're developing.

You may need this in order to back track to a previous version of your code,

if you introduce an error that you can't track down after really breaking things.

Or you may need it for other reasons.

Let's take a look at how you might do this.

You might have some type of version controlled database, which could be

as simple as keeping versions within subdirectories on your local file system.

Here, I show version one of a software system that has three files.

Files A, B and C and in version two I show a file C prime.

This is C Files C after being modified relative to each state version 1.

Next on the left I show that the developer has checked out file

A from version 2 made edits to the file and then,

checks that file back in, in order to create version 3 of the software.

And then this version files A and

C had been modified relative to the first version.

What I just showed you will work fine for a single developer.

But it's not going to work very well for a team of developers who are all trying to

work on a software system at the same time.

Traditionally, version control has been managed by keeping a centralized

version control system that team members would use to check code in to and

out of A central repository is used so that developers can share files.

You want developers to be able to work in parallel, but

you need to make sure they're not writing over each other's work.

The typical approach is to lock a file whenever it's checked out by a team member

who then owns that file.

Others can't modify the file until that current owner checks it back in.

So here I show Developer 1.

Checking out file A, this gets noted in the repository and

Developer 2 is prevented from modifying file A during this time.

During the time that is checked out the Developer 1.

Developer 2 however can't check out and modify file B.

How do these centralized version control systems work?

Well they store differences.

So they store the difference between Version 1 and Version 2 is only file C was

changed so that delta is stored, Version 3 I show two deltas for file A and one for

file B and so on and so forth, so this is how Centralized Version Control works,

it only stores the differences between file as editor made.

探索我们的目录

免费加入并获得个性化推荐、更新和优惠。

Coursera 致力于普及全世界最好的教育，它与全球一流大学和机构合作提供在线课程。

© 2018 Coursera Inc. 保留所有权利。

通过 App Store 下载

通过 Google Play 获取