developedbyed·1yData Structures and Algorithms Crash Course
This course introduces the fundamentals of data structures and algorithms with a focus on Big O notation, linear search, and binary search. It provides a step-by-step guide to implementing these algorithms in code and explains their time complexities. The course also touches on constant time operations and compares different approaches to searching arrays.
codeHeim·1y#69 Golang - Mastering Bloom Filters
Bloom filters are probabilistic data structures used to check if an element is part of a set quickly and with minimal memory usage. They guarantee no false negatives but allow false positives. Ideal for caching and pre-filtering large datasets, bloom filters can reduce unnecessary database queries in web applications. The post details how to install and implement a bloom filter in a Golang-based web app for checking user access to features, along with parameter estimation for optimizing performance.
Taro·1yInsights from an ex-Googler who has taught 1000s of Engineers about DSA interviews
Alvin Zablan, an ex-Google engineer, emphasizes the importance of a well-structured learning roadmap for mastering data structures and algorithms (DSA). He suggests focusing deeply on core concepts like DFS, BFS, dynamic programming, recursive backtracking, and the two-pointer technique. The 80/20 rule is highlighted for effective learning, advocating thorough understanding over superficial practice. Zablan advises learning before practicing and practicing mindfully to truly grasp DSA skills.
Lobsters·1yWhy Golang slices still surprise me
Golang slices have dual behavior, acting as either dynamically sized arrays or fat pointers, which can cause confusion and bugs. Dynamic arrays own their data, while fat pointers do not, making some operations like appending invalid depending on the context. The capacity field in slices introduces surprising behaviors like reslicing beyond the length and modifying capacity, contradictory to Go's minimalist philosophy.
Hacker News·1yThe RAM myth
Commonly used straightforward algorithms for data sharding may perform suboptimally due to frequent cache misses. By sorting elements by their group before processing, one can significantly reduce cache misses, improving performance even with large in-memory data. Radix sort and other cache-aware algorithms offer further optimizations. These techniques are beneficial for handling big data where efficient memory usage is critical.
