Name: golang（Learn Go Programming - Golang Tutorial for Beginners）
Uploaded: 2022-03-05T06:24:41.000Z
Duration: 6 h 39 min 58 s
Description: 【看影片學英語】數萬部 YouTube 影片，搭配英漢字典即點即查，輕鬆掌握單字發音與用法，長久累積看電影不必再看字幕。

反身代名詞

So I wanted to start out with an introduction to the go language itself. Now I know that

基礎被動語態

this is much storied territory, but I have to start somewhere. And this is going to serve

as a stepping off point for us to go through a survey of the entire go language, as well

as hitting some of the key libraries along the way. So the first thing that we need to

know is that go is created by a small team within Google. And that team was made up of

Robert griesemer, Rob Pike, and Ken Thompson. Now these guys have been around the software

industry for a little while, for example, Ken designed and implemented the first Unix

operating system, as well as had a key role in the development of Unicode. So when these

guys got together and decided that they wanted to create a language, we had a lot of talent

in the room as soon as these guys got together. But one of the questions that we need to understand

is, why create a new language at all? Well, to understand that, we have to look at the

languages that are common inside of Google. And that's the time that go is being designed,

there were really three languages that were key. The first is Python, then Java, and then

C and c++. Now, each of these languages in and of itself is very powerful. However, the

go designers started to recognize that there were some limitations that Google was running

into, that might not be able to be fixed, given the history and the designs of the existing

languages. So for example, when we look at Python, Python is very easy to use, but it's

an interpreted language. And so it can be a little bit difficult to run applications

at Google scale that are based on Python, it can certainly happen. But that is one of

the challenges that you can run into in very large Python implementations. Java is very

quick, but its type system has become increasingly complex over time. Now, this is a natural

trend that a lot of languages go through. They start out very simple, but it has additional

use cases and additional features are layered into the language, it becomes increasingly

more difficult to navigate things C and c++ is quick as well. However, it suffers from

a complex type system. And additionally, its compile times are notoriously slow. Now, the

type system has been receiving a lot of attention lately in the C and c++ communities. However,

they still have the burden of needing to manage all that legacy code. And so similar to Java,

it's very difficult for them to move past the history that they have, because c++ applications

written 10 years ago still need to compile today. And the slow compile times are another

legacy issue that C and c++ have inherited as well. When C and c++ were designed computers

had nowhere near as much memory as they do today. So the decision was made to optimize

the compilers to use a minimum amount of memory. And one of the compromises that that brought

about was the compile times can be a little bit sluggish. In addition, all three of these

languages were created in a time where multi threaded applications were extremely rare.

Almost every application that was created really had to focus on a single thread at

a time. So concurrency patterns built into these languages are patched in at best. And

so working in highly parallel, highly concurrent applications like Google often runs into can

be a little bit challenging when working in these three languages. So enter go, What does

go bring to the party in order to address some of these concerns? Well, the first thing

that we need to understand is gozi, strong and statically typed language, so it inherits

that same feature set from Java and c++. So what do we mean by strong and statically typed

with strong typing means that the type of a variable cannot change over time. So when

you declare a variable a to hold an integer, it's always going to hold an integer, you

can't put a Boolean in it, you can't put a string in it. And static typing means that

all of those variables have to be defined at compile time. Now, are there ways around

that? Yes, go does have features that allow you to get around its type system, but 99%

of the time, you're going to be living in a world that's strong and statically typed.

And getting all the benefits that come with that. Now, if you come from languages such

as Java, then you might be a little concerned that strong and statically typed languages

tend to be a little bit verbose. Well, we'll see as we get into some go syntax, how there's

been a lot of effort taken to make the compiler do as much work to understand what you're

talking about with a variable. So you don't have to explain to the compiler every time

what your variable types and things like that are.

In addition, go like a lot of recent languages has a strong focus on the community that supporting

it. Just because go is an excellent language does not guarantee success. Because there

are so many languages out there, that it can become difficult for a new developer to ramp

up in any one. As a result, there's a strong community built up around go that's really

focused on making sure that the go language keeps moving forward, and that new developers

have an easier time as possible ramping up onto the language. So what are some of the

key features of the language itself? One of the first and I would argue most important

features that go has is a recognition that simplicity is a feature. So as we go through

and start learning about the go language, you're going to run into some features and

you're going to ask yourself, Well, why doesn't this exist? Or why don't we have that feature?

And a lot of the reasons Come back to this feature. There's a recognition that if the

go language recognizes simplicity is important, then that means that we're going to have to

decide to leave out some other features that might be very useful, but would add complexity

to the language. Additionally, go focuses on extremely fast compile times a lot of modern

development environments to write code fast to build it fast and to test it fast and get

feedback back to the developer as quick as possible. Well, if you've got a 45 minute

compile time, it breaks that cycle. And developers have a very hard time staying in that design

build test loop. And so go focuses on keeping those compile times down, even though it's

going to yield us fully compiled binaries at the end, go as a garbage collected language,

which means that you're not going to have to manage your own memory. Now you can manage

your own memory. But by and large, the go runtime is going to manage that for you. And

the reason for that gets back to this simplicity argument, there is a recognition that a garbage

collected language does have challenges when dealing with certain use cases. For example,

real time trading systems for stock market systems have a very hard time when you're

dealing with garbage collection. However, the advantages on the developer of not having

to manage their own memory all the time, were deemed to be more important. Now, that doesn't

mean that the delays that a garbage collector incurs haven't been paid attention to, if

you go back through the history of the go language, you'll actually see the past few

versions have had a huge emphasis on reducing the amount of time that the application has

to pause during a garbage collection cycle. And at this point, they're actually really

fast, almost to the point that you don't know that a garbage collection happened, in order

to address that concern of concurrency go does have concurrency primitives built right

into the language. And we'll talk about that as we go through some of these videos. But

instead of having a library that we're going to have to import, in order to work with concurrency,

we're going to be able to do concurrent development right there in the base language. Finally,

go compiles down to a standalone library, which means when you compile your go application,

everything is going to be bundled into that single binary that's related to the go application

itself. So the go runtime is going to be bundled in there, any libraries that you're depending

on, they're going to be compiled in there. So you don't have to worry about reaching

out to external libraries and DLLs, and things like that in order to make your application

work. And what that gives you is version management at runtime becomes trivial. Because you simply

have one binary, you deploy that binary, you run it, and all of its dependencies are there.

Now keep in mind, when I say dependencies, I mean to go dependencies, if you're going

to build a web application that has HTML, resources, and CSS, those have to be bundled

along with the binary, but the binary itself is standalone and self contained. Okay, the

next thing that I'd like to do is show you some of the resources that are available to

you, as you start to explore the go language.

字幕列表影片播放

golang（Learn Go Programming - Golang Tutorial for Beginners）

access

multiple

situation

constant