doc: add talks from robpike and rsc

README.md

@@ -208,6 +208,7 @@ Now, Russ is the tech leader of the Go team.
   + [talk/rob2020](https://evrone.com/rob-pike-interview) A Rob Pike Interview. (Date Unclear) Apr 30, 2020.
   + [talk/rob2021](https://www.youtube.com/watch?v=YXV7sa4oM4I) <details><summary>The Go Programming Language and Environment. John Lions Distinguished Lecture, UNSW, May 27, 2021.</summary>
     <p><b>Summary:</b> In this video episode titled "The Go Programming Language and Environment, " the last scheduled speaker was unable to attend due to illness. However, Rob Pike, a Google engineer and co-creator of the Go programming language, stepped in to speak. Pike expressed his gratitude for being able to attend virtually and shared his admiration for John Lyons, who had a significant influence on his career. He also mentioned how encounters with Lyons and an Australian named Ian Johnston led him to Bell Labs and eventually to Australia. Pike then delved into the success of the Go programming language. Initially disliked, Go has gained popularity in cloud computing due to its ability to address challenges faced by other languages. It offers scalability, security, performance, and automation. The language's success can be attributed to its reliable libraries, long-term stability, and better software writing capabilities. Go was designed with scalability in mind, focusing on concurrency and multi-core CPUs. One of the challenges in software development is the lack of multi-core languages and coordinating massive compute clusters. Building tools for languages like C++ and Java can be difficult due to their complexity and slow compilation. Pike discussed how Google's transition to a new build system reduced binary size by specifying dependencies more precisely. The video episode provides a comprehensive overview of Go programming, covering topics such as web server structure, interfaces, concurrency, and building a rate limiter. It explains how Go utilizes simple mechanisms like maps and arrays to compensate for the lack of parametric polymorphism, allowing for compatibility among different implementations. The significance of interfaces in Go is also highlighted, emphasizing their simplicity and flexibility. Pike further discussed how Go introduced goroutines for efficient parallelism and concurrency, and how channels and the select statement are used for communication and synchronization. The simplicity and safety of Go programming were emphasized, along with the importance of building libraries with built-in capacity. Go's safety features, including no pointer arithmetic and indexing checks, contribute to its reputation as a secure language. The video episode also touched on the evolution of Go's project structure, known as GOPATH, into the current module system, and its impact on program reasoning. Pike expressed his desire for additional language features like channel packages and multiplexers, as well as the difficulties faced in trying to make networking and channels work together. Overall, the episode highlighted the success and advantages of the Go programming language, including its compatibility, performance, and strong library support. Pike emphasized the importance of collaboration and code sharing in creating a thriving ecosystem in software development. The episode concluded with Pike expressing appreciation for a participant who couldn't attend and mentioning upcoming talks.</p></details>
+  + [talk/rob2023] What We Got Right, What We Got Wrong. GopherCon Australia 2023. Nov 10, 2023.
 - Robert Griesemer. (Dr. Robert Griesemer) [GitHub](https://github.com/griesemer), [Twitter](https://twitter.com/robertgriesemer?lang=en)
   + Alma mater: ETH Zürich
   + [paper/robert1993](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.127.5290&rep=rep1&type=pdf) A Programming Language for Vector Computers. Doctor Dissertation. 1993.
@@ -249,7 +250,7 @@ Now, Russ is the tech leader of the Go team.
     <p><b>Summary:</b>In this episode of "Pushing the Limits of Technology: The Ken Thompson and Dennis Ritchie Story, " we delve into the groundbreaking development and lasting impact of Unix, the revolutionary operating system created by Ken Thompson and Dennis Ritchie. Prior to Unix, computers were large and expensive, but this game-changing operating system allowed for multitasking and personal use, forever changing the landscape of technology. The episode begins by introducing Ken Thompson and Dennis Ritchie, two brilliant minds who worked together at Bell Labs. They were determined to create an alternative to the batch processing systems that dominated the computer industry at the time. Their collaboration resulted in the birth of Unix, a multi-tasking, multi-user operating system that would revolutionize the field. The host shares their personal experience with Unix, highlighting the significant role it played in their life. They recall the excitement of being able to play games on their computer, thanks to Unix's multitasking capabilities. This personal anecdote helps to illustrate the impact that Unix had on everyday users, as it allowed for personal use and entertainment on a scale that was previously unimaginable. The episode also sheds light on the remarkable abilities and dedication of Dennis Ritchie. His mathematical prowess and unwavering commitment to his work were instrumental in the development of Unix. Ritchie's contributions to the field of computer science cannot be overstated, and his partnership with Thompson was a key factor in the success of Unix. Throughout the episode, the close collaboration between Thompson and Ritchie is emphasized. Their shared vision and complementary skills allowed them to push the boundaries of technology and create an operating system that would shape the future of computing. Their work at Bell Labs paved the way for the modern technology we rely on today. Even though Unix was developed decades ago, its impact continues to be felt in our everyday lives. The episode concludes by highlighting the lasting legacy of Unix and its ongoing influence on technology. From the way we use computers to the development of subsequent operating systems, Unix's impact is undeniable. In summary, this episode of "Pushing the Limits of Technology: The Ken Thompson and Dennis Ritchie Story" explores the development and impact of Unix, a groundbreaking operating system created by Ken Thompson and Dennis Ritchie. Their collaboration at Bell Labs resulted in the creation of a multi-tasking, multi-user operating system that revolutionized the field of technology. Unix's lasting legacy continues to shape our everyday lives, making it a pivotal milestone in the history of computing.</p></details>
   + [talk/ken2019b](https://www.youtube.com/watch?v=EY6q5dv_B-o) <details><summary>Brian Kernighan interviews Ken Thompson. VCF East 2019. May 4, 2019.</summary>
     <p><b>Summary:</b>In this video episode titled "Ken Thompson interviewed by Brian Kernighan at VCF East 2019, " Ken Thompson, co-inventor of the UNIX operating system, is interviewed by Brian Kernighan. The episode, which took place on May 4, 2019, provides insights into Thompson's journey at Bell Labs and his contributions to the field of computer science. The fireside chat begins with an introduction and updates from the Vintage Computer Federation (VCF). Thompson then shares how he ended up at Bell Labs, where he worked alongside Dennis Ritchie to create UNIX. He reminisces about the origins of UNIX and reveals that they were only three weeks away from creating an operating system. Thompson discusses the challenges they faced while working on the PDP-11 computer and the importance of porting and testing assembly language for DC. He highlights the introduction of disk and communications equipment, which facilitated the rapid development of UNIX. One of the significant contributions of UNIX was the invention of pipes, allowing for communication between processes. The evolution of interprocess communication is also explored, from a worthless interface to a groundbreaking idea through the implementation of pipes. The development of redirecting IO and the creation of a shell are discussed, as well as the origin of the file search tool grep and its connection to AT&T's slogan. The video episode also delves into the evolution of programming languages, from early languages like B Unbond to the present work with Go. Thompson praises the TMG compiler on the PDB seven computer for its beautiful handwriting and lack of errors. The importance of Fortran in computer sales is mentioned, along with the author's personal experience with writing Fortran code. Additionally, the episode touches on Thompson's journey with chess, from becoming hooked on the game to developing a chess machine. The author shares their passion for watching chess tournaments online and participating in a chess tournament with a C program they had created. They then describe the process of building a chess machine and the machine's success as the world and US champion. Overall, this video episode provides a comprehensive overview of Ken Thompson's contributions to the field of computer science, including his work on UNIX, programming languages, and chess. The interview with Brian Kernighan offers valuable insights into Thompson's journey and the development of groundbreaking technologies.</p></details>
-    
+
 - Ian Taylor. (Ian Lance Taylor, B. Sc.) [Website](https://www.airs.com/ian/), [GitHub](https://github.com/ianlancetaylor), [Quora](https://www.quora.com/profile/Ian-Lance-Taylor)
   + Alma mater: Yale University
   + [talk/ian2007](https://www.youtube.com/watch?v=gc78olyguqA) <details><summary>GCC: Current Topics and Future Directions. February 27, 2007.</summary>
@@ -265,7 +266,7 @@ Now, Russ is the tech leader of the Go team.
     <p><b>Summary:</b>In the video episode titled "Go Day 2021 on Google Open Source Live | Using Generics in Go, " Ian Lance Taylor introduces the concept of generics in Go programming and discusses how to effectively use this new language feature. He begins by explaining the basics of generics, including type parameters and constraints. Taylor emphasizes the importance of writing code before defining types and provides guidelines for when to use generics and when not to use them. He highlights that generics should be used for code clarity rather than efficiency. He also mentions that type parameters can be used to create more general data structures and enable more efficient storage of data. The speaker provides examples of using generics to create functions and implement common methods for different types. He explains that type parameters are particularly useful when implementing methods that are the same for all relevant types, but not when interface types can provide the desired functionality. Taylor concludes the episode by mentioning that Go 1. 18 is expected to include support for generics, which will bring new possibilities for developers. He mentions the possibility of a generic function for sorting slices in future versions of Go. Overall, the video episode provides a comprehensive overview of generics in Go programming. It highlights the benefits of using type parameters and provides practical examples of their implementation. The speaker emphasizes the importance of using generics for code clarity and avoiding repetitive code. The episode concludes by mentioning the upcoming support for generics in Go 1. 18, which will undoubtedly enhance the programming experience for Go developers. For more information on Go programming and to stay updated on the latest developments, the video recommends visiting the team's website at golang. org. Additionally, the episode encourages listeners to check out all the Gaming Day sessions available on the Go Day 2021 event page.</p></details>
   + [talk/ian2021b](https://www.youtube.com/watch?v=Pa_e9EeCdy8) <details><summary>Generics! Dec 17, 2021.</summary>
     <p><b>Summary:</b>In the GopherCon 2021 video episode titled "Generics!", Go Team members Robert Griesemer and Ian Lance Taylor discuss the upcoming release of Go 1. 18 and its support for generic functions and types. They highlight the expressive power that generics bring to the Go programming language and the responsibilities that come with using them effectively. The new features in Go 1. 18 include type parameters, more powerful interface types, and improved type inference. These features eliminate the need for type arguments, making programming with generics in Go more efficient. The update also introduces type constraints, which define valid types for a parameter, and interfaces that define sets of methods. Griesemer and Taylor provide guidance on when and where to use generic features in Go. They suggest starting with functions instead of type parameters and using type parameters for functions that operate on special types without assumptions about element types. They emphasize the flexibility and efficiency of type parameters compared to reflection or interface types, allowing for general-purpose data structures and fully type-checked code. The speakers also discuss the importance of understanding meta types and the use of interfaces as constraints in generic functions. They mention the introduction of syntactic sugar and the use of type parameters with slice types. They also touch upon type inference and its role in deducing type arguments from type parameter constraints. Griesemer and Taylor highlight the need to keep Go code readable, maintainable, and performing well when using generics. They advise using type parameters when multiple types share a common method with the same implementation and using interface types for generic programming and reading data from any value. They mention that reflection can be used in cases where type parameters are not helpful. Overall, the upcoming release of Go 1. 18 with support for generics brings significant expressive power to the language. Griesemer and Taylor provide valuable guidance on how to use generics effectively, emphasizing the importance of choosing the appropriate approach based on the specific requirements of the code. By following their advice, developers can leverage the benefits of generics while maintaining code readability, maintainability, and performance.</p></details>
-  
+
 - Russ Cox. (Dr. Russell Stensby Cox) [Website](https://swtch.com/~rsc/), [Blog](https://research.swtch.com/), [GitHub](https://github.com/rsc), [Twitter](https://twitter.com/_rsc), [Reddit](https://old.reddit.com/user/rsc), [YouTube](https://www.youtube.com/channel/UC3P6PrEBAVH1UaiPOzZ-u-w)
   + Alma mater: MIT
   + [paper/russ2008](https://pdos.csail.mit.edu/~rsc/) An Extension-Oriented Compiler. Doctor Dissertation. Aug 20, 2008.
@@ -296,6 +297,8 @@ Now, Russ is the tech leader of the Go team.
   + [talk/russ2021](https://archive.org/details/PLTalk/%23PLTalk+-+12+Years+of+Go+with+Russ+Cox+%5Bv1203523364%5D.mp4) #PLTalk: 12 Years of Go with Russ Cox. Nov. 12, 2021.
   + [talk/russ2022](https://youtube.com/watch?v=v24wrd3RwGo) <details><summary>Compatibility: How Go Programs Keep Working. GopherCon 2022. Oct 28, 2022.</summary>
     <p><b>Summary:</b>In the video episode titled "GopherCon 2022: Russ Cox - Compatibility: How Go Programs Keep Working, " Russ Cox discusses the significance of compatibility in Go programming and the strategies employed by the Go team to ensure stability and predictability in new releases. Cox begins by explaining the Go1 compatibility promise, which guarantees that new APIs can be added without breaking existing code. He emphasizes the importance of maintaining API compatibility and discusses the tools and testing approaches used to check for compatibility issues. The episode highlights two subtle problems encountered during the preparation of the Go 1.1 release, shedding light on the challenges of maintaining compatibility, including output changes, input changes, and protocol changes. Cox also delves into the changes and compatibility in Go 1. 6, including the ability to opt out of changes and the removal of support for sha-1 certificates. The discussion further explores backward, forward, and language compatibility, as well as the challenges associated with output and input changes. Examples are provided to illustrate output change incompatibilities and the issues caused by input changes. Cox emphasizes the importance of writing code and tests that can accept any valid behavior. He also discusses input change incompatibilities and protocol changes, using examples of code breaking due to data format and communication issues between HTTP versions. The episode also touches on the Goatee bug settings and compatibility in Go programming, highlighting the guarantee that compatible changes that break existing programs will last for at least two years. The Go command is considering improvements to handle version mismatches more effectively. Lastly, the episode discusses how Go modules can be utilized to remove or fix problematic features in the Go language. A bug in the code is identified, and potential fixes are suggested. Overall, the episode emphasizes the importance of prioritizing compatibility in the development of Go 1. x and maintaining stability and predictability for developers.</p></details>
+  + [talk/russ2023a](https://www.youtube.com/watch?v=BNmxtp26I5s) Go Changes. GopherCon 2023. Sep 27, 2023.
+  + [talk/russ2023b](https://www.youtube.com/watch?v=X4rxi9jStLo) Go Testing By Example. GopherCon Australia 2023. Nov 9, 2023.
 
 [Back To Top](#top)