1. RAG Pipelines - Go's AI Superpower

Abstract

Description

Unleash Go’s hidden potential in the AI revolution! While Go isn’t traditionally known for AI applications, it’s a powerhouse waiting to be tapped for building dynamic Retrieval-Augmented Generation (RAG) pipelines. Join us on an exciting journey to discover how Go can supercharge your AI projects and ignite the creation of the next generation of AI tools.

In this talk, we’ll start by briefly demystifying key concepts like RAG, GenAI, and AI Agents, setting the stage for the possibilities ahead. We’ll then tackle the big question: Why does Go seem to “suck” at AI? We’ll delve into the misconceptions and limitations, and reveal how Go’s unique strengths compensate in unexpected ways.

But here’s where it gets exciting - we’ll unveil what a RAG pipeline looks like and how you can build one using Go. With its robust standard library and features like goroutines, Go excels at moving data efficiently between different models and services, making it ideal for constructing efficient AI pipelines.

Finally, we’ll explore the path forward: How can you build innovative products around these pipelines? We’ll discuss strategies for leveraging Go to create scalable, high-performance AI applications that stand out in the market.

Whether you’re an AI enthusiast looking to explore new horizons or a Go developer eager to dive into the world of AI, this talk will equip you with the insights and inspiration to harness Go’s hidden superpowers. Let’s embark on this adventure together and transform the way we build intelligent applications!

^ back to index

2. Go: Expect the Unexpected

Abstract

Description

“Unexpected Go” is a deep dive into the subtle, often counterintuitive behaviors of the Go programming language. This talk explores edge cases and lesser-known intricacies that can catch even experienced developers off guard.

We’ll dissect a range of unexpected behaviors, including:

• The peculiarities of nil error handling and type assertions

• Surprising outcomes in time formatting and parsing

• Quirks in I/O operations and their implications for testing

• The nuanced behavior of panic and recover

• Unexpected merging in JSON unmarshaling

• Concurrency gotchas in testing and benchmarking

• The intricacies of map operations, including NaN key handling

• Limitations and surprises in Go’s implementation of generics

Each topic will be examined through code examples, highlighting potential pitfalls and offering insights into Go’s internal workings. We’ll explore why these behaviors exist, their impact on day-to-day programming, and strategies to work with (or around) them effectively.

This talk is designed for Go developers looking to deepen their understanding of the language’s internals. By shedding light on these corner cases, attendees will gain valuable insights that will enhance their ability to write more robust, efficient, and idiomatic Go code. Whether you’re debugging complex issues or architecting large-scale systems, understanding these unexpected behaviors is crucial for mastering Go.

^ back to index

3. Gophers in the Amazon: tales from the burrows

Abstract

Description

Did you know that there are Gophers in the Amazon?

No, I’m not referring to the taltuza, the giant pocket gopher of Colombia, or the tuco-tucos of Bolivia, or even the kind that dance on golf courses in cheesy 1980s films. I’m talking about the Go gopher, of course, and how it lives within Amazon Web Services (AWS).

After 2 years burrowed deep in the Amazon (aka working for an RF-engineering startup), I’ve emerged to tell the story of what I’ve learned using Go on AWS to create a scalable application platform. It doesn’t take much for a Go application to adapt to the Amazonian Lambda environment, but to thrive in such an environment is not always made easy.

In this talk, we’ll discuss my experiences, mistakes, and things I wish I’d known sooner about this particular, peculiar mix of technologies. We’ll cover the following:

• Writing and deploying Go for AWS Lambda;
• Common patterns like shared modules, error handling, performance, using external files, and testing;
• Sharp edges and things that bite;
• What to expect when (not if) things Go wrong!

This talk will take a Dramatic Look at common gotchas, available tooling, and environments like the soon-to-be-extinct go1.x AWS Lambda runtime to the ever-evolving provided.al2023 runtime. Come for a rapid-fire look at Go on AWS based on my learning-as-you-go experience, stay for the pictures of cute gophers, and leave with a new-found appreciation of this unique ecosystem.

^ back to index

4. Monads for Go?

Abstract

Description

Few terms bloom so much hope in the hearts of functional programmers and spike so much fear into the hearts of others, as the word “Monad”.

When Go added generics in 1.18, the term was thrown around a fair bit and ever since then, a new package “implementing Monads for Go” pops up every few months.

The goal of my talk is to demystify the word, talk about what Monads are used for in functional programming languages and what it could mean to “add them to Go”. Would that be useful? Can it even be done? And, as it turns out, if we focus on their core ideas and squint, we had something like them for a long time.

^ back to index

5. Kubernetes Operators with Go

Abstract

Description

Kubernetes’s untapped potential are Custom Operators. The ability to control and operate any type of resources such as databases, networking routes, authentication, authorisation, etc is key for growing companies to the take automation of their platform to the next level.

Topics to cover:

• What is Kubernetes?

• What are Kubernetes Operators?

• What are CRDs?

• The reconcile loop

• Resource lifecycle (Kubernetes events)

• Kubebuilder (Framework for building Operators with Go)

• Real-life examples of orchestrating resources with Operators

^ back to index

6. Go Plug and Play: Runtime Extensibility with Plugins

Abstract

Description

When Go introduced plugins in 1.8, it opened up a powerful way to extend applications dynamically, but many developers haven’t fully explored this feature. In this session, we’ll dive into how Go plugins work, starting with the basics of dynamic loading and extending applications at runtime. We’ll discuss where plugins fit in the Go ecosystem, practical use cases, and some of the challenges and gotchas that come with using them. Whether you’re maintaining a large-scale service or building smaller, modular apps, this talk will offer practical insights and real-world examples on using plugins effectively to keep your codebase clean, scalable, and adaptable.

Key takeaways from this talk will include:

• Inner workings of Go plugins and problems they solve

• Best practices for designing and implementing plugins in your projects.

• Common pitfalls to avoid when working with plugins.

• Live coding demonstrations showcasing practical use cases and performance considerations.

• Strategies for creating flexible, scalable applications without sacrificing performance or reliability

^ back to index

7. Bugs Lightyear Away With Fuzz

Abstract

Description

In the process of building software, we write test cases to ensure different features within a system perform as expected. We try to cover most edge cases, but we’re only human – we might miss a few. These oversights can lead to security vulnerabilities, a programmer’s nightmare.

Traditional testing methods like unit tests often fail to simulate real-world scenarios and unexpected inputs, leaving potential security risks undiscovered. These hidden vulnerabilities are one of the root causes of cybersecurity threats.

Fuzz testing solves this critical problem of uncovering unknown bugs and flaws in software applications.

Fuzzing is a process of finding defects & vulnerabilities in which system under subject is repeatedly injected with invalid, malformed and unexpected inputs. It can reach edge cases which humans often miss.

For example, in Go, a simple fuzz test for a string parsing function might look like this:

func FuzzParse(f *testing.F) {

f.Fuzz(func(t *testing.T, input string) {

Parse(input) // Your function to test

})

}

This test will generate thousands of random string inputs, potentially uncovering edge cases you never considered.

By identifying and addressing these issues early on, fuzz testing helps improve the overall security, stability, and reliability of software systems, mitigating the risk of costly breaches and system failures.

As of August 2023, OSS-Fuzz has helped identify and fix over 10,000 vulnerabilities and 36,000 bugs across 1,000 projects.

With the release of v1.18, Go has finally added Fuzzing or fuzz testing as a part of its standard toolchain. And what is great about this feature is that you don’t need to be a security expert to write the fuzz tests.

Think of fuzzing as the ultimate form of unit testing.

Join me to explore how fuzz testing can revolutionize your approach to software quality and security in the Go ecosystem.

^ back to index

8. Wasm on Edge Serverless; Make Your Life Easier With Go and TinyGo

Abstract

Description

Thanks to the support for WASI introduced in Go 1.21 last year, developers now have more options beyond TinyGo for WebAssembly projects in Go. This has significantly improved convenience and productivity, positioning Go as a strong choice not only for Wasm but also for development in WASI environments.

This talk will briefly review Wasm and Wasi concepts, then focus on Go and TinyGo development in CDN Edge Serverless as an example of a Wasi environment. We’ll discuss Edge Serverless benefits, strategies for effectively choosing between Go and TinyGo, and practical tips for Go WebAssembly development, exploring how to improve server-side development efficiency and productivity using WebAssembly.

^ back to index

9. Productive Play: Using Go's Testing Tools for Dependency Evaluation

Abstract

Description

Your professional responsibilities probably do not include play as a core

responsibility of your role. Your workplace may not provide time to try out new

technologies or build small experimental applications. However, play can be an

integral part of the research process when considering new packages, frameworks,

and other application dependencies. Not only is play fun, but it also builds

understanding, evaluates key characteristics, and produces valuable artifacts

that can later be used in production.

In this talk, we’ll explore why you should be playing at work and how Go helps

you accomplish this productively. You’ll see how Go’s built-in test tooling can

become a powerful playground for evaluating new Go packages before they ever

reach production.

I’ll demonstrate a fresh perspective on Go’s built-in tools — such as Example

tests, Benchmark tests, and profiling with pprof — to assess packages from

multiple angles. This approach allows developers to not only verify

functionality but also to explore performance, API design, and

storage/serialization needs in a controlled environment. Throughout the talk,

I’ll share real-world examples, including how I used this method to evaluate

arbitrary precision decimal packages for my team.

Beginner and intermediate developers will walk away with a newfound appreciation

for the tools Go provides to “play” with new dependencies, while intermediate

and advanced Gophers will gain insights into how this process can lead to

better, more informed decision-making in choosing libraries, and also how this

playground can transition directly into production code. This talk will give you

the tools and mindset to approach new technologies with confidence, playfulness,

and precision.

^ back to index

10. Leveraging Go for Retail Transformation: Enhancing Customer Experience and Operational Efficiency with Advanced Forecasting Models

Abstract

Description

As the retail landscape rapidly evolves, leveraging the power of Go for advanced forecasting models is becoming a cornerstone of operational efficiency and customer experience improvements. This presentation highlights how Go-based machine learning and predictive analytics models are transforming retail operations at leading companies such as Amazon, Walmart, Zara, and Kroger. For instance, Amazon’s personalized recommendation engine—powered by Go—contributes to 35% of its revenue, while Kroger has reduced checkout wait times to under 30 seconds through predictive customer traffic analysis.

Key areas of focus include demand forecasting, which reduces stockouts by up to 20% and minimizes excess inventory by 25%, offering retailers significant cost savings. These predictive models also enhance personalized customer experiences, boosting sales conversions by 30%. With trend analysis, retailers like Zara can adapt quickly to market shifts, ensuring a competitive edge in fast fashion production cycles.

In addition, the talk will cover emerging trends in Go-powered retail forecasting, including real-time inventory optimization through Internet of Things (IoT) integration and leveraging external data sources such as social media and weather patterns to improve accuracy. Attendees will learn how Go’s unique features enable balancing automation with human oversight and explore the ethical considerations, including privacy and fairness in AI-driven decision-making. This session provides a comprehensive view of how Go can empower retailers to remain competitive in today’s fast-paced market.

^ back to index

11. The Why of the iterator design

Abstract

With Go 1.23 Go got user-defined iterators integrating with range. The final design has sparked a lot of discussions: Why does it use functions, not interfaces? Why this particular signature?

I you through the history of this design, as a case-study of how Go language features are discussed.

Description

The discussion about custom iteration started already back when generics where released in Go 1.18. It was clear, at the time, that if we wanted to support user-defined container types, we need a good answer for how they should get iterated over. Since then, we have gone through several different designs, all of which where rejected, until we finally converged on the now released design towards the end of 2023.

Many people who saw this new feature for the first time nearing the release of Go 1.23 reacted to it with doubt. The implementation looks complex, the syntax hard to read. Many alternatives are being proposed on Reddit, Twitter or Slack. But many of these alternatives have already been discussed.

I want to talk about these alternatives. I don’t want to tell you how iterators work in Go 1.23 - but why they look like they do. I want to explain what we wanted from them and go through the various designs that came before and summarize, why they were ultimately rejected. And hopefully give you some insight into how new features like this are designed and discussed with the community.

^ back to index

12. Revolutionizing Healthcare IT: How Emerging Technologies are Shaping the Future

Abstract

Description

The healthcare industry is undergoing a profound transformation driven by cutting-edge technologies like artificial intelligence (AI), machine learning (ML), and advanced data analytics. This session at GopherConAU 2024 will explore how these innovations are reshaping patient care, operational efficiency, and healthcare IT infrastructure.

AI’s impact is immense, with the market projected to grow at a 41.8% CAGR, reaching USD 45.2 billion by 2028. AI-powered diagnostic tools are revolutionizing early detection, outperforming human accuracy, such as systems identifying diseases like cancer with a 94.3% success rate. The exponential growth of healthcare data—at 48% annually—drives the need for advanced analytics to improve predictive models. For instance, AI-driven solutions can predict acute kidney injury with a 92% accuracy rate, enabling timely, life-saving interventions.

This presentation will also address the integration of legacy systems with emerging technologies like cloud-based solutions, which are anticipated to propel the healthcare cloud market to USD 64.7 billion by 2025. Interoperability, data governance, and blockchain will be key to managing secure and seamless data exchange across organizations. Attendees will gain insights into how healthcare organizations can harness these technologies to optimize patient care, streamline operations, and future-proof their IT strategies in a rapidly evolving digital landscape.

This talk will provide a roadmap for navigating the challenges posed by cybersecurity risks, workforce upskilling, and balancing legacy systems with future advancements, offering actionable strategies for driving digital innovation in healthcare.

^ back to index

13. The important role GoLang takes at the core of Pies Studio.

Abstract

Description

At PIES, Golang is the backbone of our platform, driving innovations through functionalities like real-time operations, efficient file management, and seamless user experiences. Our backend servers, written in Golang, power everything from editor licensing to billing systems, ensuring scalability and high performance. We leverage Golang’s concurrency model and templating engine to transform user-created designs into production-ready applications quickly, while also offering users the ability to extend their apps with custom Golang plugins. Golang’s speed, simplicity, and scalability make it the perfect fit for our platform’s needs, allowing us to deliver reliable, high-performance services across multiple infrastructures.

How we use Golang in PIES Studio

At PIES Studio, Golang serves as the backbone of our platform, powering various core functionalities. Here’s how we leverage Golang throughout the ecosystem -

• Backend Servers

We use Golang as the primary language for all backend servers that manage PIES Studio’s editor, licensing, and billing systems.

Its performance, concurrency model, and scalability align well with our need for real-time operations and reliable server management.

Key Features Used

1. HTTP and WebSockets

We use Golang’s http package for serving web requests and websocket libraries for enabling real-time communication between the client and servers.

2. File I/O

Golang’s File I/O capabilities are utilized for handling user-generated code, processing files, and managing deployment data efficiently.

3. Concurrency Support

We leverage Golang’s native support for concurrency through goroutines and channels, ensuring that our backend can handle multiple simultaneous user requests in a scalable and efficient manner.

• Code-Generation & Deployment Engine

Our code-generation engine, responsible for transforming user-developed applications into fully functional code, is written using Golang. Its efficiency allows us to convert high-level visual application designs into robust backend logic swiftly.

We also have a deployment engine which seamlessly deploys your applications to our cloud infrastructure, which is built using Golang.

Key Features Used

1. Golang Templating Engine

The code-generation engine, responsible for converting application designs into functional code, relies on Golang’s templating engine to generate complex codebases dynamically.

2. Concurrency Support

Golang’s native support for concurrency comes in handy through goroutines and channels, ensuring that the engine can handle multiple simultaneous code generation requests in an efficient manner.

• Generated Application Backend

Every application developed through PIES Studio includes a Golang-based backend, providing users with a solid, production-ready server to manage their app’s functionality.

• Plugin System

PIES Studio offers a plugin feature where users can extend their applications with custom backend code.

Currently, we support Golang plugins, enabling users to write and integrate their own Golang code into their applications.

Why Golang?

• Built-in Concurrency

Golang has native support for concurrent programming with goroutines, which allows us to build highly efficient and scalable systems.

This makes it possible to handle multiple requests, processes, and operations in parallel without performance bottlenecks.

• Simplicity and Clean Syntax

Golang’s minimalist design allows for simple and readable code, reducing development time and complexity. This simplicity translates into fewer bugs and easier maintainability.

• Strong Ecosystem and Standard Library

Golang comes with a rich standard library that includes everything from networking, file handling, and JSON manipulation to cryptography and concurrency tools, making it ideal for building large-scale systems like PIES Studio.

• Efficiency and Performance

As a compiled language, Golang offers excellent runtime performance, which is critical for large platforms that require real-time processing. Its efficiency makes it ideal for both small and large-scale applications.

• Cross-Platform Support

Golang is cross-platform, allowing us to deploy PIES Studio on different operating systems and cloud environments with ease, ensuring platform compatibility across various infrastructure setups.

• Scalability and Reliability

With Golang’s focus on performance and concurrency, it is perfect for scaling backend systems.

It can handle a high number of simultaneous connections, making it ideal for a platform like PIES Studio, which needs to support multiple users and deployments at once.

• Fast Compilation

Golang compiles code quickly into efficient binaries, helping us speed up development, deployment, and debugging cycles, which is crucial in a dynamic platform like PIES Studio.

These technical capabilities of Golang are what make it the backbone of PIES Studio’s architecture, offering robustness, speed, and flexibility.

^ back to index

14. The Quickest but Heaviest Cloud Migration journey with GO

Abstract

Description

With our toes in the cloud native ecosystem, we often handle various kinds of migrations. But what if you have to migrate over 1PB data from one cloud to another within 1-day timeframe( that too including the precious nap & munching hours)? Snowball will take over a week to arrive, Data Transfer services would need at least 3 days for a 90% Transfer, what should we do( please guess GO in your mind ) is Go the answer?

Join the Session as Prerit takes us on a safari where they managed to migrate this much data within 12 hours(so that they can sleep well) with 0 downtime and 100% accuracy. We will look at how they migrated 120+ internal applications using their custom go controllers & their ETL/ELT pipelines. Furthermore, we will look at a live demo on how can you migrate 100Gigs of data within minutes using Go(because you are GopherCon AU) and explore the power of goroutines.

^ back to index

15. Revolutionizing User Interaction with Adaptive User Interfaces: A Go-Powered Approach to Dynamic, Data-Driven Experiences

Abstract

Description

Adaptive User Interfaces (AUIs) are transforming human-computer interaction by leveraging real-time data, user behavior, and contextual information to create personalized and responsive user experiences. This talk explores the potential of AUIs, specifically focusing on how Go’s robust, concurrent processing capabilities play a crucial role in AUI development across industries. In healthcare, AUIs integrated into Electronic Health Record (EHR) systems have reduced cognitive load by 40% and improved task completion time by 35%, driving efficiency and user satisfaction. The education sector has seen a 15% improvement in test scores and a 22% increase in course completion rates through adaptive learning platforms that personalize content delivery. E-commerce platforms utilizing AUIs have reported a 35% increase in click-through rates and a 28% boost in conversion rates by dynamically adjusting product recommendations.

This session will examine the core techniques powering AUIs, such as machine learning algorithms, context awareness, and personalization, all enhanced by Go’s ability to handle large-scale data processing and feedback loops. Key challenges like data privacy, development complexity, and user control will also be addressed, providing developers with practical insights on integrating AUIs into their Go-based systems. Attendees will gain an understanding of how AUIs are reshaping digital experiences and the role Go plays in delivering scalable, responsive user interfaces across diverse domains.

^ back to index

16. Think Pragmatically: Elevating Your Go Development Skills

Abstract

Description

Have you wondered why some Go projects feel like a breeze to work on, while others turn into a never-ending nightmare? The answer lies in the principles of pragmatic programming – a mindset that can revolutionise the way you approach software development.

Outline

1. Introduction [3 min]

• What is pragmatic programming and its relevance to Go development

2. Key Principles of Pragmatic Programming in Go [8 min]

• Care About Your Craft: Importance of writing clean, maintainable code

• Think! About Your Work: Encouraging critical evaluation of solutions

• You Have Agency: Empowering developers to take ownership of their code

3. Tools and Techniques for Pragmatic Go Development [8 min]

• Effective Go: Best practices for writing idiomatic Go code

• Error Handling: Go’s approach to error handling

• Testing in Go: Importance of writing tests alongside code

4. Pragmatic Programming with Generative AI (Live Demo) [8 min]

“AI is not a replacement for human intelligence; it’s a tool that enhances our capabilities.” - Unknown

• How generative AI tools (e.g., GitHub Copilot, ChatGPT) can assist in writing Go code

• Potential pitfalls and ethical considerations when using AI in development

5. Code as a Living Entity (with examples) [4 min]

• Refactoring: When and how to refactor Go code

• Go Modules: Benefits of using Go modules for dependency management

6. Collaboration and Team Dynamics [4 min]

• Organize Around Functionality: Importance of cross-functional teams

• Code Reviews: The role of code reviews in maintaining quality

“Code reviews are not about finding bugs, they’re about learning from each other.” - Trisha Gee

7. Pragmatic Testing Strategies in Go (with live demo) [4 min]

• Unit Testing and Benchmarking: Implementing effective unit tests

8. Conclusion [2 min]

• Benefits of adopting a pragmatic approach to Go programming

“Pragmatism is not about theory, it’s about making things work.” - Dave Thomas

^ back to index

17. Automatic efficient Go application by Profile-guided optimization

Abstract

Description

Our team manages plenty of Kubernetes clusters in private cloud for services of our company and develop many custom controller to work efficiently and to reduce the management costs for each service. So it’s so important for scaling up, growing business to reduce little bit of a CPU utilization.

PGO is a feature that we can use since Go1.20. this feature provides the compiler more meaningful profiles to determine aggressive optimization like inlining and de-virtualization. To make the result of optimization best, PGO requires the profiles that are representative of actual behavior in production environment. Of course, we can pass to PGO the representative benchmark results, but it’s so difficult and, in many cases, it’s not useful to optimize compiler. So Go’s PGO recommends to collect the profiles directly from the production environment.

The official post introduces typical workflow like following.

1. Build and release an initial binary (without PGO).

2. Collect profiles from production.

3. When it’s time to release an updated binary, build from the latest source and provide the production profile.

4. GOTO 2

This workflow is just typical and, in actual, it’s more complicated to apply for PGO to your application.

So, at first I introduce an outline about PGO. Then, I’ll share practical example for our team. In this section, I introduce the workflow to apply for PGO to your application in Kubernetes.

Abstract

• Why do we need PGO (5min)

• Self introduction

• The detail of my company

• The basic information about PGO (10min)

• What is PGO and how does PGO work

• The benefit to enable PGO

• Practical example of my company (15min)

• How to introduce PGO to your application

• The result before and after introduction

• Conclusion

^ back to index

18. Automating CI/CD Workflows with AWS and GitHub Actions: Strategies for Efficient and Secure Software Deployment

Abstract

Description

Go’s simplicity and performance make it an excellent choice for cloud-native applications, but deploying these applications can still be complex. This talk will guide you through creating an efficient, automated CI/CD pipeline tailored for Go projects.

We’ll cover:

Setting up GitHub Actions for Go-specific testing and building

Leveraging Go modules for dependency management in CI/CD

Optimizing Docker builds for Go applications

Utilizing AWS services like ECR and AppRunner for Go deployment

Implementing Go-friendly security checks in the pipeline

The presentation will include a live demo of deploying a Go microservice, showcasing how to handle common Go-specific challenges in CI/CD pipelines.

Attendees will learn:

Best practices for automating Go builds and tests in CI/CD

Techniques for optimizing Go application deployments on AWS

Strategies for maintaining code quality in fast-paced Go development

How to leverage Go’s strengths in creating efficient deployment pipelines

This talk is ideal for Go developers looking to streamline their deployment processes and embrace modern DevOps practices. Whether you’re new to CI/CD or looking to optimize your existing pipeline, you’ll come away with practical, Go-specific strategies to implement immediately.

^ back to index

19. Mastering Error Handling in Go: Best Practices and Pitfalls

Abstract

Description

Talk Description:

Introduction:

Error handling in Go is a topic that often sparks debate, especially among developers coming from languages with different paradigms. Go’s unique approach to errors—as values—demands a shift in mindset and coding practices. This talk aims to provide a deep dive into Go’s error handling philosophy, practical strategies for handling errors effectively, and common pitfalls to avoid.

Outline:

1. Why Error Handling Matters in Go:

• The inevitability of errors in programming and the importance of handling them correctly.

• Comparison with error handling in other languages (e.g., Java, Python) and why Go’s approach is unique.

• The philosophy behind Go’s error handling: defensive programming and the principle of explicit error checking.

2. Understanding Go’s Error Handling:

• How Go treats errors as first-class citizens: the error type.

• Common patterns: if err != nil and why this pattern is both powerful and necessary.

• The benefits of checking errors immediately where they occur, promoting clear and readable code.

3. When and How to Use Panic and Recover:

• The appropriate use cases for panic and recover in Go.

• Differentiating between errors and panics: when is it right to use each?

• Examples of using panic in scenarios like irrecoverable states or programmer errors.

• Best practices for using recover to gracefully handle panics and prevent application crashes.

4. Enhancing Errors with Context:

• Techniques for adding context to errors to make them more informative.

• Using custom error types and wrapping errors with additional context.

• How to implement and use Go 1.13’s errors package to unwrap and inspect errors.

5. Handling Errors in Large Codebases:

• Strategies for managing errors in large, complex Go applications.

• Organizing error handling code to maintain readability and reduce boilerplate.

• The role of logging in error handling: when to log, what to log, and how to ensure logs are useful.

6. Common Pitfalls in Go Error Handling:

• Avoiding the trap of overusing panic and recover.

• The dangers of ignoring errors or using error values improperly.

• How to prevent error handling from becoming repetitive and bloated.

7. Real-World Examples and Case Studies:

• A walk-through of error handling in a real-world Go project.

• Before and after: how applying best practices improved code reliability and maintainability.

• Lessons learned from Go projects where error handling went wrong and how to avoid similar mistakes.

8. Conclusion:

• Recap of the key takeaways: the importance of explicit error handling, when to use panic and recover, and how to enhance errors with context.

• Encouragement for Go developers to embrace Go’s error handling model and apply these best practices in their own projects.

Conclusion:

This talk will provide Go developers with a comprehensive understanding of error handling in Go, equipping them with the knowledge and tools to write more reliable and maintainable code. Attendees will leave with a clear strategy for handling errors in their Go applications, making their codebase more robust and their debugging process more straightforward.

^ back to index

20. Exploring the Robustness of Go: Balancing Strengths and Fragilities

Abstract

Description

Talk Description:

Introduction:

Robustness in software refers to the ability to withstand and adapt to unforeseen challenges and changes in the environment. In this talk, we’ll explore what makes Go robust and where it falls short. We’ll start by defining what robustness means in the context of programming and then move into an analysis of Go’s features that promote robustness, such as memory safety, type safety, and built-in concurrency mechanisms.

Outline:

Defining Robustness:

Explanation of robustness in software.

Examples of robustness versus fragility in systems.

Go’s Robust Features:

Memory Safety:

How Go’s memory model avoids common pitfalls like memory corruption.

Discussion of pointers, garbage collection, and slice/array bounds checking.

Type Safety:

Static typing and its impact on robustness.

Avoidance of unsafe type coercion and the benefits of explicit type conversion.

Concurrency and Error Handling:

Go’s approach to managing concurrent processes.

Use of goroutines, channels, and why Go opts for errors over exceptions.

Go’s Fragilities:

Mutable Shared State:

Risks associated with mutable shared state and data races.

Tools and techniques to mitigate these risks, such as the race detector.

Panic Handling:

Limitations of Go’s panic and recover model.

Scenarios where Go’s approach can lead to system-wide failures.

Lack of Generics:

How the absence of generics impacts code reuse and error handling.

Potential improvements with the upcoming introduction of generics in Go.

Conclusion:

In conclusion, Go’s built-in features provide a strong foundation for building robust applications, but there are areas where it can be fragile. By understanding these strengths and weaknesses, developers can make informed decisions and implement strategies to enhance the resilience of their Go applications.

^ back to index

21. Go Concurrency powering a Gigabyte scale real-world data pipeline

Abstract

Description

Join me for an in-depth exploration of Go’s concurrency features with a real-world challenge: migrating Gigabytes of data from MongoDB to PostgreSQL in real-time.

We’ll start with a basic sequential pipeline that reads MongoDB’s Operations Log (oplog), transforms its JSON structure to SQL, and executes statements on PostgreSQL. Then, we’ll supercharge it using Go’s concurrency toolkit to make it performant at scale.

Key topics we’ll cover:

• Analyzing the sequential approach and its limitations

• Introducing parallelism with worker pools

• Applying Amdahl’s law to identify bottlenecks

• Leveraging goroutines and channels to optimize the program’s run-time.

• Implementing fan-out/fan-in patterns for improved throughput

• Using sync.WaitGroup for coordination

• Handling backpressure with buffered channels

• Exploring context package for graceful shutdowns

• Optimizing with connection pooling for database operations

We’ll iteratively improve our data pipeline, showcasing code samples and performance benchmarks at each stage.

You’ll learn how to:

• Break down complex problems into parallelizable components

• Orchestrate concurrent operations effectively

• Choose the right Go concurrency primitives for specific scenarios

• Scale your data processing pipeline to handle massive datasets

Whether you’re a Go enthusiast or a concurrency novice, you’ll walk away with practical insights that you can apply to your data-intensive applications. Get ready to unlock the full potential of Go’s concurrency model!

^ back to index

22. Go See It All: Observability for the Rest of Us

Abstract

Description

Effective observability and monitoring are critical for the success of any mission-critical Golang system. In this session, we will dive deep into best practices and practical strategies for implementing comprehensive observability in Go-based backend services and microservices.

Key topics to be covered include:

1. Metrics: We will discuss how to identify and instrument the right metrics to gain deep insights into application performance, resource utilization, and overall health. Attendees will learn techniques for collecting, aggregating, and visualizing meaningful metrics using technologies like Prometheus.

2. Logging: We will explore the benefits of structured logging in Go and demonstrate how to leverage it to enable powerful filtering, aggregation, and analysis of application logs. Attendees will learn how to integrate their Go applications with centralized logging solutions for enhanced observability.

3. Distributed Tracing: We will introduce the principles of distributed tracing and show how to implement it in Go-based systems. Attendees will understand how to use distributed tracing to identify performance bottlenecks, troubleshoot complex issues

4. Observability-Driven Development: Finally, we will explore the concept of observability-driven development, where observability is shift-left to guide architectural decisions and development workflows. Attendees will learn how to leverage observability to build more reliable, performant, and maintainable Go-based systems

^ back to index

23. Go Big on Benchmarks

Abstract

Description

Performance is crucial for any Go service in production. This talk dives deep into the art and science of benchmarking Go services. We’ll explore the practices, tools, and techniques to accurately measure and improve your service’s performance.

Key topics include:

1. Introduction to Benchmarking in Go: Understanding the importance of benchmarking

2. Setting up Telemetry to gather benchmark data

3. Writing Effective Benchmarks

4. Interpreting benchmark results and identifying performance bottlenecks

5. Optimizing Go Services: Practical tips for improving performance based on benchmark data.

6. Common pitfalls and how to avoid them

7. Integrating benchmarking into your development workflow and CI/CD pipeline

^ back to index

24. Enhancing Application Security with Zero Trust Architecture: A Data-Driven Approach for Go Developers

Abstract

Description

As digital environments grow more complex, traditional perimeter-based security is becoming obsolete in safeguarding applications against modern cyber threats. Zero Trust Architecture (ZTA) presents a transformative solution for Go developers, focusing on eliminating implicit trust and continuously verifying every request. This talk explores ZTA principles such as continuous authentication, micro-segmentation, and “never trust, always verify,” and compares them to legacy security models, offering Go-specific insights.

Leveraging real-world data, we highlight a 35% rise in Zero Trust adoption between 2020 and 2024, detailing strategies like Identity and Access Management (IAM), policy enforcement, and network segmentation. These techniques have reduced security incidents by 50% post-implementation. We’ll also examine the challenges Go developers face in integrating ZTA into their workflows, including technical complexities and performance trade-offs, illustrated by case studies from tech leaders.

Looking forward, the integration of AI, blockchain, and quantum computing into ZTA is set to shape the future of security in Go development. AI-driven anomaly detection is predicted to cut response times by 60% by 2026, while blockchain-based identity management and quantum-resistant cryptography will address emerging risks. This session offers Go developers a comprehensive, data-driven roadmap to implementing Zero Trust Architecture, ensuring the security of modern applications in an interconnected world.

^ back to index

25. Building Your Own Debugger in Go

Abstract

Description

Introduction

When developing software in Go, many people use Delve for debugging. However, how many people understand how the debugger is implemented? It is difficult to discover how the debugger works due to the lack of available resources.

In this session, I will explain the mechanics of debuggers, how to implement one, and the challenges encountered when doing so in Go. By the end of this session, you will have the knowledge and confidence to build your own debugger and be better prepared to understand the source code of Delve.

About the Session

The session will be structured as follows:

1. Self-introduction (1 min)

2. Components of a debugger (3 min)

3. Debugger functionality and implementation (20 min)

4. Challenges faced when implementing in Go (5 min)

5. Summary (1 min)

1. Self-introduction

I will introduce myself and provide a brief background.

2. Components of a Debugger

I will explain the key components of a debugger.

When using a debugger in an IDE like VSCode, it communicates with the debugger server via a protocol called DAP (Debug Adapter Protocol). However, in this session, I will focus on using the debugger via the CLI and will not cover DAP implementation.

3. Debugger Functionality and Implementation

I will explain the functionalities of a debugger and how to implement them in Go. This includes using ptrace and Go’s standard debug package.

Debugger Functions Covered

• Build

Build the program to be debugged.

• Continue

Continue execution until a breakpoint is hit.

• Breakpoint

Set a breakpoint by specifying a file name and line number.

• Step in

Step into the next operation; if it’s a function call, it steps into the function.

• Step out

Step out to the line where the current function was called.

• Step over

Step to the next line of code.

• Backtrace

Display the stack trace from the main function to the current line.

• Local Variables

Display the names and values of local variables.

4. Challenges Faced When Implementing in Go

During the development of a debugger in Go, I encountered several challenges. In this section, I will explain those issues.

4-1. Receiving SIGURG Signals

While developing the debugger, I occasionally encountered situations where the debugger would stop due to receiving SIGURG signals from the program being debugged. This behavior is specific to the Go runtime, and I will explain the details.

4-2. Ptrace Error

I encountered an issue where the error “no such process” would sometimes occur when executing ptrace. Since it didn’t happen consistently, I struggled to solve this issue, and I’d like to explain the situation.

5. Summary

I will summarize the session.

Conclusion

Through this session, you will gain a deeper understanding of the basic mechanics of debuggers and how to implement them in Go. Additionally, you will learn how to address challenges during implementation. I hope this knowledge will inspire you to take on the challenge of building your own debugger or contributing to Delve.

^ back to index

26. Effortless Migration from Salesforce to AEM Guides: A Go-Powered Approach

Abstract

Description

Migrating content from Salesforce to Adobe Experience Manager (AEM) Guides requires precision and automation to ensure data consistency and efficiency. This talk presents a Go-centric, data-driven framework for seamlessly migrating content between platforms. Through detailed steps, real-world examples, and Go-based automation techniques, attendees will gain a deeper understanding of content migration challenges and solutions.

Step 1: Efficient Data Extraction

Starting with article extraction from Salesforce, the presentation leverages Go-based automation tools to capture key article metadata. Using practical Go code examples, we showcase how Go’s powerful concurrency model can be utilized to efficiently extract data from over 500 articles with minimal manual effort.

Step 2: Automating HTML Page Generation

Once the data is extracted, we move to the lookup and transformation phase, where Go functions are used to process JSON files and generate clean, web-ready HTML pages for each article. Attendees will learn how Go’s template libraries can be harnessed to programmatically structure content, ensuring consistency and scalability across hundreds of migrated articles.

Step 3: Optimizing Content and Enhancing Performance

The final step involves updating relative paths and performing automated HTML cleanup using Go’s text processing capabilities. This ensures proper linking of resources and optimized HTML for improved performance. The session will demonstrate how these updates maintain content quality and integrity post-migration, using Go-based techniques to streamline the process.

Attendees will leave with practical Go-based solutions for tackling content migration, along with actionable insights on data management, automation, and optimization. This session is perfect for developers looking to enhance their migration workflows while leveraging Go’s powerful capabilities.

^ back to index

27. Automating Code Smells Detection and Refactoring in Large Go Codebases with Machine Learning

Abstract

Description

As Go codebases expand in size and complexity, maintaining code quality and identifying code smells becomes an ongoing challenge. Traditional static analysis tools provide useful insights but often fall short in identifying more nuanced issues or suggesting appropriate refactoring steps. In this talk, I will present a novel approach that combines Go with machine learning to automate the detection and refactoring of code smells in large projects, making the maintenance process more scalable and efficient.

By integrating machine learning models trained on clean and well-structured code patterns, we can enhance the capabilities of Go’s existing tooling. These models go beyond static analysis by using contextual understanding to spot complex code smells—such as long functions, duplicate logic, and inefficient error handling—that would otherwise require manual inspection. I will demonstrate how to train and deploy these models, enabling them to continuously monitor your codebase for potential issues and even suggest or apply refactorings automatically.

We’ll also explore how this solution fits seamlessly into modern CI/CD pipelines, ensuring that code quality checks happen in real-time during development. I will share practical examples of how developers can use Go and machine learning libraries to perform automated refactoring, including function decomposition, optimizing loops, and improving code readability. This process significantly reduces the manual overhead required for code reviews, speeds up development, and ensures that technical debt is managed as the project evolves.

While this approach offers exciting possibilities, there are challenges to consider, such as gathering appropriate training data for the models and ensuring that automated refactoring done does not introduce bugs. However, the benefits of leveraging machine learning for code quality in Go projects are profound. By the end of this talk, attendees will have a clear understanding of how to get started with automating code smell detection and refactoring, creating more maintainable and high-quality Go applications at scale.

^ back to index

28. Ethical AI in Marketing Automation: Strategies for Responsible Innovation Using Go

Abstract

Description

The integration of Artificial Intelligence (AI) into marketing automation presents a landscape of both transformative potential and ethical challenges. As AI technologies such as Machine Learning (ML), Natural Language Processing (NLP), and predictive analytics become central to marketing strategies, they enable exceptional levels of personalization and efficiency. However, the use of AI also introduces critical issues like data privacy breaches, algorithmic bias, and decision-making opacity. With AI-driven marketing enhancing customer engagement by 40% and cutting operational costs by 30%, it is imperative to address these concerns to maintain consumer trust and brand integrity.

This talk will delve into the ethical considerations of AI in marketing and explore how Go can play a pivotal role in addressing these challenges. We will cover best practices for implementing robust data governance protocols to safeguard user privacy, techniques for auditing and mitigating biases in AI models to ensure transparent decision-making and strategies for aligning with international data use regulations. By leveraging Go’s efficiency and scalability, companies can develop ethical AI solutions that not only improve customer satisfaction by 25% but also strengthen brand loyalty.

^ back to index

29. Flight, Fortran, Control and Go

Abstract

Description

This talk will tell of how a group of students set out to design a test platform for a VTVL hopper powered by a rocket engine.

The test platform was designed to be electrically powered and controlled by a electronic ducted fan mounted on a gimbal.

This seemingly harmless design brings with it several non-linearities in the control system due to gyroscopic effect, fan acceleration effect on angular momentum and exhaust vorticity, which must be all accounted for to succesfully control the vehicle.

The control software was written in Go but required the use of control functions not yet present in the popular Gonum library, so what other option was left than to add them ourselves!

^ back to index

30. Security Lessons from Analyzing CVEs and Auditing Applications

Abstract

Description

Introduction

CVE Analysis

• Brief explanation of Common Vulnerability and Exposure (CVE).

• Steps to quickly understand and analyze a CVE.

• Example of CVE analysis with a CORS vulnerability.

Using crypto/rand is Not Always Enough

• Introduction to the crypto/rand package in Golang and its common uses.

• Present a CVE where using crypto/rand was insufficient for security.

• Analysis of the vulnerability and explanation of why additional precautions were needed.

Importance of Small Details

• Introduction to an authorization issue that illustrates how minor oversights can lead to significant vulnerabilities.

• Walkthrough of the details of the vulnerability.

• Importance of careful coding and thorough code reviews.

• Tips on what to watch out for in similar scenarios.

Path.Clean: This is a Trap!

• Discussion of the path.Clean function in Golang and why its naming can be misleading.

• Explanation of how developers might misuse it, leading to potential security issues.

Real-World Reviews

• Experiences from auditing open source Golang projects.

• Highlight a few vulnerabilities I discovered in Navidrome (currently being fixed) and other projects.

Conclusion

• Summary of the main takeaways: understanding CVEs, importance of cryptography, attention to detail, and pitfalls like path.Clean.

^ back to index

31. Maximizing Efficiency and Resilience: Strategies for Multi-Cloud Architectures with Go

Abstract

Description

As cloud adoption accelerates, reaching an estimated $597.3 billion in global spending by 2023, multi-cloud strategies have become essential for organizations aiming to enhance efficiency and resilience. With 89% of enterprises embracing multi-cloud environments, this approach is key to avoiding vendor lock-in, leveraging diverse services, and achieving notable cost savings.

In this GopherConAU 2024 session, we’ll explore the technical foundations of multi-cloud strategies through the lens of Go, focusing on workload-specific optimization, service diversity, and the strategic use of cloud instances. By examining data from leading industry reports, we’ll illustrate how organizations employing multi-cloud approaches have achieved an average of 15% savings in cloud expenditures and a 93% reduction in unplanned downtime.

Attendees will learn how to optimize workload distribution using Go, based on performance and cost metrics, and how to leverage the strengths of various cloud providers to reduce overall costs by up to 90% through spot instances. We’ll also cover strategies for enhancing resilience through geographic diversity and redundancy, along with the importance of continuous benchmarking for real-time performance and cost comparisons.

The session will address common challenges in managing multi-cloud environments, such as complexity, data transfer costs, and governance, and will provide practical solutions including advanced management tools and standardized processes. By the end of this presentation, participants will be equipped with actionable insights and strategies to implement cost-effective, resilient, and scalable multi-cloud architectures using Go, ensuring long-term operational success.

^ back to index

32. Things I find myself repeating about Go

Abstract

Description

• Stylistic issues

  • Use paragraphs to break up ideas

  • Constants at the top; types in the middle, functions at the end

  • Fewer files, fewer packages

  • Divide packages by what their provide, divide files by what they import

• Naming is important

• Helpers to avoid negation

• Rather than writing a comment, name the function to make the comment unnecessary

• main.run pattern to make main.main less special.

• Keep to the left; use guard clauses, return early

• An appeal for reasonable use of functional options

• If you like it, you should have put a metric on it

• Don’t log, emit a metric instead

• Initalise once and only once; use helpers to avoid the define then initialise idiom

• Writing fewer conditionals for more readable code

• If there are more than two choices, pull it into a function

• Use switch rather than if/ else/ return

• Don’t repeat (your logic), write helpers.

• Replace loops with simple generic algos

• Never take or return two things of the same type and how to avoid it

• A one slide goroutine manager

^ back to index

33. Generative AI in Go: RAG for Gophers (Yes, It's Possible!)

Abstract

Description

Generative AI is the shiny new toy everyone’s playing with, but let’s face it: Python’s been hogging the limelight. If you’re a Go developer feeling a bit left out of the AI party, fear not! We’re here to prove that Go can also tap into the magic of Large Language Models (LLMs) and build seriously cool generative AI applications.

This talk is your crash course in demystifying generative AI specifically for Go developers. We’ll start with the basics of LLMs and how they work (no, they’re not just autocomplete on steroids). Then, we’ll dive into the exciting world of Retrieval Augmented Generation (RAG). Think of it as giving your LLM a supercharged memory boost with external data – all while staying true to Go’s performance and efficiency ethos.

We’ll roll up our sleeves and show you the essential tools, models, and frameworks (LangChainGo, vector databases, Gemma and more!) to bring your generative AI ideas to life in Go. By the end, you’ll be equipped to build real-world RAG applications, impress your colleagues, and maybe even teach Python a thing or two.

Talk Outline:

The AI Hype Train: All Aboard?

A quick recap of the generative AI craze (and why it’s more than just hype).

LLMs for Gophers: The Need-to-Know

LLM 101: What they are, how they work, and why they’re awesome.\

Beyond the Buzzwords: Transformers, GANs, and other AI alphabet soup, explained.

RAG: LLM’s Secret Weapon

RAG: The cheat code for smarter LLMs (and how to utilise it in Go).\

Vector Databases: Your LLM’s external brain.\

LangChainGo: The bridge between your Go code and powerful LLMs.

Go Get Generative: Live Demo

Building a real-world RAG application in Go (expect plenty of crashes “oohs” and “ahhs”).\

Navigating the Go AI ecosystem: Tips, tricks, and gotchas.

The Ethical Gopher: AI Done Right

Bias, misinformation, and other AI pitfalls.\

Practical tips for building responsible AI systems.

Target Audience:

Go developers of all levels curious about generative AI \

Python developers considering a switch to the Go side (we won’t tell!).\

Anyone who wants to witness the power of Go in the AI realm.

Takeaways for the Audience:

A solid understanding of generative AI, LLMs, and RAG.\

Hands-on experience with essential Go tools and frameworks for building RAG applications.\

Insights into responsible AI development.\

A newfound appreciation for Go’s capabilities in the AI space.

^ back to index

34. io/fs: A key abstraction, but is it enough?

Abstract

Description

If it walks like a filesystem and it opens like a filesystem, should you abstract it like a filesystem?

Filesystems are one of the key abstractions in computing. io/fs was added in Go 1.16, to address the lack of a standardised abstraction in Go. Currently the interfaces are read-only; there are various third-party extensions which provide writable APIs. We’ll look at what io/fs and related standard library APIs offer, some extensions, as well at what can be abstracted with io/fs…

Maybe you shouldn’t abstract your key/value store as a filesystem, but you could abstract your git repository.

^ back to index

35. Harnessing AI and Human Expertise for a Sustainable Utility Future

Abstract

Description

In the rapidly evolving utility sector, the integration of AI technologies is transforming operations by enhancing efficiency, sustainability, and customer satisfaction. This presentation explores the role of AI innovations—such as predictive analytics, real-time data processing, and AI-powered customer service—in reshaping the industry. Key achievements include a 30% reduction in downtime through AI-driven predictive maintenance, a 25% increase in grid stability via real-time energy demand forecasting, and a 20% improvement in customer engagement with virtual assistants.

A case study from the Catapult Project demonstrates how edge computing and machine learning models enabled 95% accuracy in energy demand forecasting, reducing operational costs and improving grid performance. The presentation will highlight how AI systems complement human decision-making by enhancing responses to grid anomalies and equipment failures, underscoring the essential role of human oversight.

Looking ahead, emerging AI technologies like edge computing and autonomous systems are poised to deliver a 40% improvement in operational efficiency by 2025. By combining AI’s data processing power with human expertise, this collaborative approach will drive a more resilient, efficient, and customer-focused utility sector.

^ back to index

36. Profiling WebAssembly with pprof and wzprof

Abstract

Description

Embark on a journey to supercharge your Go applications targeting WebAssembly by harnessing the formidable profiling capabilities of pprof and wzprof. Join us for an illuminating session where we’ll unravel the intricacies of optimizing Go-powered web applications for maximum performance.

Central to our discussion will be the powerhouse duo of pprof and wzprof. You’ll discover how pprof, Go’s venerable profiling tool, forms the foundation of our optimization journey, providing deep insights into CPU and memory usage. Complementing pprof’s prowess, wzprof emerges as a specialized profiler tailored for WebAssembly, offering streamlined performance analysis during the execution of WebAssembly modules.

Through practical demonstrations and real-world examples, we’ll showcase the symbiotic relationship between pprof and wzprof, illuminating how they work in tandem to identify and resolve performance bottlenecks in your WebAssembly applications. From CPU-bound computations to memory management intricacies, you’ll gain actionable insights into optimizing your Go code for unparalleled efficiency and speed.

Whether you’re a seasoned Go developer or embarking on your WebAssembly journey, this talk promises to equip you with the tools and techniques needed to unlock the full potential of your applications.

^ back to index

37. Generate RESTful services using gRPC-Gateway

Abstract

This talk will be about writing REST services using gRPC-Gateway. I will try to give intuitive and rigorous meanings of gRPC-Gateway and its usage.

I will try to demonstrate simple Hello World gRPC services using gRPC-Gateway and will give more understanding of Protobuf, REST, gRPC, etc.

Description

^ back to index

38. Empowering Go with WebAssembly System Interface (WASI) Unleashed

Abstract

Description

The WebAssembly System Interface (WASI) is gaining popularity as a compile-once-run-anywhere target for developers of cloud-native applications. WASI is a system interface that provides a standardized way for WebAssembly modules to interact with the underlying system, regardless of the specific operating system or architecture.

WASI greatly improved interoperability in the WebAssembly ecosystem. Still, its use cases have been focused on basic OS integration, such as reading environment variables or interacting with file systems.

Go 1.21 added a new port named wasip1 (short for WASI preview 1), enabling Go developers to target server-side WebAssembly runtimes implementing WASI, such as Wasmtime, WasmEdge, or Wazero. Along with this addition to the Go toolchain, solutions have also emerged in the ecosystem, bringing full networking capabilities to Go applications compiled to WebAssembly.

This session starts with an introduction to the WebAssembly System Interface and an overview of the support for WASI in the Go toolchain, illustrated by live code examples, and dives into how applications can leverage WASI and networking extensions to build powerful WebAssembly applications with Go.

This talk gives attendees a comprehensive understanding of building and running Go applications with the WebAssembly System Interface (WASI).

^ back to index

39. Vector Databases: Benchmarking, Applications, and Best Practices

Abstract

Description

Overview

Vector Databases have exploded onto the scene, with established players and newcomers reshaping the landscape. With RAG (Retrieval-Augmented Generation) becoming ubiquitous, VectorDBs are undeniably on the rise. But amidst the hype, many questions remain:

• How do you effectively work with a VectorDB using Go?

• What are the best practices for different use cases?

• Which DB should you choose for your specific needs?

• Where do you even start?

We grappled with these questions when we first dove into VectorDBs. Our solution? We benchmarked them using Golang!

This talk will not only demystify VectorDBs and provide a clear starting point, but also showcase why Go is the perfect language for working with VectorDBs. We’ll offer a deep dive into our benchmark results, covering performance, use cases, and cost comparisons of various solutions including Weaviate, QDrant, Pinecone, and Milvus.

We’ll demonstrate how each VectorDB shines in different scenarios, catering to diverse team needs and project requirements. Throughout the talk, we’ll use Go to illustrate key concepts, making it accessible for beginners while progressively introducing more advanced topics.

Audience Takeaways

Understand the history and internal architecture of VectorDBs

Gain practical knowledge on VectorDB usage and selection using Go

Learn how to match specific VectorDBs to appropriate applications

Master Go techniques for efficient VectorDB operations

Get inspired by advanced use cases in AI and data handling

Session Outline

• [2min] VectorDBs: From Past to Present

• [3min] The VectorDB Landscape: Why Go is the Perfect Fit

• [5min] VectorDB Internals: How They Work (with Go examples)

• [3min] The Art of Benchmarking VectorDBs: Process and Importance in Go

• [7min] Our Golang Benchmark Deep Dive: Key Insights for Weaviate, QDrant, Pinecone, Milvus, and more

• [3min] Live Go Code Demo: Practical VectorDB Operations

• [5min] VectorDB Landscape Analysis: Matching DBs to Use Cases in AI and Data Handling

• [2min] Wrap-up and Q&A

This talk is designed to cater to a wide audience, starting from the basics and progressively introducing more advanced concepts. Whether you’re an AI enthusiast, a Go developer, or a data handling expert, you’ll walk away with valuable insights and practical skills.

^ back to index

40. Mastering Distributed Tracing with Go: From Basics to Best Practices

Abstract

Description

With the growing adoption of microservices and distributed systems, maintaining visibility across all components of a Go application has become increasingly challenging. Distributed tracing is an essential tool for developers, providing a detailed view of how requests traverse a system, pinpointing bottlenecks, troubleshooting errors, and enhancing performance. This talk aims to simplify distributed tracing in Go, offering insights from foundational concepts to advanced practices that make applications more robust and efficient.

The session begins with an accessible introduction to distributed tracing, highlighting its significance in modern application architecture and the advantages it offers over traditional logging and monitoring techniques. Attendees will learn how to set up distributed tracing in Go applications, utilizing open-source tools like OpenTelemetry to instrument their code and gather actionable insights about application behavior.

The session then moves into practical application, demonstrating the integration of OpenTelemetry with a Go-based microservice. The talk covers essential aspects of tracing key operations and managing context propagation across services. It also includes best practices for designing effective traces, focusing on what to trace, how to minimize overhead, and strategies for managing trace data to avoid information overload.

To provide real-world context, the talk includes two case studies. The first case study explores a high-traffic analytics platform where distributed tracing in Go was implemented to identify and resolve performance bottlenecks during peak periods of usage periods, resulting in a significant improvement in response times. The second case study examines how a financial services company utilized distributed tracing to detect and fix a complex concurrency bug in a payment processing system, reducing transaction errors and improving user experience. Additionally, the talk explores how generative AI, specifically GPT-4, can assist in distributed tracing efforts. By using AI, developers can automate various aspects of the tracing process, such as generating code snippets for common tracing patterns or analyzing trace data to detect potential issues. This integration of AI helps streamline the development process and ensures that tracing setups are both efficient and effective.

The session concludes with a discussion on the future of distributed tracing in Go, including emerging trends and tools that are shaping the field. Practical tips and resources are provided for developers who want to implement or refine distributed tracing in their Go projects. By the end of the talk, attendees will have a thorough understanding of distributed tracing in Go and be equipped with the knowledge and tools to enhance the observability and performance of their applications.

^ back to index

41. ReverseProxy is the amazing gem of the go std lib

Abstract

Description

The go std lib features a hidden gem in httputil.ReverseProxy. It’s an amazing and powerful tool that most developers don’t know about or don’t think about using.

This talk will explain what it is, how to use it, and when to use it. Developers of web services will discover new ways to approach their work using ReverseProxy to simplify their workflow and more safely release changes to production.

During this talk I will show 4 different ways I have used this to solve problems in my day job, from black box debugging http calls during local development through to safely rolling out changes to the production metrics pipeline of a large company using a tool built from scratch in just 1 week. These different ways of using ReverseProxy highlight what a flexible tool it is and how you can apply it in many ways where being able to intercept and redirect traffic simplifies real work problems.

^ back to index

42. Don't make the same mistakes I did: Tips for designing Kubernetes Custom Resource Definitions in Go

Abstract

Description

Using Go to write Custom Resource Definitions (CRDs) in Kubernetes is very powerful and useful, but, as with any API, there are lots of easily-avoidable pitfalls - once you know about them.

This talk aims to take over 4 years of experience in building CRDs and condense it down to useful, practical rules about building your CRDs in Go.

Some areas I’ll cover include:

• Patterns for mapping Go data types to CRDs

• Generating YAML CRD definitions from Go code, and how you can leverage generators to make your life much easier

• Mistakes I’ve both made and seen made when designing various types of APIs

You should expect to come away from this session with an understanding of common CRD design errors in Go and the ways you can avoid them.

^ back to index

43. Is Go Object-Oriented? A Case of Public Opinion

Abstract

Description

^ back to index

44. The Gopher Orchestra: Distributed Machine Learning with Go

Abstract

Description

In this deep dive talk, we will explore the world of distributed machine learning architectures using Go, a powerful and efficient programming language. Scaling machine learning algorithms across distributed systems presents unique challenges, and Go’s concurrency model and robust ecosystem make it an ideal choice for building scalable ML architectures.

Throughout the session, we will unravel the intricacies of distributed machine learning in Go, uncovering fascinating insights and thought-provoking ideas. Finally, we will examine various distributed ML architectures, including data parallelism, model parallelism, and hybrid approaches, showcasing how Go’s lightweight goroutines and channels enable seamless orchestration of distributed computations.

Key takeaways from this talk include:

• Insight into the unique challenges and opportunities of distributed machine learning architectures in Go.

• Understanding of key distributed ML techniques such as data parallelism, model parallelism, and hybrid approaches.

• Knowledge of scalable ML architectures, including data sharding, model synchronization, and fault tolerance mechanisms.

• Ability to leverage Go’s concurrency model and robust ecosystem to build scalable and efficient ML systems in distributed environments.

^ back to index

45. Massively Parallel 3D Part Design in Go

Abstract

Description

Description

OpenSCAD is the defacto tool for creating 3D objects and has found widespread use in the maker community.

But, ask anyone who works with it regularly and they’ll tell you OpenSCAD scripting is a pain.

What if we could script shapes in Go and render them thousands of times faster than OpenSCAD?

In this talk we’ll see how you can script shapes in pure Go and choose to use the GPU if you have a need for speed.

We’ll learn about Signed Distance Functions (SDFs) and how with simple math one can defined complex and beautiful shapes

that can be 3D printed or rendered on screen. Of course, there’ll be no shortage of live-coding demonstrations with real-time shape rendering.

Introduction to SDFs

A signed distance function (SDF) is a function that takes a 3D position (x, y and z coordinates)

and returns a number representing the minimum distance to the surface of the object it defines.

func SDF(x, y, z float32) (distance float32)

This function is already extremely useful. We can design extremely complex parts with

the idea of an SDF. Any shape that can be described by a mathematical function works-

and unsurprisingly that includes most shapes used for engineering applications, as well

as many, many more that were not possible using traditional CAD software. The world of SDFs

has only recently begun to be studied in depth.

The above example takes in a single point. We can vectorize the API to make it suitable

for massive parallelization:

type Coord [3]float32



func SDFVectorised(position []Coord, distance []float32)

This function will pass in the position buffer as input to the GPU program

and the GPU program will store results for each individual coordinate in the distance

buffer. How do we tell a GPU to do this? By writing a shader with the SDF source code

much like we’d do in Go. Below is the SDF for a sphere of radius=1 written in OpenGL’s shader language (GLSL):

float sphere(vec3 v) {

 const float radius = 1.;

 return length(v) - radius;

}

So this looks like code that is reasonably similar in function to Go- right? WRONG!

Although it looks more similar to the first function we defined (SDF), the sphere

function is actually massively parallel due to the design of GLSL.

Behold, a GLSL program that calculates the distance to the sphere lies below.

layout(rgba32f, binding = 0) uniform image2D position_buffer;

layout(r32f, binding = 1) uniform image2D distance_buffer;



void main() {

 ivec3 idx = ivec3( gl_GlobalInvocationID.xyz );

 vec3 position = imageLoad(position_buffer, idx).rgb;

 float distance = sphere(position);

 imageStore(distance_buffer, idx, vec4(distance,0.,0.,0.));

}

This function will be called simultaneously for every element in the buffer.

If the positions buffer we pass to the GPU is 16000 in length, it will run 16000 times, in parallel,

which is to say it would (in theory) run 16000 times faster than our single threaded,

CPU-bound SDF function we defined earlier for the same sized buffer since we have to

wait for each call to SDF to finish before calling it on the next position.

gsdf

Enter gsdf. You can now code your shapes in pure Go. What’s more is you can choose to render

them using the GPU if you have a need for speed you need to satisfy.

gsdf is the spiritual successor of a 3D design module written in Go that was itself inspired by another 3D design module, also written in Go.

All 3 modules are products of frustration with both free and paid available software for 3D design.

gsdf today has most of the functionality needed to design shapes for engineering applications.

It is also remarkably easy to implement your own SDF, giving users flexibility to integrate

new shapes at the lowest level that are not currently available in gsdf.

^ back to index

46. Is Go a Good Language for Building a Compiler?

Abstract

Description

Session Overview: Building a Compiler with Go

What You’ll Learn

1. Creating an Open-Source Compiler in Go

• Step-by-step guide to compiling a new syntax entirely in Go.

2. Optimizations

• Internal Optimizations: Techniques for improving the performance of your compiler.

• Profile-Guided Optimization (PGO): An overview of PGO and how to implement it.

3. LLVM Backend Integration:

• Advantages: Why integrating with LLVM can be beneficial.

• Key Considerations: Important factors to keep in mind during the integration process.

4. Compiler Bootstrapping:

• Plans and strategies for bootstrapping your compiler.

Who Should Attend?

• Compiler Beginners Welcome: This session is designed with beginners in mind, so no prior experience with compiler concepts is necessary.

^ back to index

47. 80% faster, 70% less memory: the Go tricks we've used to build a high-performance, low-cost Prometheus query engine

Abstract

Description

We’ve been building a brand-new, Prometheus-compatible query engine from the ground up for Grafana Mimir in Go.

Our new query engine has been designed to deliver an improved user experience and vastly improved performance: our benchmarks show queries running up to 80% faster and with 70% lower peak memory consumption than Prometheus’ default engine, and our real-world testing shows similar results.

As we’ve been building the engine, we’ve learnt a number of Go performance lessons the hard way, including why using byte slices can sometimes be preferable to strings, the benefits and costs of memory pooling and the surprisingly large impact of function pointers. And we’ve seen the complexity (and bugs!) these things can introduce too, and developed a number of techniques to help combat this.

In this talk, you’ll:

• Get a peek inside the engine and some of the key design decisions that have enabled these results

• Learn some of the Go performance lessons we’ve learnt along the way: the things that worked, the things that didn’t, and the thing that later caused us a day of hunting down a hard-to-replicate bug

• Learn some of the techniques we’ve implemented to combat the issues some of these performance optimisations can introduce

• Learn how to apply these ideas to your own projects

• Hear what we plan to do next to improve the engine even further

^ back to index

48. API Design First development: Creating Robust Go Implementations

Abstract

Description

Outline

The presentation will focus on two main topics:

1. Evolution of our API Development Approach: We’ll discuss our team’s transition from a traditional code-first method to a design-first philosophy. This section will highlight the challenges and insights gained during this significant shift in our development paradigm. We’ll examine how prioritizing user needs over simply exposing data has led to the creation of more user-friendly, intuitive and composible APIs.

2. API Design first Development Toolkit: We’ll introduce the suite of tools we’ve adopted to enhance our software development lifecycle (SDLC), with a particular emphasis on API design and documentation. This includes our strategies for automating code generation for server stubs and client SDKs, as well as streamlining our development processes. We’ll showcase our core toolkit, featuring powerful tools such as go-task, oapi-codegen and Redocly.

Our API Development Approach (10 mins)

Talk about what it takes to shift to Design-First approach. The shift to a design-first approach fundamentally alters the development workflow. Any interface modifications now necessitate a code regeneration step before actual coding begins. This raises important questions about code organization: How can we maintain a clear separation between generated code and custom implementations? What strategies can we employ to effectively test the generated portions of our codebase?

On the API consumer side, the availability of up to date, published documentation enables immediate implementation and testing, streamlining the integration process. However, this paradigm shift is not without its challenges for developers. They must adapt to a new mindset where API design takes precedence, potentially requiring additional time and effort upfront.

API Design first Development Toolkit (15 mins)

We will talk about oapi-codegen (https://github.com/oapi-codegen/oapi-codegen) and why picked it up over the default open-api specification generator. Also, talk how we used go-task (https://github.com/go-task/task) to automate code generation as part of developer workflow and CI process. Lastly, talk about our API Catalogue which helps API consumers easily discover and consume APIs.

Demo: Do a demo of making changes to an Open API specification, generating code, generating new test cases, make code changes and run tests again.

Target Audience

The presentation is aimed for individuals with moderate to advanced experience in Golang programming, interested in adopting API design first development practices.

Impact

Our goal is to inspire increased adoption of API design-first development within enterprise environments, we aim to

1. Share practical insights from using an API design first approach in a regulated environment, focusing on benefits and challenges.

2. Empower developers with Design First thinking, leveraging GoLang’s simplicity to implement and iterate over well-designed APIs. While this approach encourages a focus on user needs and interface consistency, GoLang’s simple yet strict syntax and powerful standard libraries enable quick prototyping and resilient production code. The combination fosters a development environment where design principles guide implementation, resulting in more intuitive, maintainable, and scalable APIs.

^ back to index

49. Navigating the Chaos: A Holistic Approach to Incident Management

Abstract

Description

Remember when we were at school, and people said - “Actively listening in class guarantees 50% prep for the upcoming test”?

The same goes for being proactive at work in ways that will instantly prepare you to manage incidents better (at night or in general).

In this talk, I will lay out the foundations of incident management, including key questions that if you’ll be able to answer - You will be able to easily manage incidents, no matter the time and place.

I will also show the best practices I’ve finalized over the years that helped me get a clear vision of how to manage production incidents in the quickest & efficient way possible.

Embracing the tips I’ll give you will guarantee you’ll not only talk the talk but also walk the walk when it comes to incident management.

^ back to index

50. Technical Documentation - How Can I Write Them Better and Why Should I Care?

Abstract

Description

Data collection done by people is a wasteful act and could result in duplicated work by different people.

Gathering info for tasks, or for the ability to maintain code or infrastructure - Documentation plays a crucial part in that.

In this talk, I’ll show you a structured way to write your Go technical doc, without being a technical writer - So everyone could do it to their best ability.

I’ll explain why you should care about these docs, and how eventually it serves your best interests (Yes, more than 1).

I’ll also touch about best practices of writing docs specifically in Go, including how docs and tests interact, conventions, etc.

If you want to save your time and other people’s time - Writing documentation well could have a great impact on that.

^ back to index

51. Secret scanning in open source at scale (in-depth)

Abstract

Description

Supply chain security conversation is booming these days after attacks like log4j came to the scene.

In this in-house research, we have conducted research on publicly available open-source assets like (JS packages), WordPress Plugins, and Ruby Gems to find out the presence of mistakenly or deliberately publicly exposed secrets (including private API keys and so on) i.e. AWS, Google, etc. (33 different types!)

This could pose a risk to anyone using those packages as dependencies or plugins so that this chain of not re-inventing the wheel could become a disaster that stops the wheel once and for all.

We would be presenting our research done on a large scale after in-house scanning on:

• Around 2 Million+ NPM Packages. (almost all publicly available at the time of research)

• About 60,000 WordPress Plugins. (almost all publicly available at the time of research)

• Ruby Gems (almost all publicly available at the time of research)

We would be demonstrating the numbers and impact to an audience in this talk and we would also be providing ways to prevent this and automation to integrate in your own ci/cd pipelines to prevent such disasters from happening.

Outline:

• Introduction to supply chain attacks.

• Introduction to secrets.

• History of such attacks.

• What results we found when we did research on almost all wordpress plugins to find 33 types of secrets (each and every plugin and each and every file).

• Same as above for JS Packages (almost all).

• Same as above for Ruby gems (almost all).

• Breakdown of severity of leakage of each private key and secret type and how many of those we found in each type of assets.

• Impact

• Demonstrations (videos and code snippets and screenshots of secrets leaking).

• Common files leaking such.

• Stats of leakage

• How to prevent it from happening and solution for orgs.

—- Takeaways: —-

• Discussion of the rising significance of supply chain security in the context of recent high-profile breaches.

• Explanation of the research methodology involving scrutiny of open-source assets for publicly exposed secrets.

• Emphasis on the risk to users who depend on these packages, potentially leading to catastrophic security vulnerabilities.

• Addressing the paradox of not reinventing the wheel through code reuse and the need to mitigate associated risks.

• Quantification of the research’s scope and scale, including analysis of over 2 million NPM packages, Ruby gems, and 60,000 WordPress Plugins.

• Presentation of empirical findings, underscoring the extent of exposure and the potential impact on software ecosystems.

• Introduction of proactive measures and best practices to avert similar vulnerabilities, with a focus on integration into CI/CD pipelines for automated prevention.

• Opportunity for attendees to gain insights into safeguarding their development workflows and enhancing their software security posture.

^ back to index

52. Go-ing Windows: API Bindings for the brave (and foolish)

Abstract

Description

Windows APIs: A Go Perspective

Windows APIs are a gateway to powerful OS functionalities. Traditionally, however, you had to know (or suffer) C++ or C# to access them.

In this talk, we will learn how to bridge this gap with Go by integrating Windows OS-level functionality into Go applications. We will then put our knowledge to the test by building a real-world app live together.

Outline

• Understand Windows APIs

• Introduction to the Windows API

• What they are and why they matter

• How to use Windows APIs in Go

• Different options with code examples

• Key challenges in each option

• Accessing Windows APIs via pure Go

• Step-by-step guide to:

• loading DLLs

• accessing functions

• making API calls

• Build an app live: Enable Windows mouse pointer trails via Go

• How to discover the API

• Implement the binding in a simple Go program

• Ship it

• Conclusion

• Tools for simplifying API bindings

• Extending the approach to broader tasks.

By the end of this session, you’ll know how to bind and use Windows APIs within your Go projects, empowering you to build more capable and versatile applications.

^ back to index

53. Where the bloody hell are you? GIS in Go

Abstract

Description

While building a system that had to process and analyse GIS data in Go, we ran into many interesting challenges:

• weird input data

• TIFF files with more data than you can imagine

• GeoJSONs… maybe.

This talk will be a journey across:

• The basics of GIS

• Some of the libraries that can be used to solve some of these issues

• Broken assumptions which make some things more difficult to do in Go (than Python)

• Why do these things in Go? What about Postgres/PostGIS? When to turn to GDAL/OGR?

• Flat Earth assumptions

^ back to index

54. So, you want to add sum types to Go?

Abstract

Description

You might have head of “sum types”, “union types”, “variants”, “algebraic data types” or “enums”. You might have heard someone say “Go already have sum types, they are called interfaces” and the retort “but I want closed sums!”. You might have heard that “there is no point adding sum types without pattern matching”. And maybe you are curious what all those words mean. Or maybe you just want to be able to say that a value has to be one of several types, why is that so hard‽

I will explain what variants are, what they are useful for and all the questions you need to answer if you actually want to add them to a language and what their implications are. And I will put that into the context of adding them to Go: Why it has not happened yet and what I would predict for their future.

^ back to index

55. Why we can't have nice things: Generic methods

Abstract

Go got generics, but they are pretty limited. One of the most unpopular limitations is the inability of having methods with extra type parameters. The proposal is stalled, despite having over 600 upvotes.

Why can’t add this widely popular feature? There happen to be good, technical reasons.

Description

Generic methods would allow us to write chaining APIs. This is particularly important for functional iterator patterns, which currently have to stretch over multiple lines, or be awkwardly nested. It would also allow us to properly attach generic code to the type it belongs to. An example is func N[T constraints.Integer](n N) N in package rand: It makes it easier to choose a random time.Duration, for example. But it should really be a method on *rand.Rand.

So no one really contests that it would be useful to have this feature. Even the Go team largely agrees. But the omission was intentional. The reasons for it stretch all the way back, to even before Go’s first open source release. In fact, it might be the reason we even got generics at all.

I walk through the uses of this feature, the reasons adding generics took so long and how they lead to this omission.

^ back to index

56. How to do less work with code generation - and when you should avoid it.

Abstract

Description

^ back to index

57. Who broke the build? — Using Kuttl to improve E2E testing and release faster (workshop)

Abstract

Description

No one wants to be responsible for breaking the build. But what can you do as a developer to avoid being the bad guy? How can project leads enable their teams to reduce the occurrence of broken builds?

In talking within our own teams, we discovered that many developers weren’t running sufficient integration and End to End tests in their local environments because it’s too difficult to set up and administer test environments in an efficient way.

That’s why we decided to rethink our entire local testing process in hopes of cutting down on the headaches and valuable time wasted. Enter Kuttl. Connecting Kuttl to CI builds has empowered our developers to easily configure a development environment locally that accurately matches the final test environment — without needing to become an expert CI admin themselves.

These days, we hear, “Who broke the build?” far less often — and you can too!

^ back to index

58. Who broke the build? — Using Kuttl to improve E2E testing and release faster

Abstract

Description

No one wants to be responsible for breaking the build. But what can you do as a developer to avoid being the bad guy? How can project leads enable their teams to reduce the occurrence of broken builds?

In talking within our own teams, we discovered that many developers weren’t running sufficient integration and End to End tests in their local environments because it’s too difficult to set up and administer test environments in an efficient way.

That’s why we decided to rethink our entire local testing process in hopes of cutting down on the headaches and valuable time wasted. Enter Kuttl. Connecting Kuttl to CI builds has empowered our developers to easily configure a development environment locally that accurately matches the final test environment — without needing to become an expert CI admin themselves.

These days, we hear, “Who broke the build?” far less often — and you can too!

Session Outline:

^ back to index

59. From the Top: Mastering the DevOps Machine Learning Pipeline for Unrivaled Innovation - A CEO's Perspective on Cool DevOps

Abstract

Description

^ back to index

60. How Golang Changed My Life.

Abstract

Description

1- Introduction ( The early Days ):

The first time I saw a computer was in form 3, and it was a moment I’ll never forget. Until then, my exposure to technology had been limited to television and the occasional radio. When I entered the computer lab at school, I was amazed by the rows of computers with their blinking lights and screens. I didn’t know what those lights signified, but I was fascinated by the idea that you could interact with a screen using a small device called a mouse. I remember watching other students navigate through menus and click icons, thinking it was the coolest thing in the world.

I think I have the best parents in the world that have always wanted me to succeed, but they couldn’t afford to buy a computer. As a result, I often had to borrow completed assignments from other students to do my homework, emphasizing the word “completed” since most times I didn’t understand what the teacher was asking us to do. Although I didn’t fully understand the code they had written or what they’ve done, I was eager to learn more. I would ask them to explain their work, hoping to grasp the concepts behind it. There were many times when I had to go to a friend’s house to complete my practical assignments. She and her family were very welcoming, and lived just a few meters away. She obviously knew a lot more about programming than I did. Although I said I was doing my assignments, she did most of the work while I followed along, trying to understand what was happening on the computer. We would spend hours after school at her place, and I became more comfortable with programming thanks to her guidance.

Getting access to the school’s computer lab wasn’t easy. The school had a strict policy on which classes were allowed in the computer lab, and being a young kid in a non-examination class, I felt discouraged by this policy. Despite this, I understood that the school had valid reasons for such restrictions.

Due to my lack of access to the computer lab and the fact that we didn’t have a computer at home, my enthusiasm for learning programming began to wane. Because of this, I didn’t do well in the first two terms of Form 4. My computer teacher passed an ultimatum: anyone who didn’t pass his tests during the first two terms wouldn’t be allowed to take his subject in Form 5, which was the next year and an examination class. Given this ultimatum, I had no choice but to drop the subject in Form 5.

In my final year of high school, I managed to build some momentum and reignite my programming journey. However, I still struggled during the first and second terms, leaving me with a lot of catching up to do. There was one pivotal moment in the computer lab that ultimately became a significant learning experience. One day during a practical session in the Lab, I was asked to explain the difference between “volatile” and “non-volatile” memory. Having just returned to computer science after being forced to drop it in Form 5, I was excited but nervous. Unfortunately, I reversed the definitions, assigning the characteristics of volatile memory to non-volatile memory, and vice versa. I presented my answer with confidence, but my teacher simply shook his head, and the entire class burst into laughter. As one of only three students from an Arts Major taking a computer science course among a class full of Science Majors, the experience was humiliating.

I seriously considered never returning to that classroom. However, when the next class came around, I mustered the courage to go back. Looking back on it now, I realize that my determination to succeed was stronger than my embarrassment. Despite being laughed at by an entire class, I returned to continue my learning journey.

In high school, I didn’t do a lot of programming. We started with HTML, but I found it intriguing how lines of code could create web pages. At the time, programming in C was part of the curriculum, but it seemed so distant and complex. I knew it was a programming language, but the specifics were beyond my grasp. We didn’t have many resources, and there were few teachers who understood advanced programming languages.

When I entered college, I was surprised to find that most of the courses focused on hardware and theory, with limited attention to software development. This made it challenging to find guidance and resources to pursue my passion for programming. My first attempt at writing a C program in college was daunting—I struggled with syntax errors and understanding basic concepts. Adding to the challenge, I didn’t have a laptop during my first semester in college, so I had to write the code by hand and cross my fingers that it would work or it was correct. The lack of mentorship and limited access to educational materials made the learning process slow and sometimes frustrating.

In college, I faced the most challenging time of my academic life. I loved computers, but I didn’t meet all the necessary requirements, coming from an arts background instead of a science background. As a result, I couldn’t get into a state university, which would have significantly reduced the tuition burden on my parents. The state university rejected my application to study computer engineering because I was an arts major. This made sense, as computer engineering is typically associated with those from a science background, who are expected to have more mathematical brain cells or something like that. The only options available to me were public administration and a host of other courses that I didn’t like or understand.

In a state of confusion, since attending a state university on a scholarship was my only plan for pursuing my dream of computer science, I had no choice but to apply to a private university. This was contrary to what I had hoped for my parents, as it would increase the financial strain, but it allowed me to pursue what I wanted to study in college. Fortunately, the private university offered candidates the flexibility to choose their field of study, so I selected computer engineering.

The first and second semesters were the most difficult part of my college experience. As a quick note, I was an arts major who had never taken advanced mathematics, physics, or chemistry in high school. I knew before choosing this path that it wouldn’t be easy, and I remember the day I saw the department’s course timetable. I had to ask the meaning of some of the course names listed on the schedule, as they were entirely new to me coming from an arts background. Additionally, my science-major classmates in the room during coding sessions or engineering mathematics classes seemed to grasp concepts much faster. It often felt like I was the only one struggling to keep up, I would frequently ask professors to explain concepts two or three times.

Despite this, I had excellent professors who wanted me to succeed, and my habit of asking for help when I didn’t understand became something that paid off. This habit, which I wasn’t ashamed of, helped me improve my relationship with my classmates, but of course some of them hated me. It became a class-wide joke that when a professor explained something during a coding session, everyone would turn and look at me, knowing I would say, “Wait, what? Could you explain that again?” Even though it felt like I was holding the class back, I found that my determination to ask questions and seek help from those who were smarter than me ultimately helped me succeed.

2- Discovering Go - ( The Turning Point ) :

A few years ago, I embarked on a journey to teach myself various programming languages, including JavaScript, Python, Java, and even a bit of C. However, my relationship with C was fraught with hesitation, primarily due to its complex schema and the discouragement from my college classmates. They often remarked that C was a challenging language to grasp, and I let that sentiment shape my perception of it, solidifying my aversion to C. Despite these challenges, my mentor, Ryan Yoder, introduced me to Golang while we were working on a minimum viable product (MVP) for a startup. I had just over a week to get up to speed with Go, which felt like a daunting task, especially with my preconceptions about C looming in the background. At first glance, Go seemed like a superset of C, evoking memories of my college years when even the mention of “pointers” sent shivers down my spine. Other programming languages I had explored never intimidated me as much as C, and this sudden reintroduction to similar concepts initially felt like a hurdle. However, as I delved deeper into learning Go, I began to notice the differences that set it apart from C and other languages I was familiar with.

One unique aspect of Go that quickly stood out to me was its design philosophy and the rationale behind its creation. In my experience with other programming languages, I never took the time to explore the reasons behind their development or the specific problems they aimed to solve. This was the first time I delved into the “why” of a programming language—the underlying purpose driving its creation. The compelling force that attracted me to Go and made me a Golang enthusiast was its commitment to simplicity. The idea that a language could be built on such clear and straightforward principles was truly fascinating to me. The idiomatic approach to coding, with a focus on efficiency and readability, made Go distinct and refreshing in a world where programming languages often prioritize complexity and feature overload.

Another feature of Go that quickly stood out was its approach to concurrency through goroutines and channels. This concept of lightweight threads was unlike anything I had encountered in languages like Java, where concurrency was often achieved through complex patterns or additional libraries. The ease of managing concurrent operations in Go was like a breath of fresh air, offering a straightforward way to handle parallel tasks without the overhead of traditional threading. As I progressed through online resources and tutorials, I discovered Go’s emphasis on simplicity and readability. Unlike C, where I often felt tangled in complex syntax and cryptic error messages, Go provided a much clearer and more concise way to express logic.

Although it took me some time to grasp concepts like “pass by value” and “pass by reference,” Go’s straightforward error handling and detailed stack traces helped ease the learning curve. Despite the tight deadline to get up to speed with Go, I found myself gradually enjoying the language’s simplicity and flexibility. During that intense week, I managed to build a small billing system and learned on the job, which was a significant milestone for me. It wasn’t just about meeting the project deadline; it was about overcoming my fear of C-like languages and discovering the beauty of Go’s design philosophy.

In the end, my journey with Golang taught me that it’s possible to break through preconceived fears which i think might be a problem for some developers that don’t like a particular programming language not because it’s a terrible language but because of the ergonomics of the language i might call it or maybe i’m the only one, but learning Go provided a space for me to revisit my past experience when pointers was a problem learning C with a different mindset..

The language addressed many of the issues I had encountered in other programming endeavors which were mainly Simplicity, big Community support (the ones that would actually answer your question and give feedback Like the Golang-insider community on X), baked in prerequisites tool chains for developers like formatters, testing packages etc all baked into the language standard Library, building a language with a design philosophy around it (Go idioms) , offering a unique combination of power and simplicity. This experience not only broadened my programming skills but also reshaped my perspective on learning and growth.

3- Professional Development (Impact of Golang):

When I started my journey with Golang, I experienced a steep learning curve. Coming straight out of college with only a handful of programming language knowledge and software development experience, I didn’t realize the full extent of skills required to succeed in the software engineering field. In my country, software engineering is a highly sought-after skill across all sectors, but there’s a common misconception that getting a job is straightforward if you call yourself a software engineer or hold a certificate.

My early years after college were marked by this “get a job quickly” mentality, believing that having a degree would be enough to secure employment. It wasn’t until I began learning Golang that I understood the depth of skills and complementary expertise needed in the tech industry.

One significant turning point was joining the Golang Slack community, thanks to an introduction by Martin Gallagher. Engaging with other developers in this community, as well as the Golang-insider community on X (shoutout to Matt Boyle), provided me with a broader perspective on software development. These interactions helped me set a clearer vision for my software career, emphasizing the importance of continuous learning and community support.

Initially, learning Golang was challenging. I wasn’t sure where to start, and there was always a question of which technology or programming language to choose, which I guess it’s a common question among beginners either in tech or deciding to learn a new programming language. Fortunately, I found helpful resources like online courses, books, and active developer communities. These resources provided the guidance I needed to navigate the Golang ecosystem and gain confidence in my skills.

The first time I used Golang was literally building a startup company MVP product which played a significant role in my learning and exploration of Golang. They allowed me to apply what I was learning, and through them, I experienced both successes and failures. These early experiences were crucial in shaping my understanding of the language and its real-world applications. They taught me the importance of debugging, code optimization, and effective communication with my peers.

Fast forward to today, I’m a tech lead after learning Golang for just one year, and I’ve become a major lead backend engineer at work. This rapid career progression is not to brag, but to illustrate how Golang can fast-track one’s career and open up new opportunities. The success stories, like mine, showcase the increasing adoption of Golang in various companies and industries, reflecting its robustness and efficiency.

Overall, learning Golang has been a journey of continuous growth, challenging my skills, and offering new opportunities. My advice to anyone starting with Golang is to leverage the community, embrace the learning curve, and take on projects that push your boundaries. It might be challenging at first, but the rewards are worth the effort.

4- Looking Ahead - The Future with Go (Conclusion):

As I look to the future, my aspirations as a Go developer are driven by a deep appreciation for the language’s design philosophy of simplicity and efficiency.

Despite hearing that some tasks require more code in Go compared to other languages, I see this as an opportunity to embrace the clarity and readability that comes with explicitness. For me, the discipline of writing clear, straightforward code aligns with my values as a developer, promoting maintainability and reducing the risk of errors. The growing ecosystem and community support for Go are additional incentives for me to keep developing with this language.

I aim to use Go not only to further my career but also to make a positive impact in my local community. I plan to give talks at meetups about Go, share knowledge with colleagues, and contribute to open-source projects, fostering a collaborative environment where others can learn and grow. I want to inspire the next generation of developers by showing them the power of Go, encouraging them to pursue their dreams in technology, and helping them overcome challenges I once faced.

As I continue my journey with Go, I envision myself taking on more leadership roles, mentoring aspiring developers, and advocating for the language at industry conferences. By sharing my experiences and lessons learned, I hope to inspire others to explore Go and realize its potential. Ultimately, my goal is to make a lasting impact on the tech industry, one line of Go code at a time.

^ back to index

61. Most Expensive Design Mistakes (Ever) and how to avoid them

Abstract

Description

A fantastic User Experience (UX) is what makes the difference when customers choose between one product or another. Considering that, it only makes sense for QAs and UX researchers (UXRs) to join forces and help build great experiences from their own perspectives. Why not have a system that considers the best of both worlds?

As you know, the saying “good design is obvious” is a tale as old as time. As Steve Krug once said, “Your goal should be for each page or screen to be self-evident, so that just by looking at it the average user can say ‘I get it.’”

Takeaways:

How to create effective visual hierarchies

How to avoid reinventing the wheel

How to avoid letting personal feelings take over the process

How to ask the right questions

^ back to index

62. Mastering Software Quality: A Blueprint for Starting Fresh

Abstract

Description

Description:

During this presentation, I will provide practical tips and tools for instilling quality at various levels that align with the reality of your products. We will delve into the realm of skilled exploratory testing to uncover risks that go beyond the obvious. Additionally, we will explore the effective use of tools at different layers, including unit, component, integration, and UI tests, and observability to yield the best possible results, fostering a sense of unity within the team.

I will share the lessons I’ve learned and the pitfalls I’ve encountered during my extensive 10-year journey in the field of quality, working with various development methodologies across diverse products. Over this time, I’ve come to understand the stark contrast between a strong test strategy and a weak one, underscoring the fact that quality begins long before the first line of code is written.

Key Takeaways:

• The distinguishing factors between a strong and a weak test strategy

• How to seamlessly integrate a ‘shift left’ strategy into your team’s process, supported by tools and practical examples

• A candid exploration of what succeeded and what fell short during my journey to embed quality as early as possible.

^ back to index

63. Are quality engineers still necessary in modern ages?

Abstract

Description

Description:

Even though quality is a team responsibility, developers automating tests without the customer’s point of view could end up only ensuring that your code logic is correct. Exploring the customer’s perspectives raising different inputs, and discussing the business problem that we are trying to solve demonstrate that automation is not everything, and there is a lot more to look out for.

Quality is more than simply automating tests, because you can’t test quality into a product; it must be built in. To be able to do so, quality engineers being part of the team create a mental model of your customers including their perspective, their needs and their user experience.

In this talk, I will reveal common misconceptions about the QA role in development teams, showing how Quality Assurance Engineers are fundamental and why they should be an active part of the process to achieve the goals of your product.

Takeways:

Common misconceptions about the QA role in development teams

The role of quality engineering in modern software development methodologies

Building a culture of quality within organizations

^ back to index

64. Go is Good Enough

Abstract

Description

Go has been around a decade, but in the past few years, we come across a point where the Garbage collection and other principles have been contested, declaring it unfit for high-speed/system programming.

For instance, we can consider a high-load network proxy that demands rapid serialisation/deserialisation. In such a case, we can construct and execute a custom network serialiser/deserialiser protocol in Golang, showcasing its practical application.

The ambition is to demonstrate that, more often than not, it’s not the language but our implementation design and algorithms that make something fast and scalable.

And while we do this, we will realise Golang has all the right tools and techniques to help us:

• Build

• Debug

• Profile

• Maintain

highly scalable codebases.

^ back to index

65. Surviving Panics, Fatal Errors, and Crashes: Lessons from the Trenches

Abstract

Description

Ever found yourself in the midst of chaos caused by panics or unexpected crashes? Join me as I share our team’s journey through the wilderness of debugging and resolving critical issues that threatened the stability of our system. In this engaging presentation, we’ll explore the challenges we faced, the lessons we learned, and the strategies we employed to emerge victorious.

With the rollout of a new feature, our system encountered pod crashes triggered by a dreaded “fatal error: concurrent map iteration and map write.” What ensued was a month-long saga of investigation, root cause analysis, and relentless pursuit of solutions. Throughout this ordeal, we discovered invaluable insights that transformed our approach to handling errors and ensuring system resilience.

Our arsenal of survival tactics included:

• Logging, logging, and more logging: Amplifying our logs to capture crucial insights into system behavior.

• Strategic placement of panic recovery: Learning the importance of recovering from panics within the goroutine where they occur.

• The art of reading stack traces: Recognizing the significance of dissecting stack traces, even when they initially seem perplexing.

• Uncovering the hidden impact of non-critical functionality: Understanding how seemingly innocuous components can disrupt critical workflows.

• Distinguishing between fatal errors and panics: Recognizing the distinction between different types of errors and their implications.

• Identifying unrecoverable errors in Go: Gaining awareness of the range of errors that cannot be recovered from in the Go programming language.

By sharing our hard-won wisdom and practical insights, we aim to empower fellow developers to navigate similar challenges with confidence and resilience. Whether you’re a seasoned engineer or a newcomer to the field, this presentation offers invaluable guidance for building robust, reliable applications that stand the test of time.

Join us as we unravel the mysteries of error handling and equip ourselves with the tools and knowledge to overcome any obstacle that comes our way. Let’s transform setbacks into opportunities for growth and emerge stronger together.

^ back to index

66. Maximizing Scalability with Go and Redis: A Telemetry Processing Journey

Abstract

Description

At Delivery Hero, we process a staggering 10,000 requests per second globally, particularly in our critical TIER1 flow, where we handle telemetry data primarily from riders’ phones. In this session, we’ll delve into how we harnessed the power of Go and Redis to handle this high-load, mission-critical system at an incredibly low cost.

Key Points:

Go and Redis as the Perfect Pair: Discover how Go and Redis form the backbone of our telemetry processing infrastructure. Go’s concurrency model and performance complement Redis’s high availability and resilience, enabling seamless handling of our demanding operations.

Efficient Data Management with Redis: Explore how Redis’s versatile features, including sorted lists and key expiration (TTL), enable efficient telemetry data storage, event queue management, and fraud prevention. Learn how Go’s native support for Redis interactions streamlines integration and enhances overall system performance.

Scalability Made Simple: Dive into how Go and Redis effortlessly scale to handle our high-volume telemetry flow. With Go’s lightweight footprint and Redis’s scalability features, such as automatic sharding and replication, we ensure our system remains responsive and reliable, even under peak loads.

Cost-Effectiveness and Resource Optimization: Learn how we achieved cost-effectiveness by leveraging the smallest Redis instances available, strategically deployed across multiple regions. Explore how Go’s efficient resource utilization and Redis’s pay-as-you-go pricing model contribute to significant cost savings without compromising performance.

Customized Data Flows and Experimentation: Our implementation with Redis has opened doors for various experiments, including different location frequency updates, giving us the flexibility to optimise and innovate based on unique service needs.testing different telemetry processing strategies, empowering continuous optimization and innovation.

^ back to index

67. How Regex Works: The Secret Sauce Behind Pattern Matching

Abstract

Description

Ever wondered how regular expressions pull off their magic tricks? Let’s demystify the regex engine together! In this fun talk, we’ll peek under the hood and see how it all works, using something called Non-deterministic Finite Automaton (NFA), or as some like to call it, state machines. Don’t worry, we’ll keep things simple and easy to understand.

The regex engine is like a super-powered detective that’s really good at finding specific patterns in text. But did you know that behind the scenes, it’s using something we all study in universities, called Non-deterministic Finite Automaton (NFA)? It’s a bit like a map that helps the regex engine understand and match patterns efficiently.

Imagine trying to solve a really big puzzle. NFA helps by breaking down complex regex patterns into smaller pieces, or states. Then, all we need to do is follow the map, moving from one state to another until we find our match. It’s like having a guide to lead us through the maze of text, making pattern matching a breeze.

During our adventure, we’ll take a closer look at how the regex engine is put together. We’ll explore concepts like backtracking (when it needs to go back and try a different route), greedy quantifiers (how it decides how much to match), and character classes (the different types of characters it’s looking for). And remember, we’ll explain everything in plain language, so you won’t get lost in technical jargon.

But we won’t stop at just talking about theory. We’re going to dive deeper and take you through the process of building a simple regex matcher right in the presentation. By walking through this hands-on exercise, you’ll get a firsthand look at how the regex engine works in action. By the end of our journey, you’ll have not only a better understanding of regex but also the practical skills and confidence to use it effectively in your own projects.

Whether you’re a beginner or a seasoned coder, this talk will help you unlock the secrets of regex and level up your pattern matching skills. So, join us for a fun and enlightening exploration into the world of regex!

^ back to index

68. Usage of default Golang templating in complex report generation.

Abstract

Sharing experience in solving complex problem of generating reports

• abstract reports from data sources
• prepare MD templates with placeholders pointing to datasource + query + how to present
• execute queries to different sources
• process data: draw graphs, insert raw data
• generate PDF report

Description

At Delivery Hero we have a Reliability Manifesto and in section R-9 It states that all services should be load tested, be able to process at least 4x load rump-up and should be run on regular bases.

During Load Testing we generate a huge amount of monitoring data in different systems: DataDog APM, Prometheus and AWS Cloudwatch.

All this data should be aggregated in one presentable report.

The problem we want to solve:

• How to abstract reports from different metrics sources and different data they provide.

• How to give a flexible and simple instrument to generate templates automatically.

• How to make the lives of our engineers easier.

For instance, in my tribe we have dozens of services, in Logistics we have hundreds of services, In Delivery Hero overall we have thousands of services.

For each of them we need to run load tests on regular bases.

And for each of them we need to generate reports.

The problem of running tests automatically is easy to solve. But how to solve the problem with reporting?

We have an answer, because we designed a tool which helps us to abstract reports from metrics data sources and at the same time keep flexibility of calling different sources with different queries.

You provide a template in a format of Golang templates

{{ ddResult := queryDD .StartTime .EndTime “query” }}



The maximum value of the metric is {{ findMax ddResult }}

Or

{{ promResult := queryProm .StartTime .EndTime “query” }}



{{ drawProm promResult }}

And as the output you receive a generated PDF with either text “The maximum value of the metric is XX” or drawn graph from Prometheus.

All these queryDD, findMax, queryProm and drawProm are predefined template.Funcs and empower great flexibility of your report.

I will be talking about how to implement these functions, how to call different sources, process data and render outputs.

^ back to index

69. NATS for Go Beginners: Build Scalable Systems with Ease

Abstract

Description

^ back to index

70. Evil Tech: How Devs Became Villains

Abstract

Description

Once upon a time, developers were the unsung heroes of our world. The stereotypical developer, with glasses perched on the nose and an innate talent for science, even inspired the alter egos of superheroes.

However, today, software engineers often find themselves under scrutiny for their roles in creating data-gathering apps, facial recognition software in CCTV systems, and the constant tracking of citizens through GPS, among other issues.

From being heroes to becoming modern-day Dr. Frankensteins, tech creators face an unenviable dilemma: to embrace malevolence or strive for heroism.

During this talk, we will delve deep into the complex relationship between technology and ethics, and explore how developers navigate the fine line between progress and principles.

This is our villain’s origin story, told with a touch of dark humor.

^ back to index

71. Turn Your Home into a Discotheque, with Go!

Abstract

Description

Embark on a guided tour of DISCO: the Domestic Illumination System Control Operator. A simple and robust text protocol that makes IoT smart lights fun for programmers. A novel approach using pure Go and almost exclusively standard library. Buckle up for a wild ride through the breaking changes, the endless refactors, the trials, the heartbreaks, the decisions made and lessons learned over 5 years of development.

Prepare to go hand to hand with Phillips and LIFX lights over your local network. Brush over a lightweight HTTP API wrapper. Dive down from the application to the transport layer for a taste of UDP packet wrangling. Brace yourself for color math! Know the difference between RGB, HSV, and CIE/XY color spaces, how to convert between them, when and how to use them. Discover the joy of gamut bounding. Delve into techniques for color scheme generation.

^ back to index

72. Peak Performance with Profile-Guided Optimization in Go!

Abstract

Description

In the talk, we will unlock the full potential of Go applications with Profile-Guided Optimization (PGO), which is a compiler optimization technique that helps with optimizing software based on runtime statistics. This talk delves into how Go developers can harness runtime profiling to achieve next-level performance enhancements. We’ll explore the complete PGO workflow in Go, from building instrumented binaries to collecting comprehensive runtime profiles, and using this data to inform the Go compiler for smarter optimizations.

Through hands-on demonstrations and practical examples, I’ll show you how to apply PGO to various Go applications, ensuring you leave with actionable insights and best practices to turbocharge your Go projects with minimal effort and maximum impact. Whether you’re working on microservices, large-scale systems, or performance-critical applications, this session will equip you with the knowledge and tools to elevate your Go applications to new heights of efficiency and speed.

^ back to index

73. Benchmarking, Profiling and Tracing in Go: Elevating Performance and beating 'deadcode'

Abstract

Description

In “Benchmarking, Profiling and Tracing in Go: Elevating Performance and beating ‘deadcode’”, we will dive deep into Go’s powerful toolkit for performance analysis, focusing on maximizing application efficiency. This talk will start with crafting precise benchmarks using Go’s testing package to measure function execution times under various conditions. We’ll explore CPU and memory profiling with Go’s pprof tool to pinpoint performance bottlenecks and identify high memory usage patterns. We will also dive into runtime/trace package to generate detailed execution traces for goroutines and visualize them with gotraceui tool. Additionally, we will also evaluate the power of ‘deadcode’ tool to find unreachable functions that imposes maintenance effort.

I will also demonstrate block profiling to understand contention in goroutines and integrating go tool trace for detailed visualization of goroutines, network calls, and system calls, and how to effectively use tools like go-torch for flame graphs to simplify profiling data interpretation.

Attendees will leave equipped with strategies to implement benchmarking, profiling and tracing in their Go applications development process.

^ back to index

74. Making non-Go tools accessible to Go developers using WebAssembly

Abstract

Description

With Go’s ease of cross-compilation and simplicity of otherwise using go run to automatically compile and run, we are seeing many new developer tools being written in Go. However, there are still plenty of necessary tools written in other languages, such as protoc (C++) or sql-formatter (TypeScript). This is even more so in codebases that are mostly, but not completely, Go, for example when a frontend is written in TypeScript and an ML backend is written in Python. gRPC users need to generate stubs in all of these languages, juggling between OS package managers, NPM, and more. Notably, reliance on OS package managers make it very difficult for a build to be reproducible across developer machines.

Luckily, we now have a cross-platform bytecode format, WebAssembly. If we compile C++ to WebAssembly, or compile a JS runtime such as QuickJS to WebAssembly, we can use the pure Go WebAssembly runtime, wazero, to bring tools written in these other languages to Go.

This talk will begin by explaning the concept of reproducible builds, why they are helpful (to reduce mysterious debugging), and how they can be achieved when able to completely stick to Go tools.

Then it will go through several tools that otherwise are tricky to install, not being in Go, but made trivial by packaging WebAssembly versions.

• protoc / protoc-gen-grpc - C++ binaries, with the latter not even providing downloadable precompiled binaries to try to wire into a build

• protoc-gen-es - NodeJS binary, which normally requires using NPM to download the packages and dependencies to run

And more protoc plugins written in languages including Python, Rust, Swift, and Zig.

When using Buf to orchestrate a protobuf build and using versions of the above packaged as Go binaries via Wasm, we can generate to all of C++, Python, Ruby, TypeScript, Go, and more, all with go run invocations, no developer tool installation required at all.

• sql-formatter - NodeJS binary, which normally require using NPM to download the packages and dependencies to run. The NodeJS binary can continue be used by IDEs, such as with the VSCode plugin, while CI or CLI invocation can use the Go distribution to produce the exact same result - it’s the same code

• yamllint / prettier - a Python binary to lint yaml files and a NodeJS binary to format various files such as yaml and markdown. Go projects will still often have these other file formats and we can lint and format them in a way that matches IDE integrations

• sqlc - a Go binary that normally uses cgo to access PostgreSQL parser. This can cause slow build times and log spam on MacOS updates. Using the parser compiled to Wasm, we bring sqlc to go run with no gotchas

While mentioning go run frequently for installation-free invocation, for those that prefer go install naturally runs fine. And because Go binaries can be cross-compiled trivially, all of these tools are available with precompiled binaries for major platforms, all built from a normal Linux GitHub CI runner. There is no need for complicated runner setup as would be needed if compiling the C++ sources directly to these platforms

By the end of the presentation, the audience will understand reproducible builds and why they are important. They’ll see many tools that were out of reach behind bespoke package managers ported to Go using WebAssembly and be able to use these tools right away in their builds - after all, they already have Go installed.

^ back to index

75. Unit Testing : an afterthought or an absolute necessity ?

Abstract

Description

You should write tests at the same time as you write your code.

• Dave Cheney

But can we ?

1. Do we need to care about unit testing [3 min]

a. Tight deadline

b. Let the QA handle it through integration, acceptance testing

c. I don’t get paid for it

d. I don’t have time to write test

e. We will see when we need more codacy grades

f. Let’s just write basic unit test for path(cover the lines not logic)

2. The cost of not writing unit test [4 min]

a. Bugs

b. Sacrificing the reliability of code

c. Stability and maintainability of application

d. Loosing confidence on the complex code

e. Future development requiring more time to production

f. Increased collaboration

i. Other people working on it

g. Would have served as a technical documentation

3. Test Methodology and writing testable code [2 min]

4. Using GenAI to generate code [2 min]

a. Copilot

b. Bito

5. Going beyond 100% coverage (with example) [2 min]

a. Not lines but actual logical scenarios

6. Coverage Report [1 min]

7. Testing Painful function (with example)

a. Function having no return argument (assert) [1 min]

b. HTTP (httptest) [1 min]

c. Complex struct [2 min]

d. Dependency (gomock,interface) [2 min]

e. Test function having go routine [2 min]

f. Channel output

g. Sync based unit test cases

8. Conclusion [2 min]

a. The more testing you do, the more money you save on long run

b. Which test library to choose

c. Prefer table driveen test

d. Testing All The Things - Rabbit hole

“A software system can best be designed if the testing is interlaced with the designing instead of being used after the design.”

-Alan Perlis, NATO Softare Engineering Conference, 1968 (source https://www.infog.com/presentations/11-2-6-8)

^ back to index

76. Processing 40 TB of code from ~10 million projects with a dedicated server and Go for $100

Abstract

Description

I have a lot of this content lying around from various blog posts, so nothing needs to be created here other than to get the content into a nice visible thing.

Learn why using AWS was not the right approach here, and how we ended up processing millions of repository to find the answers to such questions as,

YAML vs YML? Which group of developers have the biggest potty mouth? How many files does an average repository have? How many lines of code are in a typical file per language? How many repositories appear to be missing a license? Why does that even matter?!

And more!

^ back to index

77. Abusing Go, AWS Lambda and bloom filters to make a true Australian serverless search engine

Abstract

Description

I have a lot of this content lying around from blog posts and as such don’t need anything new here I would want to start by testing the theory, then walking through the idea, and then showcasing in order

• Implementing an index using bloom filters which we can embed into the binary
• Early termination logic
• Crawling the data
• Ranking algorithms
• Adult content detection
• Snippet extraction (this could be its own talk honestly… so much)
• Indexing
• Architecture in AWS
• Results

Portions of it could easily be cut such as adult content and such, but you never know, it might be worth mentioning. I

^ back to index