Cameron Balahan
Diana Shevchenko
Robert Laszczak
Agniva De Sarker
Martin Gallauner
Travis Cline
Chioma Onyekpere
Raghav Roy
Cameron Balahan
Alice Merrick
Jonathan Amsterdam
Zvonimir Pavlinovic
Jonathan Amsterdam
Hila Fish
Felix Geisendörfer
Zvonimir Pavlinovic
Rabieh Fashwall
Jonathan Amsterdam
Millions of developers love Go for its features, performance, ecosystem, and community. But there’s another, perhaps more compelling reason as well: Go is good for business.
In this talk, we’ll review the business of Go, including the value it provides both Google and Go users alike. By digging into examples of what the Go team is working on now, we’ll show how our focus on productivity and production-readiness leads to happier developers and more successful businesses.
Cameron Balahan
Cameron is a Product Manager and the product lead for Go at Google. Before Go, Cameron led Google Cloud's programming languages support and integrations and, before Google, he led a high frequency market making firm where he built low latency trading systems in C and C++. He likes Go more.
In the fast-paced world of modern application development, optimizing resource utilization and responsiveness is crucial. Kubernetes Event-Driven Autoscaling (KEDA) offers a game-changing solution by seamlessly integrating event-driven architecture with Kubernetes. Join us in this informative talk, where we'll guide you through the process of getting started with KEDA. Discover how to harness its power to automatically scale your applications, making them more agile, cost-effective, and responsive. We'll explore the fundamentals of KEDA, its key features, and practical examples of its implementation. Whether you're a seasoned developer or just embarking on your Kubernetes journey, this beginner-friendly session will equip you with the knowledge and tools needed to supercharge your applications. Learn to leverage KEDA's capabilities and embrace the future of event-driven, auto-scaling architecture. Don't miss out on this opportunity to accelerate your applications and stay ahead in the ever-evolving tech landscape.
Gathering pieces of information for a task to deliver/modify a feature in your Go service, or dev project in any scale - is a wasteful act and could result in duplicated work done by different people. Onboarding, your ability to maintain your Go code or infrastructure and systems handover - Documentation plays a crucial part in all these processes. So... how can we write technical docs in an easy way & why should we even do it? In this talk, I'll show you a structured way to write technical docs, without being a technical writer - So you will deliver highly valuable information to your audience (your fellow gophers, users, or anyone else), to your best ability. I'll explain why you should care about these docs, how do they serve your best interests (Yes, there's more than one!) and what impact it could make on employees or even on your entire organization.
Hila Fish
Hila Fish is a DevOps Tech Lead, with over 15 years of experience in the tech industry. AWS Community Builder, Hashicorp Ambassador, and an International public speaker who believes the DevOps culture is what drives a company to perform at its best and talks about that and other DevOps/Infrastructure topics at conferences.
She carries the vision to enhance and drive business success by taking care of its infrastructure. In her spare time, Hila is a lead singer of a cover band, giving back to the community by co-organizing DevOps-related conferences (Inc. "DevOpsDays TLV" & "StatsCraft" monitoring-focused event), providing mentorship and managing programs in “Baot” (The largest technical women’s community in Israel), and enjoys sharing her passion and knowledge wherever she can, including across diverse technology communities, initiatives and social media.
Splitting problems into smaller ones can be a good strategy for tackling complex problems. But sometimes, instead of making project development faster, the opposite happens. Ultimately, developing the simplest feature requires the heroic work of 10 teams on a dozen microservices over half a year. Sounds familiar?
"Divide and rule" is not the only strategy that we can implement in complex projects. One of the most established approaches that can simplify implementing functionalities with complex domain logic is Domain-Driven Design (DDD).
I found DDD very useful in multiple projects with complex domains that I could work on. On the other side, I know that people believe in many myths about DDD used in Go. Most of them are sourced from using DDD in projects that don't require such a sophisticated approach or from projects implemented by people who didn't understand the principles of DDD.
During this talk, I will demystify DDD and give you a real-life example of where empowering DDD helped simplify them and increase development velocity.
If you don't work on a project with complex domain logic now, this presentation may still be helpful for you if you want to work on more challenging projects in the future. I will also give you some hints on which parts of DDD you should start from and what techniques work with DDD well.
Robert Laszczak
During the day, Robert is a Principal Software Engineer in SlashID, where he builds IDP solutions at a global scale. During the night, he's blogging at threedots.tech.
Author of Go With The Domain and Watermill.io. Robert's programming journey spans 16 years, during which he has navigated diverse domains, including infrastructure, global financial platforms, and security.
A couple of years ago, he finally found a language he loved: Go.
The database/sql package is the gateway to interact with a database. But do you know how it works internally? How does the connection pool work? How are the `maxOpenConns` and `maxIdleConns` limits respected?
In this talk, we will unpack all of that and more as we dive deep into the innards of the `database/sql` package. You will leave the room with a much better appreciation of all the things that happen behind the curtain the next time you write `db.Query`.
It will start off with the WHY. I will give a bit of context into the situation that forced me to build a custom connection proxy: https://github.com/mattermost/perseus.
The problem was that our software wasn't written with multi-tenancy in mind. So when we had to share multiple internal instances with the same DB instance, we faced a unique challenge. One can obviously use pgbouncer to share the connections between multiple processes. But then it wasn't possible to share the connection from multiple schema without some signalling mechanism.
So we were faced with 3 choices:
- Either rewrite Mattermost to be multi-tenant
- Modify pgbouncer
- Or build something of our own.
This talk will focus on the learnings that I ran into while taking the 3rd option.
We will then start with a very high level diagram of the flow of how a connection appears to be used from the outside. Then we will go one level deeper and give a brief overview of different components of the whole connection pool - the idle connection slice, the connection request queue, and the connection cleaner among other things. After this, we will explain each component in detail along with a little bit of code as well. We will wrap up the talk with the important takeaways. Eventually, we decided not to run this in production due to an inherent security vulnerability of the architecture, but this whole exercise gave us a much better understanding of the db stats panel used in our monitoring dashboard. And now our SRE team can easily detect and tune the connection pool settings just by looking at the metrics.
Go is popular for making concurrency easy through great language support for Goroutines and Channels, but getting it right is still up to you. In order to verify your design is truly correct, you need to look above the code and at the intent, but how does one do that? That’s where TLA+ comes in.
Raghav Roy
Raghav loves systems! But that's not all he thinks the niche he relates to, or he's most vocal about, is balancing closed source and open source work, and it's still something he's learning and getting better at every day.
He's a nerd for all kinds of white-papers that are all kinds of esoteric, even when it's not low-level systems, it could be astronomy, new coffee science, biology, and most recently psychology. He always has something to talk about (probably why he likes to give talks) and he always wants someone to talk to him about something they're weirdly nerdy about.
I want to talk about fallacies you might run into as someone who spent most of his developer career with Java and tries to apply the same train of thought to writing Go. Some of the topics I want to address are:
- Code organization and where are my classes?
- When ignoring pointers and always copying by value is maybe not the best idea
- What implicit interfaces want you to do
Martin Gallauner
I'm a developer with five years of experience, mainly within the Java ecosystem. Currently with Posedio, a Vienna-based company offering first-class consultancy services specialized in cloud native and DevOps. I pull from diverse experiences from my previous life as a hands-on electrician, from debugging pizza dough machines to installing flight simulators worldwide.
Astronomer is a platform that streamlines Apache Airflow's deployment, management, and scaling, a tool for orchestrating complex data workflows. In this talk, we'll delve into why the Astronomer team chose Go for their cloud-native development. We'll highlight Go's simplicity, performance, and scalability as key factors in this decision and discuss how it enhances the platform's functionality.
This session is designed for seasoned Go developers and those interested in its capabilities. We will explore best practices and provide practical insights for improving workflows, particularly those involving data processing with Go.
Chioma Onyekpere
Chioma is a Software Engineer with a dedicated work ethic and a digital nomad. She is proficient in the complete software development life cycle, including design, development, testing, and maintenance. Her programming style adheres to the DRY principle, and she utilizes agile methodologies to create software that is interactive, dependable, and scalable. She is adept at problem-solving and design thinking and is passionate about enhancing user experiences.
Chioma possesses expertise in web application development using a variety of technologies. She is interested in developing highly engaging and interactive software products based on user research and understanding. In addition to her technical skills, Chioma enjoys sharing knowledge with aspiring tech professionals by mentoring and writing articles.
Overall, the talk is about optimizing code in applications where every byte matters. I will start with a quick introduction to memory layout in Go with a small example in a few slides. This will be to revise how Go structures occupy memory, explaining concepts like padding and hardware sympathy, followed by an explanation of what simple structure layout manipulation can do to improve performance, how Go memory allocator uses different memory blocks (mspans) to store variables of different size. This will be accompanied by a simple real-life analogy to better understand the utility of optimisation for beginners.
Next, we will take a look at a real-life demo (pre-recorded to be safe). In the demo, we will run benchmarks on the code that uses identical structs with different layouts. The demo along with the explanation should take around 5 minutes. After that, we will take a look at the utility and use cases of such code optimisation—when it is needed and when it's best to avoid it. We will take a look at how the compiler can do a similar optimisation for us and why sometimes it doesn't.
This will lead us to the concept of mechanical sympathy, which will be briefly mentioned. And last but not least, we will review a use case from researching this optimisation on the scale of a Go observability library. With this example, we will see a 5–40% improvement in the memory usage of certain "heavy" structures that are created or stored millions of times per minute, and the subsequent performance wins.
Diana Shevchenko
Diana is a Software Engineer 2 at Datadog in the Application Performance Monitoring department. Passionate about computer science. Always eager to learn new things and share knowledge. She has been working with Go for the last few years.
Go's execution tracer (aka go tool trace) has suffered from high overhead since its inception in 2014. Historically this has forced potential users to worry about up to 20% of CPU overhead when turning it on. Due to this, it's mostly been used in test environments or tricky situations rather than gaining adoption as a continuous profiling signal in production. This talk will explain the contributions we made to the go1.21 release that reduced this overhead to less than 1% for most applications using frame pointer unwinding. It will discuss the technical challenges we faced, the collaboration with the Go runtime team at Google, and how Go users can benefit from this work and improve the performance of their own applications. Last but not least we'll discuss upcoming changes in go execution tracing and frame pointer unwinding in Go 1.22 and beyond.
Felix Geisendörfer
Felix is a Staff Engineer at Datadog where he works on Continuous Profiling for Go. Before that he was working on manufacturing systems for Apple, herding big PostgreSQL clusters. In his spare time he's usually working on open source, playing beach volleyball, or giving questionable advice (check out the GitHub link) on the internet.
Go 1.22 added two enhancements to the routing patterns for http.ServeMux: methods and path wildcards. I'll describe the new features, explain our search for a good rule for deciding which pattern wins in case of a conflict, and talk about how the changes affect performance.
Jonathan Amsterdam
Jonathan is a Software Engineer at the Go team.
In this talk, we'll discuss the recent results on analyzing publicly available Google Cloud containers for known Go vulnerabilities. We’ll discuss what kind of Go vulnerabilities are prevalent in the containers, how often they present themselves, and how we can guard against them.
Zvonimir Pavlinovic
Zvonimir is a Software Engineer at the Go team focusing on using static analysis techniques to tackle security related problems. Before that, Zvonimir was a computer science PhD student at New York University working on the intersection of formal methods and theory of programming languages.
Go sits in a special place in the history of computing, with lineage from Unix, Bell Labs, and Plan 9. As the practice of programming shifts and AI capabilities grow, the way we build systems is evolving. In this talk, we'll explore how Go can be leveraged today in building AI-enabled tools and discuss what the future might hold. We'll delve into how Go fits well within the AI/LLM ecosystem and chart out how we can expand its role.
We'll discuss the crucial role of open source in computing, particularly in the AI and LLM ecosystem, where open collaboration and transparency are keys to progress. I will showcase some AI powered tools built with Go and invite attendees to contribute to shaping the future of Go and AI/LLM programming.
Embark on a journey to enhance your Go programming prowess by unraveling common anti-patterns that can sneak into your codebase, hindering maintainability and efficiency. In this insightful talk, I will explore real-world scenarios, providing not just a diagnosis of these anti-patterns but, more crucially, prescribing practical solutions to elevate your Go coding practices.
Discover the pitfalls of global state misuse and how to structure state for better maintainability. Dive into the intricacies of error handling, learning how to gracefully manage errors and fortify the resilience of your code. Navigate the challenges of concurrent programming, unveiling the mysteries of race conditions and synchronization techniques to write efficient and robust concurrent code.
Cleanliness is paramount in code readability. Explore the importance of decluttering your codebase by eliminating unused imports and variables, fostering a collaborative and efficient development environment. Optimize your string handling code by steering clear of inefficient concatenation practices, and strike the right balance in using interfaces for code flexibility without unnecessary complexity.
Finally, demystify the nuances of dependency management, avoiding common mistakes that can compromise the stability of your projects. Learn version control best practices and ensure a secure and well-maintained codebase.
By the end of this talk, you'll not only be able to identify these anti-patterns but will also be armed with practical strategies to weave clean, maintainable, and efficient Go code. Join us for an exploration into the heart of Go anti-patterns and emerge a more adept Go developer.
Rabieh Fashwall
Rabieh, with over 13 years of experience in the computer software industry, is a seasoned Software Engineer adept at crafting Cloud Native applications and Web applications, primarily utilizing Golang, .Net, and React (TypeScript). Throughout his professional journey, he has honed his skills in diverse programming languages such as C#, Golang, and JavaScript. His expertise extends to leveraging various tools and technologies, and he has gained exposure to multiple cloud solutions, including AWS, GCP, and DO.
He thrives on challenges and actively seeks projects that push him beyond his comfort zone, allowing him to expand his knowledge and skill set. The continuous pursuit of learning new languages and development techniques is not only a personal passion but also a commitment to contributing to the success of the organizations he works with.
In the last three years, Rabieh transitioned into the role of a DevOps Engineer to deepen his understanding of the Kubernetes Administration ecosystem. This experience has provided him with valuable insights into the intricacies of managing Kubernetes, reinforcing his expertise in orchestrating containerized applications. Currently, he has returned to his role as a Senior Golang Engineer, combining his extensive software engineering background with newfound insights from the DevOps domain to deliver robust and scalable solutions
Cameron Balahan
Cameron is a Product Manager and the product lead for Go at Google. Before Go, Cameron led Google Cloud's programming languages support and integrations and, before Google, he led a high frequency market making firm where he built low latency trading systems in C and C++. He likes Go more.
Jonathan Amsterdam
Jonathan is a Software Engineer at the Go team.
Zvonimir Pavlinovic
Zvonimir is a Software Engineer at the Go team focusing on using static analysis techniques to tackle security related problems. Before that, Zvonimir was a computer science PhD student at New York University working on the intersection of formal methods and theory of programming languages.
You can book a spot at a walking tour at the Tickets section from the top navigation bar.
The TinyGo team will be hanging out at the venue during the day. Whether you booked a workshop ticket or not - with your conference pass you can join them for some hardware hacking. You can purchase a GopherBadge directly from the TinyGo team at the Tickets section from the top navigation bar, or bring your own hardware.
Jonathan Amsterdam
Jonathan is a Software Engineer at the Go team.