In the Cloud Native ecosystem there is a fundamental lack of forensics analysis tooling that pair in concert with incident response techniques. In other words it's challenging not only to make sense of a stream of forensics data, but to respond to it in a meaningful way.
In this presentation we explore the unique constraints of running a low level forensics analysis and incident response engine in a multilcloud environment. We look at how auditing at the kernel level frees us from having to concern ourselves with how our applications are running.
Finally we look at breaking into an environment and escaping the boundaries of a pod to gain access to the host system. In this example we watch as the Falco security engine can detect this malicious behavior and take action in responding to it at runtime.
In this talk, we will share our story of why Oracle chose to rewrite a 10-year old huge monolith in C++, which handles more than 100MM in revenue and billions of requests per day in Golang, and war stories on how Golang performs in complex real world scenarios.
How does Go's reflection work and what can you do with it?
In this talk, we will deep dive into go's `reflect` package internals and review practical use-cases for using it.
This talk will dive into how we rewrote one of our production services to Golang, leveraging Go's native proxy implementations and routines, alongside its async capabilities for improved scale and throughput of core web services, enabling exponentially improved performance.
In this talk we will review Domain Driven Design briefly, and concentrate on how to apply that approach to building microservices in Go.
My focus will be on providing an array of best practices to allow the developer to build microservices that are easy to extend and maintain.
Many developers are using Go IDEs daily. But these developers are less familiar with Go tools that empower above IDEs and come other useful Go tools.
We used Go to build an advanced monitoring system for AT&T’s Mobility Network. Lossless real-time processing of 100s of Gbps of traffic generated by 150M devices is challenging. We had to use every trick in the book and a lot of creativity to understand and overcome performance challenges.
Profiling applications should be a fundamental part of developers' work, but unfortunately it is usually not. This talk gives the highlights on Go's builtin tools for profiling and debugging in runtime: go tool pprof / trace, expvar. Will include code examples & live demos, focusing on web apps.
In this talk I'll about the main differences between Go and Rust, when should we use each one of them and talk about hybrid solutions.
We will go over real world system and understand the problem and decisions that made them pick Rust / Go or Hybrid solutio
Fuzzing or fuzz testing is an automated software testing technique that involves providing semi-random data as input to test programs.
We will discuss how fuzzing helps with security, stability and performance in Go. As well as how to integrate it into the CI and overcome challenges.
This talk will cover different aspects about the context package in Go. We'll discuss the need for a context mechanism and how it is addressed in other languages. We'll walk through some best practices when using the context interface, do's and don'ts, and we`ll learn how to use it to decrease load.
I share my experiences from integrating probabilistic programming into a server-side software and implementing a probabilistic programming facility for Go, http://infergo.org/. I discuss the challenges and suggest guidelines for adoption of probabilistic programming in server-side software.
Apache Arrow is a cross-language development platform for in-memory data. It specifies a standardized language-independent columnar memory format for flat and hierarchical data. I co-created with Miki Tebeka a wrapper for Go around the C++ lib using cgo and I would like to share my insights.
Something that came out of the discussion around the debacle of try
earlier in the year was a comment that Peter Bourgon made on the
GoTime podcast where he suggested that Go should have a set of values.
His specific example was "error handling should be explicit". This
comment stuck with me and interacted with a comment that Daniella
Petriziliack made around the same time. Both of their comments pointed
me back to PEP-20, the Zen of Python. My idea is to work from that
document as a foundation and try to suggest some values that are
foundational to all Go programs.
Come and geek out with fellow Gophers. Drinks & snacks are on us!