The State of Go
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Subtitle |
| |
| Title of Series | ||
| Number of Parts | 490 | |
| Author | ||
| License | CC Attribution 2.0 Belgium: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/47361 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
FOSDEM 2020444 / 490
4
7
9
10
14
15
16
25
26
29
31
33
34
35
37
40
41
42
43
45
46
47
50
51
52
53
54
58
60
64
65
66
67
70
71
72
74
75
76
77
78
82
83
84
86
89
90
93
94
95
96
98
100
101
105
106
109
110
116
118
123
124
130
135
137
141
142
144
146
151
154
157
159
164
166
167
169
172
174
178
182
184
185
186
187
189
190
191
192
193
194
195
200
202
203
204
205
206
207
208
211
212
214
218
222
225
228
230
232
233
235
236
240
242
244
249
250
251
253
254
258
261
262
266
267
268
271
273
274
275
278
280
281
282
283
284
285
286
288
289
290
291
293
295
296
297
298
301
302
303
305
306
307
310
311
315
317
318
319
328
333
350
353
354
356
359
360
361
370
372
373
374
375
379
380
381
383
385
386
387
388
391
393
394
395
397
398
399
401
409
410
411
414
420
421
422
423
424
425
427
429
430
434
438
439
444
449
450
454
457
458
459
460
461
464
465
466
468
469
470
471
472
480
484
486
487
489
490
00:00
State of matterState of matterComputer animation
00:21
Formal languageLibrary (computing)Beta functionMathematicsComputer animation
01:05
Formal languageInterface (computing)Imaginary numberFile formatShift operatorNumerical digitSinc functionFormal languageMultiplication signSlide ruleImaginary numberNumberShift operatorPolygonBitPotenz <Mathematik>Power (physics)Goodness of fitMathematicsInterface (computing)Standard deviationDivisorCASE <Informatik>WordAdditionGraph coloringPoint (geometry)ExponentiationComputer animation
04:39
NumberExponentiationImaginary numberComputer animation
05:00
Electronic signatureCodeTerm (mathematics)Reading (process)Type theoryInterface (computing)Closed setType theoryObject-oriented programmingCASE <Informatik>Error messageParameter (computer programming)Right angleRhombusComputer animation
06:10
Data recoveryLink (knot theory)Public key certificateRSA (algorithm)Web browserError messageType theoryContext awarenessHacker (term)RippingImpulse responseFunction (mathematics)SequenceHash functionSimilarity (geometry)Perfect groupTable (information)Library (computing)Standard deviationInclusion mapCodeRun time (program lifecycle phase)MathematicsFormal languageStandard deviationLibrary (computing)CoroutineContext awarenessReading (process)Canadian Light SourcePublic-key cryptographyCodeAdditionError messageAuthorizationRecursionSoftware bugPublic key certificateFerry CorstenRun time (program lifecycle phase)Configuration spaceOpen setFunctional (mathematics)Type theorySign (mathematics)String (computer science)Software testingRSA (algorithm)Exception handlingDefault (computer science)CurveEncryptionWeb browserComputer fileMereologyUniform resource locatorWindowLevel (video gaming)MappingInterface (computing)Direction (geometry)Hash functionoutputPhysical systemDirectory serviceImplementationCartesian coordinate systemDatabaseQuery languageLink (knot theory)Multiplication signBenchmarkComputer animation
13:01
Software testingFunction (mathematics)Parallel portImplementationProgram slicingIntegerPointer (computer programming)Software testingType theoryFunctional (mathematics)ImplementationMultiplication signModule (mathematics)String (computer science)Default (computer science)Computer animation
14:37
Module (mathematics)Modul <Datentyp>Formal verificationSummierbarkeitProxy serverDirectory serviceSoftware repositoryPublic key certificateMechanism designInheritance (object-oriented programming)Self-organizationIntegrated development environmentCase moddingMultiplication signText editorCodeVariable (mathematics)Default (computer science)Point (geometry)DatabaseHash functionModule (mathematics)Dot productMathematicsComputer animation
17:21
Module (mathematics)Virtual machineWebsiteComputer animation
18:03
Convex hullAdditionLatent heatStreaming mediaMathematicsStack (abstract data type)BuildingDirectory serviceComputer fileRun time (program lifecycle phase)Binary codeReal numberLine (geometry)FlagVirtual machineComputer animation
19:08
CodeFunction (mathematics)Pointer (computer programming)Scheduling (computing)Android (robot)Exception handlingCoroutineSubject indexingCASE <Informatik>LengthComputer programmingGoodness of fitRevision controlLetterpress printingPoint (geometry)Link (knot theory)outputMathematicsArmBound stateRepresentational state transferPoint cloudSlide ruleServer (computing)CodeAndroid (robot)Multiplication signClient (computing)Computer animation
22:03
GoogolBinary fileRead-only memoryBefehlsprozessorWindowSinc functionDialectComputer animation
22:45
Event horizonComputer programmingWindowTranslation (relic)System callGame controllerEvent horizonTerm (mathematics)Computer animation
23:08
Ultraviolet photoelectron spectroscopyEvent horizonSoftware developerComputer networkMereologyLevel (video gaming)SoftwareEvent horizonSoftware developerComputer animation
23:47
1 (number)Computer animation
24:36
2 (number)Slide ruleComputer animation
25:21
Row (database)BitBuildingEvoluteComputer animation
25:43
Data storage deviceFamilyBitComputer animation
26:07
Computer animationLecture/Conference
26:35
State of matterComputer animation
27:20
FacebookPoint cloudOpen sourceComputer animation
Transcript: English(auto-generated)
00:05
Cool, so thank you everyone for waking up so early and coming to the Go Dev Room. So we're gonna start, as we always start with the state of Go, we're gonna be covering all of the things that have happened since Go 1.12, which is actually a bunch of things.
00:21
I am Francesc Campoy, and I'm here with Marche, which is the co-organizer of the Dev Room. Without her, none of this would have been possible, so thank you. So what happened since Go 1.12? Go 1.13, also 1.14 eventually, 1.12 was out back in September, and 1.14 will be out sometime
00:46
hopefully February, but we still don't know. Beta 1 has been out for a while, so you could try it out. Beta 2 I think will be coming out, but I'm not really sure about those plans. So we're gonna be talking, as we always do, about all of the changes to the Go community,
01:01
but also the language, the standard library, and the tooling. So with that, since we don't have that much time, let's go directly into what has changed to the language since Go 1.12. In the last time I did this talk, I had a very cute slide saying nothing, because nothing has changed. This time I actually had things to say, which is new. So two things have changed.
01:22
In Go 1.13, we got new number literals, and in Go 1.14, we changed the way embedded interfaces work, slightly. So let's go with the number literals. So now you can use binaries. Yay! 0B101 is five, but also you can use octals.
01:40
We had octals already. 010 has always been, surprisingly to many people, eight, not 10. But now you can make it a little bit more clear by using 0O, either upper or lower case. In addition to that, you can also use imaginary numbers everywhere. So if you've always wished to use imaginary binary numbers, congratulations, now you can.
02:04
Hexadecimals have also evolved. So now we have two new things to the hexadecimals. And I see weird faces. I know. So the goal of this is actually to make Go be more compatible with other languages or rather make the numbers in Go similar to other languages. This is actually following a standard.
02:22
I am not really sure, personally, in what use cases you would use this. But if you know about any, I'd be interested in knowing. So the way this works is that we have floating points. And floating points, if you have 0.1 in decimal, it means that the 1 is divided by the base, 10. Here's the same. 0.1 in hexadecimal, you're dividing by the base, 16.
02:43
So 0.1 is actually 1 16th. And then you have exponents, and those exponents multiply by two to the power of that exponent. So if you have something like 8.c p3, that is 8.c is 10, which is multiplied by 1, the base 0.
03:02
Then plus 12, which is c, divided by 16. Then you add that, then you multiply it by 2, divide it to the power of 3, and then you get number 86. Write 86 if you have to. Cool. Also related to exponentials to the power of 2, we have shifts. And shifts have changed in a very slight way,
03:21
but very useful, actually. Previously, you could only shift numbers by unsigned integers, which means that if you had a negative number, you would convert it to an unsigned integer, have an overflow, get a different number which was wrong, and then do a shift by that. Now you don't need to do that conversion, which
03:40
means that now you're able to say, I want to do a shift by minus 2, and you will get a panic, which is actually better than letting it work. So I think that this is a very good change slide, but you might get new panics. So this is a new panic in Go 1.13 that you might have never seen before. You can also separate numbers with underscores when they're very long, which might be a very good idea
04:01
or a very bad idea, depending on how you use them. So what can you do? You can have good ideas. That is a million, and it's obviously a million. You don't need to count the zeros, so that's useful. You can also have dates, which, by the way, I forgot the word. Polyandrome. Poly what? Polyandrome? Androme. No? Poly something.
04:20
What is the word that starts and begins the same way? Palindrome. Palindrome, there you go. So today is a palindrome date in all formats. Yeah, I know. And also you can use colors. Bad ideas, 0x15p1, it's still 42, so just write 42. More bad ideas.
04:40
Do not do this. This is an actual number now, and it's something, 500 something imaginary. Do not do that. Also, I think it's a bug, but you can put as many zeros in the exponent as you want. So this is actually a number, and it will parse, which is a very bad idea. I think that's a bug, probably. So yeah, cool.
05:01
So that's four numbers. The overlapping interfaces can be appended. What's new about that? So previously, if you had this interface, this would not compile, because both read closer and write closer have a method close that both return error. They're both exactly the same method, but they're from different interfaces.
05:21
So these will not compile. You will get duplicate method close. Since go 1.14, this actually works. But it only works when both methods have the same type. So this type, in this case close, doesn't get any parameters and returns an error. That's it, right? The question right away might be for people that are coming from more object-oriented
05:42
languages is, oh, what method are you using? Diamond problem. Doesn't matter, because these are interfaces. That is not really an issue. You just say that there's a method close. This works when the methods are exactly the same. If they're not exactly the same, like in here where my closer doesn't return an error, you will still get the now somehow weird error message
06:04
duplicate method close, which means that they're actually not the same, which is weird. But whatever. OK, cool. So that is all of the changes to the language. And now we continue with standard library with Marcin. Thank you. So this year, we're going to have a lot of changes in the standard library. So let's get started.
06:22
First, we have some breaking changes. First of all, the removal of sslv3, which started in 1.13. And it's completely gone in 1.14. Finally. You shouldn't have been using sslv3 anyway, since it can be easily attacked using the so-called poodle attack, which you can just use to intercept all traffic.
06:41
That's a very creepy logo. Also a breaking change is that runtime go exit can no longer be aborted by a recursive panic recover, which I honestly think is a real bug. And it's just been fixed now. So in previous versions, you could use this code, which was you do a runtime go exit.
07:04
And then into the first, you panic and recover. And then suddenly, your go routine won't actually exit. In this case, it's the main go routine. And it will just continue executing and printing. So we also have a lot of changes in cls in Go. As we know, sslv3 is gone.
07:22
We also have a new addition to the certificates authority parts in Go, which we will look for, to fix a bug in Alpine 3.7. It will now look for slash sc slash ssl slash shirt.pem. However, you probably never noticed this was an issue because Alpine just puts a copy in the default location that Debian uses.
07:41
For Docker users, you still need to do apk install ci certificates. What's also new in Go 1.13 is ed255.9 certificates. These are already very popular in SSH and we're now adding them to cls and htps and so forth. The big advantage is that the public key
08:00
is only 32 bytes long and it is even faster than any RSA encryption. This also uses a publicly documented curve unlike some other encryptions that is probably influenced by the NSA, so this one is safe. The downside is no browser supports this yet, so Go is just early, maybe in 10 years.
08:22
There's also a lot of improvements in error handling in Go 1.13, especially error wrapping, checking error types, and checking error values. What we have is this problem here. For example, I do a read config and I want to check if my config file actually gets the error or does not exist.
08:41
We can do this. We can do error is equal to os error dot error not exists. However, when we add additional context in read config, this test does no longer work. We want to do more advanced checks, we will get very hacky code which we don't like. What is the solution? The solution is we can now wrap errors in Go.
09:02
How do we do that? We use fmt error f and we use a new percent sign w verb. This is our read config from before and we now check open config.json. We check for an error and now we can wrap this error and we can say cannot open config.json, then our verb,
09:20
and this will actually wrap all the errors in there and will actually keep the type from these errors. Before you could wrap errors with percent sign v and we will always get an error of type, error string error. Now with wrap, we get error wrap error. With this type wrap error, we can continue
09:41
and use helper functions from the errors library and we can do errors dot is. So this will actually unwrap all the errors that are inside and check if any of them is equal to os error not exist. We can even take this further. For example, we're querying a database and we want to check if we have a specific query error.
10:01
We can use a new helper function errors dot s which will check if any wrapped error is of the type query error and expose it to us. We also have something new in os. We have os user config there. This actually builds on the other feature I didn't know about in Go 1.12
10:21
which was os user home there. Who has ever here used os user home there? Did anyone know about that? I didn't know either until yesterday so that's, okay, it's useful. So this new user config builds on top of the home there and it will look for the config directory
10:41
for your local system. On Linux it's a dollar sign home slash dot config application support on any Mac or iOS drawing based system and add data on Windows. And for hashing, it's for you. Thank you. So there's a new package in the standard library that is really cool. It's hash map hash. Yes, so hash map hash, it exposes the hashing mechanism,
11:04
the hashing functions that maps using Go by default. So whenever you use maps in Go, this is the hash that is being used. It is new in Go 1.14 and it is, I mean, it's used for maps so it is very good for maps and things like maps and other things that look like maps.
11:21
So it is the fastest thing in the Go standard library. Yay, which made me think directly. The fact that they say in the standard library means that there's something faster outside, yes. So there's C-Spay XX hash, which is actually an implementation of the XX hashing algorithm, which is probably the fastest one I had seen so far.
11:41
It is still way faster than map hash. I think that the reason for this is actually that hash inside of the standard library needs to satisfy interfaces and that makes it slower, unfortunately. Interestingly, I thought that we would be able to, I worked for this company called D-Graph who have a caching thing called Ristretto
12:01
where we use this, this hash. And we were using it in a very hacky way. And it turns out that is exactly what the standard library does. So what they do is they expose through Go link name, they're able to expose the runtime function that is actually using assembly directly into the standard library. And then they wrap it with interfaces and stuff,
12:21
which makes it a little bit slower. In Ristretto, we do this, which is basically the same thing, but no interfaces. And turns out that this code is 10 times faster than the one that's on the library. So I wanna propose a bug. Hi, Carmen. So I think that we could do much better.
12:40
We could be 10 times faster. And for hashing functions, I think that fast is better than idiomatic. So let's go with testing. We also got two new improvements in testing this year. In 1.13, we got reflect.e0. And in 1.14, we got cleanups, finally, in testing and benchmarks.
13:02
So the first is our reflect is zero. Now we can do in Go, we can use reflect to then take a value of any variable and check if that value is equal to the zero type of a specific type. For example, integer zero is zero, true. An empty string is default zero type of a string,
13:21
so it's true. However, we have to be careful with slices in the pointers. So here, an empty slice is false, but the nil slice is true because the nil is a zero type of the pointer. We also have cleanup. So when we run test, we can now add t.cleanup,
13:43
which will run on the end of the complete run of all your tests and will clean up any things that you have done to make your test possible. How is this different from defer? Well, that has to do with when you use parallel tests and subtests, this might actually be more favorable over defer.
14:00
So we also got two new improvements in time. We got two new functions on duration. We got dot milliseconds and dot microseconds. As the name suggests, they return the integer value of the duration. The implementation is actually quite simple. It's just take the duration and divide it by zero x one f four p plus o nine,
14:21
also better known as just the thousands. That's a joke. And for tooling, back to you. Cool, thank you. So tooling for Go, so Go modules. Yeah, I cannot not talk about Go modules, so we're gonna talk about Go modules, but unfortunately, there's way too much to say about Go modules.
14:41
There's a lot of things that have changed. So I'm just gonna cover the most important changes. That said, the whole theme is Go modules got much better, which is very good. So Go 1.11 modules or Go 1.11 modules, depending on how you want to read it. When you set it to on, it says you're using modules. When you set it to off, it says you're not using modules.
15:01
But when you set it to auto, it used to be depending on whether you're inside of the Go path or not, which was confusing. So now instead, it works on whether we can find Go dot mod and it looks for it in the current directory or any of the directories that are parent of the current one. This is kind of like the way it works for Go path and vendor, all that stuff, same mechanism.
15:22
If you want to know how whether you're inside of a Go mod or not, you can actually use Go and Go mod, which is an environment variable, which tells you whether you found a Go dot mod or not. And funny enough, that also got like 10 times faster than the previous version, which means that now it actually works really well, even on your editor and stuff like that, which is nice.
15:43
There's also this environment variable Go sum db, which defaults to sum dot golang dot org. The point of this variable is it allows, when you download it in a package, if it's the second time you download it, you can actually check that it's the same one that you had because Go dot sum. But if you download it for the first time, you cannot verify that it is actually the thing
16:01
that you're supposed to download. So sum dot golang dot org is a database that contains all of the hashes of those packages that already exist. And you'll be able to verify that what you got is actually what other people have gotten in the past. You can also disable it if you want to. There's also, so has anyone used Go no proxy or Go no sum db?
16:22
Okay, so three, four people. Now they're documented, luckily, which is good, but still they're somehow hard to use, in my opinion. Go no proxy and Go no sum db basically say, do not use the Go proxy for this because you will not find it there. So just go directly and clone it from whatever,
16:40
HTTP or URL, whatever you got. Go sum db is kind of the same, but do not verify it and Go sum db, just trust it, right? If you wanna use that, which is very useful when you're downloading code from private repositories, for instance, you had to set both. Now you can just set one, which is go private. So you can say go private my own GitHub repo
17:01
or my own GitHub organization and it will just work. That's pretty nice. Also, there's go insecure. Do not use it unless you have to, but basically it stops from checking any certificates or HTTPS and it just downloads whatever. It is also great if you use it with Go no sum db, that way you don't verify anything too. That's great.
17:22
Okay, so for everybody here using Subversion, now you can use it with Go modules. Yay! Okay, godock-http. This is something that I'm slightly sad about. This is a joke about Midsummer, if anyone gets it. But go doc-http went away.
17:42
Dash-http would make go doc act as an HTTP server, so you could actually have the website locally and even better, you could see the documentation the way it's going to look on the website from your machine as you're typing, which was pretty cool. And I don't know how we're gonna replace that, but sad, but eventually I think
18:00
something will be replaced, hopefully, yes. Cool. It's one new thing which I didn't know was before, so. Thank you. So we got a new flag to the go build command. We now have go build dash stream pods. And what it does is if we're on a normal go build and we trigger stack trace, for example, with a panic, we still only get my home directory slash home
18:22
user go source, get a blah blah blah. When, why do you want that? And then when we do go build dash stream pods, that whole pods where I stole my go files is now replaced by the weirdly named command dash line dash arguments.
18:40
So why would we do this? First of all, if you build something on a CI, you can now trim out all your real CI stuff and just have one pod there. And also, reproducible builds are now possible. This helps making reproducible builds so we can now compare binaries built on two machines that they are similar or identical.
19:00
Back to you for the run time. Cool, thank you. So for run time, there's one little change that is not performance, the rest is just performance. So the little change, when you have an out of range, I was gonna say exception error, now it actually tells you more information. It tells you what was the length and what was the index that you tried to access.
19:21
This is super good for beginners. So thank you go team. This is actually very good. Before this, I would actually just like print the thing before it crashes, which is sad. So this is very good, small change, but good. Then for performance, defer got, like defer has been getting faster for quite a while. Like people still say, oh, do not use it.
19:40
It's not that fast. It got faster and faster and faster and now is for most cases as fast as calling a function, which is very fast. So if you wanna use it, you can literally use it anywhere. There's details on exactly what places it works and what places it really doesn't, but you can see that it went from 67 nanoseconds to seven nanoseconds. And seven nanoseconds is really fast,
20:01
so you can use it literally anywhere. JSON also got much faster. I run this on my machine, well, a cloud machine, 32 cores, and encoding in JSON got 9% faster and decoding got 38% faster. So all the things that you have, like serving REST APIs and stuff like that
20:22
will benefit a lot from this, which is really nice to see. There's a lot of changes, but one of the changes is here. By the way, at the end, we'll have a link to the slides so you can download them if you want to. What else? Bunch of things. So one of the things that we changed, because of SSA, we're able to verify whether check bounds are necessary more often or not.
20:42
So there's a bunch of them that have been removed so your code will be faster when you're using slices. Time.timer also got more efficient. And also when you're using mutexes, now when you unlock a mutex, and by unlocking it, you're releasing, you're making a Go routine be schedulable,
21:01
that routine will be scheduled directly, which means that on high contention, your program will run much faster. If you don't know what that means, it's fine. Things faster with concurrency. And ports, which I don't know anything. Thank you. In just in case you don't know, Go runs everywhere. Go runs everywhere, except NaCl.
21:23
So at one point in the team, we have support for Android 10 and Go, I'm not sure who uses that. In 1.13, Mac OS users now need 10 and 11 El Capitano later. 1.14 will also be the last version to support Darwin ARM 32-bit, 32-bit, be careful.
21:40
That's only used on iOS anyway. And on 1.14, we will now have a port for FreeBSD on ARM 64, which today we have a full talk about. And Go 1.14 might also support Dragonfly, Elunas, and Solaris, depending on whether a build server or the Google team does works or not. And Go 1.14 also drops support
22:00
for the native clients in favor of WebAssembly. And also, breaking news, TinyGo, not so tiny budgets. TinyGo is now officially sponsored by Google, and that's all we know for now. How many of you know about TinyGo? Whoa, look back. That was basically the whole room.
22:20
Yep, cool. On Windows, we also got some nice features. We finally got data execution prevention, which has been in Windows since Windows XP, but for some reason, Go never cared about it. So data execution prevention will mark specific regions in the memory as executable or non-executable, which is enforced by the CPU. And that's something you don't need to do anything about.
22:42
It's automated, automatic, so it just happens. And we also have improvement for Windows events. So when we listen for a syscall in our Go program, Go will actually translate Windows events to syscalls. So we have now three new events, control close, control log off, and control shut down,
23:00
and now translated to a sick term in Unix terms when you use a Go program. And now for the community. So the women who Go got seven more chapters than last year, which makes that we now have 37 women who Go and Go go with chapters in almost every part of the world.
23:21
For the Go Developer Network, for those who don't know it yet, it's a meetup network that's sponsored by Google of all Go meetups in the world. Now has over 10,000 members in 172 meetups, which hosted 4.6 thousand events. And to those events, 137 people RSVP'd yes.
23:42
And this is a map of all meetups in the world, Go meetups. Cool, so for conferences, there's a bunch of them. So the first one is this one, Faustin, hi. The next one is tomorrow. This is why we don't have Chris Nova here today because she's flying to Israel
24:01
to speak at that conference. Talking about conferences that are very close together. So between March 27th, 28th, 29th, and 30th, we have four different conferences in I think four different continents. Yay, which makes it fun. So if you like to travel, not fun, we have Capital Go Washington, DC,
24:20
Go For Go India in Goa, Go For Go Russia in Moscow, and Go For Go in Paris. And then we have also Go For Go Europe in Berlin, which is probably one of the ones that you can get closely here. Also, Go For Go is a very good conference, and it's not far, it's straight away. On top of that, I just wanted to show you this amazing drawing by Ashley McNamara,
24:41
and also the fact that we are all, well, I am going to Go For Go in Disney World Studios. So that's gonna be fun. So I think it's probably the best venue I could imagine for a conference. I think I might go to some talk. And also, finally, one thing, the slides are here. So if you wanna take a picture,
25:00
this is the picture you want to take. I'll give you five seconds for the picture. Okay, so this is the end of our talk. Thank you very much. And yeah.
25:20
And some more things. Today is actually the seventh year that we are here in a row. So I wanted to show you a little bit the evolution of the Go Dev Room at Fosden. This, back in 2014. I don't know if you can see there, well, this is a very tiny room to start with. It was on building K, and this day was incredibly hot inside and snowing outside.
25:42
It was great. Also there, that's the first co-organizer I used to co-organize this with Andrew Duran, and also Brad Fitch was giving a talk about a family store or something like that. Then in 2015, we got the same room. You may notice there's a gopher drawn there. There's actually two, we keep on doing that.
26:00
So in 2015, we got that room. We complained a little bit. In 2016, we got a bigger room. And that was great, but still completely crowded. In 2017, we got the same room, and we complained. So in 2018, we got the same room. And then we complained again, and we made a video, which I could not add in there, but we complained a lot, and we got this amazing dev room, which much, much bigger.
26:23
And this year, it's sad that all of you here got late, because this is the picture. Yeah, it's Sunday. So anyway, let's see what room we get next year. So more things about today. Thank you.
26:41
So we've just seen the state of Go, and there was this talk. Next up is Dylan. He's already standing there. So we have a day of amazing talks scheduled all day. We don't even take a break. And at the end of the day, at 4 p.m., we will have an hour of lightning talks. A lightning talk here is eight minutes, and you can still submit for a lightning talk.
27:03
You go to bit.ly slash go light 2020, and you can there still submit a lightning talk till 1430 Brussels time, eight minutes. It's in this room. It starts at four. If you take more than eight minutes, we'll throw things at you. Yes.
27:21
Thank you. Thank you.