https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Return to Golang, Algorithms, Golang Data Structures Performance Glossary, Golang Algorithms Performance Glossary, Web Performance Glossary, JVM Performance Glossary, Java Performance Glossary, Golang Performance Glossary, Rust Performance Glossary, Python Performance Glossary, JavaScript Performance Glossary, CPP Performance Glossary, Network Performance Glossary, Database Performance Glossary, Storage Performance Glossary, Linux Performance Glossary, Windows Server Performance Glossary, macOS Performance Glossary, Glossaries, Systems Performance, 2nd Edition, Performance Bibliography, Systems Performance, Performance DevOps, IT Bibliography, DevOps Bibliography

“ (SysPrfBGrg 2021)

Slices in Go are dynamically-sized arrays that provide flexibility by automatically resizing as elements are added. They are widely used for their performance benefits in terms of memory allocation and iteration, but careful management is needed to avoid excessive copying or resizing, which can degrade performance. https://golang.org/doc/effective_go#slices

Maps in Go are hash tables that store key-value pairs, providing average O(1) time complexity for lookups and inserts. Maps are efficient for fast lookups, but poor key distribution or high memory fragmentation can lead to performance issues, particularly in high-concurrency environments. https://golang.org/doc/effective_go#maps

Structs are user-defined types in Go that group fields together. Structs offer efficient memory usage since fields are stored contiguously in memory, but improper field ordering or alignment can lead to increased memory overhead due to padding between fields. https://golang.org/doc/effective_go#structs

Arrays in Go are fixed-size collections of elements of the same type. While arrays provide fast access and iteration with low memory overhead, their static nature makes them less flexible than slices, limiting their usefulness in programs that require dynamic resizing. https://golang.org/ref/spec#Array_types

Linked Lists can be implemented in Go using structs that store references (pointers) to other nodes. Although linked lists provide efficient insertions and deletions, their use in Go is often discouraged due to poor cache locality and higher memory overhead compared to arrays or slices. https://en.wikipedia.org/wiki/Linked_list

Sync.Map is a specialized concurrent map implementation in Go's sync package, designed to handle multiple goroutines accessing the map simultaneously without explicit locking. Sync.Map performs well under high-concurrency situations but may be less efficient than regular maps for single-threaded use cases. https://golang.org/pkg/sync/#Map

Heap in Go refers to the portion of memory where dynamically allocated objects are stored. The Go runtime uses garbage collection to manage heap memory, and excessive heap allocations can increase GC pressure, leading to performance degradation. https://golang.org/doc/go1.5#garbage_collection

Trees such as binary search trees or AVL trees can be implemented in Go using structs and pointers. Trees offer efficient sorting and searching operations (O(log n)), but poor balancing or skewed data distributions can lead to inefficient performance, particularly in unbalanced trees. https://en.wikipedia.org/wiki/Tree_structure

Queues in Go can be implemented using slices or linked lists, providing efficient FIFO (first in, first out) access patterns. Depending on the implementation, queues can suffer from inefficient memory usage if frequent resizing or excessive pointer dereferencing occurs. https://en.wikipedia.org/wiki/Queue_(abstract_data_type)

Stack is a data structure that operates on a LIFO (last in, first out) basis, typically implemented using slices or arrays in Go. Stacks are simple and fast for push/pop operations, but performance can degrade if memory reallocation is needed frequently for dynamic stacks. https://en.wikipedia.org/wiki/Stack

Binary Search is an efficient search algorithm that operates on sorted arrays or slices in Go. With a time complexity of O(log n), binary search is much faster than linear search for large datasets, but it requires the data to be sorted beforehand, adding overhead if the data is not already ordered. https://en.wikipedia.org/wiki/Binary_search_algorithm

Ring Buffer is a circular data structure that uses a fixed-size buffer, allowing efficient overwriting of old data as new data is added. In Go, the ring buffer is useful for implementing bounded queues and managing memory efficiently without reallocating, but it requires careful handling of read and write pointers. https://en.wikipedia.org/wiki/Circular_buffer

B-Trees are balanced search trees optimized for systems that read and write large blocks of data, such as databases. In Go, B-trees provide efficient range queries and insertions, but they require careful balancing to maintain their O(log n) performance for searches, insertions, and deletions. https://en.wikipedia.org/wiki/B-tree

Radix Trees or prefix trees store strings or binary data in a compact form by sharing common prefixes. In Go, radix trees are often used for routing tables in web frameworks, offering fast lookups for matching string keys with efficient memory usage. https://en.wikipedia.org/wiki/Radix_tree

Skip Lists are probabilistic data structures that allow fast search, insertion, and deletion operations, with time complexities similar to balanced trees. In Go, skip lists can be used as an alternative to trees, providing simpler balancing with good performance under random insertion patterns. https://en.wikipedia.org/wiki/Skip_list

Hash Tables in Go are used to implement maps and provide average O(1) time complexity for lookups and insertions. However, hash table performance can degrade due to collisions or poor hash functions, leading to longer search times as the number of elements increases. https://en.wikipedia.org/wiki/Hash_table

Doubly Linked Lists extend the functionality of singly linked lists by allowing traversal in both directions. In Go, doubly linked lists are useful when frequent insertions or deletions at both ends are needed, but they come with higher memory overhead due to the extra pointer storage. https://en.wikipedia.org/wiki/Doubly_linked_list

Priority Queues are specialized queues where each element has a priority, and elements are dequeued based on their priority. In Go, priority queues are often implemented using heaps, providing efficient access to the highest-priority elements, though maintaining heap structure adds overhead. https://en.wikipedia.org/wiki/Priority_queue

Bloom Filters are probabilistic data structures used to test whether an element is a member of a set, allowing false positives but no false negatives. Go can use Bloom filters for fast, memory-efficient membership testing, though performance can degrade as the false positive rate increases. https://en.wikipedia.org/wiki/Bloom_filter

Graph Data Structures represent networks of nodes connected by edges. In Go, graphs are used in applications like social networks and routing algorithms, where operations such as traversals or shortest path computations are common. Performance depends on the implementation, whether using adjacency lists or matrices. https://en.wikipedia.org/wiki/Graph_(abstract_data_type)

Sparse Arrays are arrays where most of the elements are empty or zero, allowing memory to be saved by storing only non-zero elements. In Go, sparse arrays can be implemented using maps to store indices and values, providing efficient memory usage, especially when the array size is large but sparsely populated. https://en.wikipedia.org/wiki/Sparse_array

Trie is a type of search tree used to store dynamic sets of strings, where the keys are usually strings. In Go, tries are useful for applications like autocompletion or searching, offering efficient search times that depend on the length of the string rather than the number of stored elements. https://en.wikipedia.org/wiki/Trie

Cuckoo Hashing is a collision resolution technique for hash tables, where an element is placed in one of two possible locations and moved if necessary. In Go, cuckoo hashing can be used to achieve constant-time lookups, though it requires careful management of hash functions to avoid excessive rehashing. https://en.wikipedia.org/wiki/Cuckoo_hashing

Deque (double-ended queue) is a data structure that allows insertion and deletion of elements from both ends. In Go, deques are useful when both stack and queue behaviors are needed, providing flexible access patterns but requiring efficient resizing strategies to maintain performance. https://en.wikipedia.org/wiki/Double-ended_queue

Fenwick Tree or binary indexed tree is a data structure that provides efficient methods for cumulative frequency tables. In Go, Fenwick trees are used to perform point updates and prefix sum queries in logarithmic time, often applied in algorithmic challenges and data analysis. https://en.wikipedia.org/wiki/Fenwick_tree

Immutable Data Structures in Go refer to data structures that do not change after they are created. This is especially important for concurrent programming, as immutable data structures prevent race conditions by ensuring data consistency without locks, though they may introduce overhead due to copying. https://en.wikipedia.org/wiki/Persistent_data_structure

Rope Data Structure is a tree-like structure used to store and manipulate large strings efficiently. In Go, ropes are useful for applications that involve frequent string concatenation or slicing, offering better performance than naive string operations for very large strings. https://en.wikipedia.org/wiki/Rope_(data_structure)

Treap is a hybrid data structure that combines a binary search tree and a heap. In Go, treaps are used to maintain a sorted list of elements while allowing fast insertion, deletion, and random access, making them a versatile option for dynamic sets. https://en.wikipedia.org/wiki/Treap

AVL Tree is a self-balancing binary search tree where the heights of subtrees differ by at most one. In Go, AVL trees provide guaranteed O(log n) time for insertions, deletions, and lookups, but the rebalancing operations add complexity and overhead compared to unbalanced trees. https://en.wikipedia.org/wiki/AVL_tree

Red-Black Tree is a balanced binary search tree with properties that ensure the tree remains approximately balanced after insertions and deletions. Go implementations of red-black trees offer O(log n) time for search, insertion, and deletion, making them ideal for scenarios where sorted data and efficient operations are required. https://en.wikipedia.org/wiki/Red%E2%80%93black_tree

Heap Data Structure is a specialized tree-based data structure that satisfies the heap property, where the parent node is either greater than or less than its children. In Go, heaps are used to implement priority queues, offering O(log n) performance for insertion and extraction, making them efficient for scheduling tasks or managing resource allocation. https://en.wikipedia.org/wiki/Heap_(data_structure)

Splay Tree is a self-adjusting binary search tree where recently accessed elements are moved to the root. In Go, splay trees provide fast access to frequently used elements, but less predictable performance for other operations, making them suitable for certain workloads with localized access patterns. https://en.wikipedia.org/wiki/Splay_tree

Min-Heap is a type of heap where the parent node is always less than or equal to its children. In Go, min-heaps are used to implement priority queues where the smallest element is always at the root, providing efficient access to the smallest element in O(1) time and O(log n) for insertions. https://en.wikipedia.org/wiki/Min-max_heap

Sparse Matrix is a matrix in which most of the elements are zero. Sparse matrices in Go can be represented using maps or specialized data structures, providing efficient memory usage and computational performance in cases where non-zero elements are sparse. https://en.wikipedia.org/wiki/Sparse_matrix

Bloom Filter is a probabilistic data structure used to test whether an element is a member of a set, allowing false positives but no false negatives. In Go, bloom filters are used in applications like database query optimization and network packet filtering, providing memory-efficient membership testing. https://en.wikipedia.org/wiki/Bloom_filter

Interval Tree is a data structure designed to efficiently find all intervals that overlap with any given interval or point. In Go, interval trees are used in applications like computational geometry or scheduling, providing O(log n) performance for insertion, deletion, and query operations. https://en.wikipedia.org/wiki/Interval_tree

Fibonacci Heap is a heap data structure consisting of a collection of trees, used to improve the time complexity of certain operations. In Go, Fibonacci heaps offer O(1) amortized time for insertions and O(log n) for deletions, making them efficient for graph algorithms like Dijkstra’s shortest path. https://en.wikipedia.org/wiki/Fibonacci_heap

Quad Tree is a tree data structure where each internal node has exactly four children, used to partition a two-dimensional space. In Go, quad trees are effective for spatial indexing, collision detection, and range queries, offering logarithmic search time for points in a plane. https://en.wikipedia.org/wiki/Quadtree

Disjoint-Set Union (Union-Find) is a data structure that tracks a set of elements partitioned into disjoint (non-overlapping) subsets. In Go, disjoint-set operations like union and find are used in network connectivity, clustering, and graph algorithms, providing nearly constant time complexity through path compression and union by rank. https://en.wikipedia.org/wiki/Disjoint-set_data_structure

Segment Tree is a tree data structure used for storing intervals or segments, and allows efficient queries like range minimum, maximum, or sum. Segment trees in Go are widely used in competitive programming and real-time data analytics, providing O(log n) time for both queries and updates. https://en.wikipedia.org/wiki/Segment_tree

Trie (Prefix Tree) is a tree-like data structure used to store a dynamic set of strings where keys are typically strings. In Go, tries are efficient for prefix matching and autocomplete functionality, providing O(k) time complexity where k is the length of the string. https://en.wikipedia.org/wiki/Trie

K-D Tree is a binary tree used for organizing points in a k-dimensional space. Go implementations of k-d trees are useful for spatial searches such as nearest neighbor searches and range queries, offering O(log n) performance for search operations in balanced trees. https://en.wikipedia.org/wiki/K-d_tree

Count-Min Sketch is a probabilistic data structure that provides approximate counts of elements in a data stream, with a trade-off between accuracy and memory usage. In Go, count-min sketches are used in network traffic analysis, frequency counting, and database optimizations. https://en.wikipedia.org/wiki/Count%E2%80%93min_sketch

R-Tree is a tree data structure used for indexing multi-dimensional information, commonly used in spatial databases. In Go, r-trees offer efficient querying of spatial data such as geographical coordinates, allowing fast insertions and deletions while maintaining query performance. https://en.wikipedia.org/wiki/R-tree

Van Emde Boas Tree is a tree data structure that provides fast lookups, insertions, and deletions for integer keys within a bounded range. Van Emde Boas trees in Go are used in applications requiring fast operations on bounded ranges, with O(log log U) time complexity for U possible keys. https://en.wikipedia.org/wiki/Van_Emde_Boas_tree

Splay Tree is a self-adjusting binary search tree where frequently accessed elements are moved closer to the root, improving access time for frequently used elements. In Go, splay trees are useful for workloads with non-uniform access patterns, as recently accessed elements become faster to retrieve. https://en.wikipedia.org/wiki/Splay_tree

Self-Balancing Binary Search Trees are trees that automatically keep their height balanced to ensure that operations like insertion, deletion, and lookup remain O(log n). In Go, popular implementations include AVL trees and red-black trees, both of which maintain balance to provide consistent performance. https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree

Treap is a randomized binary search tree that also maintains heap properties. In Go, treaps combine both binary search tree and heap properties to ensure balanced tree structures with randomized balancing, offering O(log n) performance for insertion, deletion, and search operations. https://en.wikipedia.org/wiki/Treap

Dynamic Array is an array that automatically resizes itself when its capacity is exceeded. In Go, slices function as dynamic arrays, allowing efficient memory management and array resizing behind the scenes, but performance can degrade if frequent resizing is required. https://en.wikipedia.org/wiki/Dynamic_array

Union-Find Data Structure is used for efficient management of disjoint sets and is critical in Go for solving problems related to connectivity, such as finding connected components in graphs. It supports two operations: union and find, both of which can be optimized with path compression and union by rank to offer nearly constant time complexity. https://en.wikipedia.org/wiki/Disjoint-set_data_structure

Max-Heap is a variant of the heap data structure where the parent node is always greater than or equal to its children. In Go, max-heaps are used to implement priority queues where the largest element is always at the root, allowing efficient access to the maximum element in O(1) time, and O(log n) for insertions and deletions. https://en.wikipedia.org/wiki/Heap_(data_structure)

Sparse Set is a data structure used to efficiently store and retrieve a subset of integers from a larger range. In Go, sparse sets are particularly useful when tracking active elements within a large but mostly empty domain, offering O(1) time complexity for insertions, deletions, and lookups. https://en.wikipedia.org/wiki/Sparse_set

Huffman Tree is a type of binary tree used for lossless data compression algorithms like Huffman coding. In Go, Huffman trees are used for encoding symbols based on their frequencies, providing efficient storage by assigning shorter codes to more frequent symbols and longer codes to less frequent ones. https://en.wikipedia.org/wiki/Huffman_coding

Bloom Filter with Counting is an extension of the standard Bloom filter that allows elements to be deleted by maintaining a count of occurrences. In Go, counting bloom filters are used in scenarios where both insertion and deletion of elements are necessary, such as in caching and network traffic monitoring. https://en.wikipedia.org/wiki/Counting_Bloom_filter

Segmented Sieve is an algorithm used for finding all prime numbers up to a large number, particularly useful when the input range is large. In Go, segmented sieves are implemented for efficient prime number generation, dividing the range into smaller segments to reduce memory usage and improve cache performance. https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes#Segmented_sieve

Cartesian Tree is a binary tree derived from a sequence of numbers that serves both as a binary search tree and a heap. In Go, cartesian trees are used for range queries and for maintaining sorted sequences, providing efficient performance for both minimum and maximum queries on subarrays. https://en.wikipedia.org/wiki/Cartesian_tree

Persistent Data Structures are data structures that preserve previous versions of themselves when modified. In Go, persistent data structures are useful in applications like version control systems and undo operations, where past states need to be retained without duplicating the entire structure. https://en.wikipedia.org/wiki/Persistent_data_structure

Binomial Heap is a heap data structure that supports quick merging of two heaps. In Go, binomial heaps are useful for implementing priority queues in distributed systems or parallel computing environments, where merging operations between heaps occur frequently. https://en.wikipedia.org/wiki/Binomial_heap

Xor Linked List is a memory-efficient variation of a doubly linked list where nodes store the XOR of the addresses of their previous and next nodes instead of storing both pointers. In Go, xor linked lists can be used to reduce memory overhead, but require careful pointer manipulation to navigate the list. https://en.wikipedia.org/wiki/XOR_linked_list

Dynamic Segment Tree is a variation of the segment tree that allows for efficient insertion and deletion of segments. In Go, dynamic segment trees are used in applications like interval queries, handling ranges that change over time with O(log n) performance for updates and queries. https://en.wikipedia.org/wiki/Segment_tree

Fair Use Sources:

• B08J5QZPNC (SysPrfBGrg 2021)

Golang Programming Language, Golang Compiler, Golang Go Toolchain, Golang Go Command, Golang Module System, Golang Goroutine, Golang Channel, Golang Package, Golang Import Path, Golang GOPATH, Golang GOROOT, Golang Go Mod File, Golang Go Sum File, Golang go.mod Syntax, Golang go.sum Integrity, Golang Main Package, Golang Main Function, Golang Func Keyword, Golang Struct Type, Golang Interface Type, Golang Map Type, Golang Slice Type, Golang Array Type, Golang String Type, Golang Rune Type, Golang Byte Type, Golang Error Interface, Golang Custom Error, Golang Defer Keyword, Golang Panic Function, Golang Recover Function, Golang Concurrency Model, Golang WaitGroup, Golang Mutex, Golang RWMutex, Golang Sync Package, Golang Context Package, Golang WithCancel Function, Golang WithTimeout Function, Golang WithDeadline Function, Golang WithValue Function, Golang Interface{} Type, Golang Empty Interface, Golang Type Assertion, Golang Type Switch, Golang Goroutine Scheduler, Golang Garbage Collector, Golang Race Detector, Golang gofmt Tool, Golang golint Tool (deprecated), Golang go vet Tool, Golang gopls Language Server, Golang go test Command, Golang go build Command, Golang go run Command, Golang go get Command, Golang go install Command, Golang go generate Command, Golang go clean Command, Golang go list Command, Golang go doc Command, Golang go fix Command, Golang go mod tidy Command, Golang go mod vendor Command, Golang go mod download Command, Golang go work File, Golang Module Proxy, Golang GOSUMDB Environment Variable, Golang GOPROXY Environment Variable, Golang GOPRIVATE Environment Variable, Golang Vendor Directory, Golang Vendoring, generate Directive, embed Directive, Golang Internal Packages, Golang Init Function, Golang Build Constraints, Golang build tags, Golang cgo Integration, Golang cgo Comment Syntax, Golang CGO_ENABLED Flag, Golang cgo Linking, linkname Directive, Golang Testing Package, Golang Test Function Convention, Golang Benchmark Function Convention, Golang Example Function Convention, Golang testing.T, Golang testing.B, Golang testing.M, Golang testing.Run, Golang testmain Generation, Golang Coverage Profiling, Golang CPU Profiling, Golang Memory Profiling, Golang Block Profiling, Golang Mutex Profiling, Golang Trace Tool, Golang pprof Tool, Golang net/http/pprof Package, Golang net/http Package, Golang http.ListenAndServe, Golang http.Handler Interface, Golang http.HandlerFunc Type, Golang http.ServeMux, Golang http.Client, Golang http.Transport, Golang http.RoundTripper, Golang http.Cookie, Golang URL Parsing, Golang URL Values, Golang JSON Encoding/Decoding, Golang encoding/json Package, Golang Marshal Function, Golang Unmarshal Function, Golang json.RawMessage, Golang YAML Integration (third-party), Golang TOML Integration (third-party), Golang XML Encoding/Decoding, Golang encoding/xml Package, Golang CSV Encoding/Decoding, Golang encoding/csv Package, Golang ProtoBuf Integration (third-party), Golang gRPC Integration (Go Module), Golang RPC Package (net/rpc), Golang Bufconn (grpc testing), Golang gob Encoding Package, Golang tar Package, Golang zip Package, Golang fmt Package, Golang Printf Function, Golang Println Function, Golang Sprint Function, Golang Sprintf Function, Golang Errorf Function, Golang log Package, Golang log.Printf, Golang log.Fatal, Golang log.Panic, Golang log.SetFlags, Golang log.SetOutput, Golang log.Ldate, Golang log.Ltime, Golang log.Lmicroseconds, Golang log.Llongfile, Golang log.Lshortfile, Golang log.LUTC, Golang io Package, Golang io.Reader Interface, Golang io.Writer Interface, Golang io.Closer Interface, Golang io.ReadCloser, Golang io.WriteCloser, Golang io.ReadSeeker, Golang io.ReadWriteCloser, Golang io.Copy Function, Golang io.TeeReader, Golang io.LimitedReader, Golang io.Pipe, Golang bufio Package, Golang bufio.Reader, Golang bufio.Writer, Golang bufio.Scanner, Golang Scanner.Split, Golang bufio.ReadString, Golang bufio.ReadBytes, Golang ioutil Package (deprecated), Golang io/fs Package, Golang fs.File Interface, Golang fs.FS Interface, Golang os Package, Golang os.File Type, Golang os.Open Function, Golang os.Create Function, Golang os.Stat Function, Golang os.Remove Function, Golang os.Rename Function, Golang os.Mkdir Function, Golang os.Chdir Function, Golang os.Getenv Function, Golang os.Setenv Function, Golang os.Exit Function, Golang os.Getpid Function, Golang os.Getppid Function, Golang os.UserHomeDir Function, Golang runtime Package, Golang runtime.GOMAXPROCS, Golang runtime.NumGoroutine, Golang runtime.Caller, Golang runtime.Callers, Golang runtime.Stack, Golang runtime/debug Package, Golang runtime.ReadMemStats, Golang runtime.GC, Golang reflect Package, Golang reflect.Type, Golang reflect.Value, Golang reflect.Kind, Golang reflect.StructField, Golang reflect.Method, Golang reflect.DeepEqual, Golang reflect.ValueOf, Golang reflect.TypeOf, Golang reflect.SliceOf, Golang reflect.MapOf, Golang reflect.ChanOf, Golang reflect.New, Golang reflect.Indirect, Golang reflect.MakeFunc, Golang sync.WaitGroup, Golang sync.Mutex, Golang sync.RWMutex, Golang sync.Once, Golang sync.Cond, Golang sync.Pool, Golang atomic Package, Golang atomic.AddInt32, Golang atomic.AddInt64, Golang atomic.AddUint32, Golang atomic.AddUint64, Golang atomic.AddUintptr, Golang atomic.LoadInt32, Golang atomic.LoadInt64, Golang atomic.LoadUint32, Golang atomic.LoadUint64, Golang atomic.StoreInt32, Golang atomic.StoreInt64, Golang atomic.StoreUint32, Golang atomic.StoreUint64, Golang atomic.SwapInt32, Golang atomic.CompareAndSwapInt32, Golang time Package, Golang time.Time Type, Golang time.Duration Type, Golang time.Now Function, Golang time.Sleep Function, Golang time.After Function, Golang time.Tick Function, Golang time.NewTimer, Golang time.NewTicker, Golang time.Parse Function, Golang time.ParseDuration Function, Golang time.Format Function, Golang time.Unix Function, Golang math Package, Golang math/rand Package, Golang rand.Seed, Golang rand.Intn, Golang rand.Float64, Golang rand.NewSource, Golang strings Package, Golang strings.Trim, Golang strings.Split, Golang strings.Join, Golang strings.Contains, Golang strings.Replace, Golang strings.ToLower, Golang strings.ToUpper, Golang strings.HasPrefix, Golang strings.HasSuffix, Golang strconv Package, Golang strconv.Itoa, Golang strconv.Atoi, Golang strconv.ParseInt, Golang strconv.ParseFloat, Golang strconv.FormatInt, Golang strconv.FormatFloat, Golang path Package, Golang path/filepath Package, Golang filepath.Join, Golang filepath.Walk, Golang filepath.Abs, Golang filepath.Base, Golang filepath.Dir, Golang filepath.Ext, Golang filepath.Glob, Golang unicode Package, Golang unicode/utf8 Package, Golang utf8.RuneCountInString, Golang utf8.DecodeRuneInString, Golang unicode.IsLetter, Golang unicode.IsDigit, Golang unicode.ToUpper, Golang unicode.ToLower, Golang regex Integration (regexp), Golang regexp Package, Golang regexp.Compile, Golang regexp.MatchString, Golang regexp.ReplaceAllString, Golang regexp.FindStringSubmatch, Golang sort Package, Golang sort.Ints, Golang sort.Strings, Golang sort.Slice, Golang sort.Search, Golang hash Package, Golang hash/crc32 Package, Golang hash/crc64 Package, Golang hash/adler32 Package, Golang hash/fnv Package, Golang crypto Package, Golang crypto/md5 Package, Golang crypto/sha1 Package, Golang crypto/sha256 Package, Golang crypto/sha512 Package, Golang crypto/hmac Package, Golang crypto/rand Package, Golang crypto/tls Package, Golang crypto/x509 Package, Golang crypto/ecdsa Package, Golang crypto/rsa Package, Golang os/exec Package, Golang exec.Command, Golang exec.CommandContext, Golang exec.LookPath, Golang os/signal Package, Golang signal.Notify, Golang signal.Stop, Golang syscall Package, Golang syscall.Kill, Golang syscall.SIGTERM, Golang syscall.SIGINT, Golang build tags, Golang CGO Integration, Golang _test.go Files, Golang Benchmark Functions, Golang TestMain Function, Golang Example Functions in test, Golang testdata Directory, Golang doc.go Files, Golang internal Packages, Golang vendor Directory, Golang GOPROXY Setting, Golang GOPRIVATE Setting, Golang GOPATH Layout, Golang GOBIN Setting, Golang GOCACHE Setting, Golang GOMODCACHE Directory, Golang sum.golang.org, Golang go1.x Versions, build Lines, embed Directive, Golang embed Package, Golang embed.FS, Golang embed Files, Golang template Package, Golang text/template, Golang html/template, Golang template.ParseFiles, Golang template.Execute, Golang template.FuncMap, Golang net Package, Golang net.Listen, Golang net.Dial, Golang net.IP, Golang net.TCPAddr, Golang net.UDPAddr, Golang net.Listener, Golang net.Conn, Golang net.Interface, Golang net/http.DefaultServeMux, Golang net/http.Client.Do, Golang net/http.Request, Golang net/http.Response, Golang net/http.Handle, Golang net/http.HandleFunc, Golang net/http.ServeTLS, Golang net/http.ServeFile, Golang net/url Package, Golang url.Parse, Golang url.URL Type, Golang url.Values, Golang mime Package, Golang mime.TypeByExtension, Golang mime/multipart Package, Golang mime/multipart.Form, Golang mime/multipart.File, Golang mime/multipart.Writer, Golang mime/multipart.Reader, Golang encoding/base64 Package, Golang base64.StdEncoding, Golang base64.URLEncoding, Golang base64.RawStdEncoding, Golang encoding/hex Package, Golang hex.EncodeToString, Golang hex.DecodeString, Golang image Package, Golang image/png Package, Golang image/jpeg Package, Golang color.Color Interface, Golang color.RGBA, Golang image.NewRGBA, Golang image.NewGray, Golang image/draw Package, Golang context.Context, Golang context.Background, Golang context.TODO, Golang context.WithCancel, Golang context.WithDeadline, Golang context.WithTimeout, Golang context.WithValue, Golang build Import Paths, Golang cross-compilation, Golang GODEBUG Settings, Golang runtime.NumCPU, Golang runtime.GOARCH, Golang runtime.GOOS, Golang reflect.DeepEqual, Golang unsafe Package, Golang unsafe.Pointer, Golang unsafe.Sizeof, Golang unsafe.Alignof, Golang unsafe.Offsetof, Golang go/ast Package, Golang go/parser Package, Golang go/token Package, Golang go/types Package, Golang ast.File, Golang parser.ParseFile, Golang token.FileSet, Golang token.Pos, Golang go/build Package, Golang go/build.Context, Golang build.Default, Golang build.Import, Golang syscall.Exit, Golang go/format Package, Golang format.Node, Golang runtime.Stack Function, Golang runtime.Goexit, Golang runtime.GCPercent, Golang runtime.StackGuard, Golang reflect.PointerTo, Golang reflect.MakeSlice, Golang reflect.MakeMap, Golang reflect.MakeChan, Golang reflect.SelectCase, Golang reflect.Select, Golang reflect.ChanDir, Golang reflect.InterfaceData, Golang reflect.MethodByName, Golang reflect.StructTag, Golang reflect.Value.Cap, Golang reflect.Value.Len, Golang reflect.Value.Index, Golang reflect.Value.Field, Golang reflect.Value.Set, Golang reflect.Value.Convert, Golang net.DialContext, Golang net.ListenConfig, Golang net.Resolver, Golang net.Dialer, Golang net.TLSConn, Golang net/url.UserInfo, Golang html/template.ParseGlob, Golang html/template.ParseFiles, Golang html/template.New, Golang html/template.Must, Golang html/template.HTML, Golang text/template.New, Golang text/template.Must, Golang text/template.ParseGlob, Golang text/template.ParseFiles, Golang compress/gzip Package, Golang gzip.Writer, Golang gzip.Reader, Golang gzip.BestCompression, Golang gzip.BestSpeed, Golang compress/zlib Package, Golang compress/flate Package, Golang database/sql Package, Golang sql.DB, Golang sql.Stmt, Golang sql.Tx, Golang sql.Row, Golang sql.Rows, Golang sql.Open, Golang sql.Drivers, Golang context cancellation, Golang context timeout, Golang context deadlines, Golang os.FileMode, Golang os.FileInfo, Golang os.ReadDir, Golang os.ReadFile, Golang os.WriteFile, Golang os.UserConfigDir, Golang os.UserCacheDir, Golang syslog Package (deprecated), Golang runtime.GOROOT, Golang runtime.Version, Golang runtime.MemStats, Golang runtime.LockOSThread, Golang runtime.UnlockOSThread, Golang runtime.GCStats, Golang runtime.NumCgoCall, Golang runtime.ReadTrace, Golang runtime/trace Package, Golang trace.Start, Golang trace.Stop, Golang math/big Package, Golang big.Int, Golang big.Rat, Golang big.Float, Golang net.IPNet, Golang net.IPMask, Golang net.ParseIP, Golang net.ParseCIDR, Golang net.InterfaceAddrs, Golang net/http.CookieJar, Golang net/http.Client.Timeout, Golang net/http.Client.Transport, Golang net/http.Server, Golang net/http.FileServer, Golang net/http.StripPrefix, Golang net/http.HandleFunc, Golang net/http.NotFound, Golang encoding/gob Package, Golang gob.Register, Golang gob.NewDecoder, Golang gob.NewEncoder, Golang sync/atomic Package, Golang atomic.Value, Golang atomic.Load, Golang atomic.Store, Golang math.Ceil, Golang math.Floor, Golang math.Sqrt, Golang math.Pow, Golang math.Log, Golang math.Sin, Golang math.Cos, Golang math.Tan, Golang math.NaN, Golang math.Inf, Golang go/constant Package, Golang go/importer Package, Golang go/printer Package, Golang go/scanner Package, Golang go/format Node, Golang path.Clean, Golang path.Base, Golang path.Dir, Golang path.Ext, Golang path.Join, Golang path.Split, Golang path.Match, Golang runtime/metrics Package, Golang runtime/trace.StartRegion, Golang runtime/trace.EndRegion, Golang runtime/trace.Log, Golang runtime/debug.FreeOSMemory, Golang runtime/debug.SetGCPercent, Golang runtime/debug.ReadGCStats, Golang runtime/debug.WriteHeapDump, Golang testing.M Main, Golang testing.Bench, Golang testing.Short, Golang testing.Verbose, Golang testing.TempDir, Golang testing.T.Cleanup, Golang testing.T.Parallel, Golang testing.T.Run, Golang testing.B.Run, Golang testing.B.ReportAllocs, Golang testing.B.ResetTimer, Golang flag Package, Golang flag.String, Golang flag.Int, Golang flag.Bool, Golang flag.Parse, Golang os.Chmod, Golang os.Chown, Golang os.File.Readdir, Golang os.File.Sync, Golang os.Stdin, Golang os.Stdout, Golang os.Stderr, Golang runtime.KeepAlive, Golang runtime.GCStats.PauseTotalNs, Golang runtime.SetFinalizer, Golang runtime.MemProfile, Golang runtime.BlockProfile, Golang runtime.CPUProfile, Golang runtime/pprof Package, Golang pprof.StartCPUProfile, Golang pprof.StopCPUProfile, Golang pprof.WriteHeapProfile, Golang pprof.Lookup, Golang net/http/httptest Package, Golang httptest.NewServer, Golang httptest.NewRecorder, Golang httptest.ResponseRecorder, Golang image/color Palette, Golang image/color Model, Golang image/color.Gray, Golang image/color.RGBA64, Golang image.Config, Golang image.Decode, Golang image.RegisterFormat, Golang text/scanner Package, Golang scanner.Scanner, Golang scanner.Position, Golang scanner.TokenText, Golang scanner.Whitespace, Golang scanner.IsIdentRune, Golang text/tabwriter Package, Golang tabwriter.Writer, Golang tabwriter.AlignRight, Golang tabwriter.FilterHTML, Golang tabwriter.DiscardEmptyColumns, Golang tabwriter.NewWriter, Golang context.ErrCanceled, Golang context.ErrDeadlineExceeded, Golang time.AfterFunc, Golang time.Until, Golang time.NewTicker.Stop, Golang time.NewTimer.Stop, Golang reflect.Swapper, Golang reflect.Value.CanAddr, Golang reflect.Value.CanSet, Golang reflect.Value.Interface, Golang reflect.Value.Pointer, Golang reflect.Type.Elem, Golang reflect.Type.NumField, Golang reflect.Type.Field, Golang reflect.Type.NumMethod, Golang reflect.Type.Method, Golang reflect.Type.Comparable, Golang reflect.Type.ConvertibleTo, Golang reflect.Type.Implements, Golang reflect.Type.AssignableTo, Golang reflect.Type.Bits, Golang reflect.Type.Len, Golang reflect.Type.Cap, Golang reflect.Type.ChanDir, Golang reflect.Type.Key, Golang reflect.Type.Name, Golang reflect.Type.PkgPath, Golang reflect.Type.String, Golang reflect.SelectRecv, Golang reflect.SelectSend, Golang reflect.SelectDefault, Golang runtime.LockOSThread

SHORTEN THIS to 20 ITEMS! navbar_golang

Abstract Syntax Trees, Absolute Time, Advanced Go Concurrency Patterns, Alias Declarations, Alternate Package Names, Anonymous Fields, Anonymous Functions, Append Function, Array Types, Assertion of Types, Assignability Rules, Atomic Package, Augmented Assignment, Authentication with Context, Auto-Increment Versions, Backward Compatibility, Basic Types, Benchmark Functions, Binary Package, Blank Identifier, Block Statements, Boolean Expressions, Bridge Methods, Build Constraints, Build Tags, Builtin Functions, Byte Order, Byte Slices, Bytes Package, Caching Modules, Cancellation with Context, Cap Function, Channel Direction, Channel Operations, Channel Types, Channels, Character Literals, Closure Functions, Code Generation, Code Formatting, Code Review Comments, Collecting Garbage, Composite Literals, Composition over Inheritance, Concurrency Patterns, Conditional Compilation, Constant Declarations, Constant Expressions, Context Package, Continue Statements, Control Flow, Convert Function, Copy Function, Cross Compilation, Cyclic Dependencies, Cyclic Imports, Data Alignment, Data Race Detection, Deadlock Detection, Defer Statements, Deferred Function Calls, Deleting Map Entries, Dependency Management, Design Philosophy, Detecting Deadlocks, Directive Comments, Directory Structure, Discarded Errors, Documentation Comments, Dot Imports, Dynamic Linking, Effective Go, Empty Interface, Embedding Interfaces, Embedding Structs, Embedded Files, Encoding Binary, Encoding CSV, Encoding JSON, Encoding XML, Endianness, Enforcing Contracts, Error Handling, Error Interface, Error Types, Escape Analysis, Executable Packages, Exit Codes, Expvar Package, Exported Names, Expression Statements, Extending Interfaces, External Linking, Fallthrough Keyword, Fatal Errors, Field Tags, File Inclusion, File I/O, File Paths, First-Class Functions, Floating-Point Numbers, FMT Package, For Loops, Format Specifiers, Formatting Source Code, Function Declarations, Function Literals, Function Types, Functional Options, Garbage Collection, GC Tuning, Generics, Global Variables, Go Build Command, Go Command, Go Concurrency Patterns, Go Doc Tool, Go FMT Tool, Go Generate Command, Go Get Command, Go Install Command, Go Modules, Go Playground, Go Run Command, Go Test Command, Go Toolchain, Go Vet Tool, Go Workspaces, GOB Encoding, Godoc Documentation, Gofmt Formatting, Goroutine Leaks, Goroutines, Gosec Security Scanner, GOTRACEBACK Environment Variable, Gotype Tool, GOVERSION File, Gowork Files, Heap Allocation, Heap Dump, HTML Templates, IOTA Identifier, Iota Enumerations, IO Package, IO Reader, IO Writer, Import Declarations, Import Paths, Imports Formatting, Incremental Compilation, Indentation Rules, Index Expressions, Indexed Elements, Initialization Order, Init Functions, Input Validation, Integer Overflow, Integer Types, Integration Testing, Interface Assertions, Interface Embedding, Interface Satisfaction, Interface Types, Internal Packages, Internationalization, Interoperability with C, Invariably Safe Initialization, IO Utility Functions, JSON Marshalling, JSON Unmarshalling, Keywords, Lambda Functions, Language Specification, Lateral Type Inference, Lazy Initialization, Leaking Goroutines, Len Function, Linter Tools, Literal Types, Live Variable Analysis, Load Testing, Logging Conventions, Logging Package, Loop Control Statements, Magic Comments, Make Function, Map Types, Maps, Memory Allocation, Memory Model, Memory Profiling, Method Declarations, Method Expressions, Method Sets, Methods, Module Compatibility, Module Caching, Module Proxy, Module Replacements, Module Versions, Module-aware Mode, Modules, Mutexes, Named Return Values, Name Mangling, Name Resolution, Name Shadowing, Naming Conventions, Nesting Structs, Net HTTP Package, Net Package, Nil Interface, Nil Pointer Dereference, Nil Slices, Nil Values, Non-Blocking Channels, Number Literals, Object Files, Octal Literals, Open Source License, Operator Precedence, Optimization Flags, Order of Evaluation, OS Package, Package Documentation, Package Initialization, Package Names, Package Visibility, Packages, Packages with Main, Panic and Recover, Panic Defer Recover, Parallel Testing, Parsing Techniques, Path Separators, Performance Optimization, Performance Profiling, Pipeline Patterns, Plain Functions, Pointer Arithmetic, Pointer Receivers, Pointers, Polymorphism, Portability, Postfix Operators, Predeclared Identifiers, Predefined Constants, Preemption in Scheduler, Primitive Types, Print Functions, Profiling Tools, Project Layout, Protobuf Integration, Public and Private Identifiers, Punctuator Tokens, Race Conditions, Race Detector, Range Expressions, Range Loops, Read-Only Interfaces, Receiver Functions, Receiver Types, Recover Function, Recursion, Reflection, Regular Expressions, Relative Imports, Relocation Information, Remote Import Paths, Repeatable Builds, Replace Directive, Reserved Words, Resource Management, Response Writers, RESTful APIs, Return Statements, Reusing Code, Rune Literals, Runes, Runtime Package, Satisfying Interfaces, Scopes, Select Statements, Selective Imports, Self-Referential Functions, Semaphore Patterns, Send-Only Channels, Shadowing Variables, Short Declarations, Signals Handling, Signed Integers, Simple Statements, Single Assignment, Single Binary Applications, Slice Expressions, Slice Internals, Slice Length and Capacity, Slice of Slices, Slices, Source File Organization, Source to Source Compilation, Space Optimization, Spawned Processes, Specification Compliance, Split Package, Sprint Functions, Stack Traces, Standard Library, Static Analysis, Static Linking, String Conversions, String Formatting, String Literals, Strings Package, Struct Embedding, Struct Literals, Struct Tags, Struct Types, Structs, Subtests, Switch Statements, Synchronization Primitives, Syntactic Sugar, System Calls, Tab Characters, TCP Connections, Template Parsing, Template Rendering, Template Syntax, Templates Package, Ternary Operators, Testing, Testing Package, Text Templates, Third-Party Packages, Thread Safety, Time Package, Timeouts, TLS Configuration, Tokenization, Toolchain, Trace Tool, Tracing, Tracking Dependencies, Type Aliases, Type Assertions, Type Declarations, Type Embedding, Type Inference, Type Parameters, Type Switches, Typed Constants, Types, UID and GID, Unhandled Errors, Unicode Characters, Unicode Package, Unique Package Names, Unsafe Package, Unstructured Concurrency, Untyped Constants, Unused Imports, Unused Variables, Update Statements, URL Parsing, UTF-8 Encoding, Value Receivers, Variable Declarations, Variadic Functions, Vendor Directory, Vendoring, Version Control, Version Pinning, Visibility Rules, WaitGroup, Walkthrough Examples, Web Applications, Whitespace Rules, Wildcards in Imports, Write Barriers, Zero Initialization, Zero Values

Golang: Golang Fundamentals, Golang Inventor - Golang Language Designer: Ken Thompson, Robert Griesemer, Rob Pike of Google, Go abstraction, Golang Glossary - Glossaire de Golang - French, Go agile, Go ahead-of-time (AOT), Go AI, Go algebraic data types, Go algorithms, Go Android, Go anonymous functions, Go AOP, Go AOT, Go APIs, Go arguments, Go ARM, Go arithmetic, Go arrays, Go aspect-oriented, Go assignment, Go associative arrays, Go async, Go asynchronous callbacks, Go asynchronous programming, Go automatic variables, Go automation, Go Avro, Go backend, Go backwards compatibility, Go block scoped, Go Booleans, Go Boolean expressions, Go buffer overflow, Go builds, Go built-in types, Go bytecode, Go cache, Go caching, Go call by reference, Go call by value, Go callbacks, Go call stack, Go casting, Go characters, Go Chocolatey, Go CI/CD, Go classes, Go CLI, Go client-side, Go closures, Go cloud (Go Cloud Native-Go AWS-Go Azure-Go GCP-Go IBM Cloud-Go IBM Mainframe-Go OCI), Go code smells, Go coercion, Go collections, Go command-line interface, Go commands, Go comments, Go compilers, Go complex numbers, Go composition, Go configuration, Go concurrency, Go concurrent programming, Go conditional expressions, Go conferences, Go constants, Go constructors, Go containers, Go control flow, Go control structures, Go coroutines, Go crashes, Go creators, Go currying, Go databases, Go data manipulation, Go data persistence, Go data science, Go data serialization, Go Built-In Data Types, Go data structures, Go data synchronization, Go dates, Go dates and times, Go deadlocks, Go debugging, Go declarative, Go deferred callbacks, Go delegates, Go delegation, Go dependency injection, Go design patterns, Go designers, Go destructors, Go DevOps, Go dictionaries, Go dictionary comprehensions, Go DI, Go distributed software, Go distributions, Go distros, Go DL, Go Docker, Go do-while, Go DSL, Go duck typing, Go dynamic binding, Go dynamic scope, Go dynamically scoped, Go dynamically typed, Go dynamic variables, Go eager evaluation, Go embedded, Go encapsulation, Go encryption, Go enumerated types, Go enumeration, Go enums, Go environment variables, Go errors, Go error handling, Go evaluation strategy, Go event-driven, Go event handlers, Go event loops, Go exception handling, Go executables, Go execution, Go expressions, Go FaaS, Go Facebook, Go fibers, Go fields, Go file input/output, Go file synchronization, Go file I/O, Go filter, Go first-class functions, Go fold, Go foreach loops, Go fork-join, Go floating-point, Go FP, Go frameworks, Go FreeBSD, Go frontend, Go functions, Go functional, Go functional programming, Go function overloading, Go garbage collection, Go generators, Go generator expressions, Go generics, Go generic programming, Go GitHub, Go global variables, Go GraphQL, Go gRPC, Go GUI, Go hashing, Go heap, Go heap allocation, Go hello world, Go higher-order functions, Go history, Go Homebrew, Go HTTP, Go idempotence, Go IDEs, Go import, Go imperative, Go immutable values, Go immutability, Go inheritance, Go influenced, Go influenced by, Go installation, Go integers, Go integration testing, Go interfaces, Go internationalization, Go interpreters, Go interprocess communication (IPC), Go iOS, Go IoT, Go IPCs, Go ISO Standard, Go iteration, Go JetBrains, Go JIT, Go JSON, Go JSON-RPC, Go JSON Web Tokens, Go JSON Web Token (JWT), Go Just-in-time (JIT), Go JWT, Go K8S, Go keywords, Go lambdas, Go language spec, Go lazy evaluation, Go lexically scoped, Go lexical scoping, Go libraries, Go linters, Go Linux, Go lists, Go list comprehensions, Go literals, Go localization, Go local variables, Go locks, Go logging, Go logo, Go looping, Go macOS, Go map, Go mascot, Go math, Go member variables, Go memoization, Go memory addressing, Go memory allocation, Go malloc, Go memory management, Go memory safety, Go message queues, Go metaclasses, Go meta-programming, Go methods, Go method overloading, Go MFA, Go ML, Go microservices, Go Microsoft, Go mobile dev, Go modules, Go modulo operators, Go monitoring, Go multiprocessing, Go multi-threaded, Go mutable values, Go mutability, Go mutex (Go mutual exclusion), Go namespaces, Go natural language processing (NLP), Go networking, Go network programming, Go NLP, Go non-blocking, Go non-blocking I/O, Go null, Go null reference, Go null coalescing operators, Go numbers, Go number precision, Go OAuth, Go objects, Go object code, Go object comparisons, Go object creation, Go object creators, Go object destruction, Go object destructors, Go object lifetime, Go object-oriented constructors, Go object-oriented programming, Go object serialization, Go observability, Go OOP, Go operators, Go operator overloading, Go optimizations, Go organizations, Go ORMs, Go packages, Go package managers, Go pass by reference, Go pass by value, Go parallel computing, Go parallel programming, Go parallelism, Go parameters, Go people, Go performance, Go persistence, Go pipelines, Go pointers, Go polymorphism, Go primitives, Go primitive data types, Go probability, Go procedural, Go processes, Go producer-consumer, Go programmers, Go programming, Go programming paradigm, Go program structure, Go program termination, Go Protocol Buffers (Protobuf), Go Protocol Buffers, Go Protobuf, Go proxies, Go public-key encryption, Go PKI, Go pure functions, Go race conditions, Go random, Go reactive, Go readability, Go records, Go recursion, Go reentrancy, Go refactoring, Go reference counting, Go reference types, Go referential transparency, Go reflection, Go regex, Go remote procedure calls (RPC), Go REPL, Go reserved words, Go REST, Go REST APIs, Go RHEL, Go RPCs, Go runtimes, Go safe navigation operators, Go SDK, Go secrets, Go security, Go serialization, Go serverless, Go server-side, Go sets, Go set comprehensions, Go side effects, Go signed integers, Go SMTP, Go Snapcraft, Go social media, Go sockets, Go source code, Go source-to-source compiler, Go SQL, Go SSL - Go SSL-TLS, Go Single sign-on (SSO), Go SSO, Go StackOverflow, Go stack, Go stack allocation, Go Stack overflow, Go standards, Go standard errors, Go standard input, Go standard library, Go standard operators, Go standard output, Go state, Go statements, Go strings, Go string concatenation, Go string functions, Go string operations, Go scheduling, Go scientific notation, Go scope, Go scope rules, Go scoping, Go scripting, Go static analyzers, Go statically scoped, Go static scoping, Go statically typed, Go static variables, Go statistics, Go strongly typed, Go structural typing, Go synchronization, Go syntax, Go systems programming, Go TCP/IP, Go TDD, Go testing, Go test frameworks, Go threads, Go thread-local storage (TLS), Go TLS, Go thread locking, Go thread locks, Go thread safety, Go thread scheduling, Go thread synchronization, Go times, Go timers, Go to JavaScript, Go tools, Go toolchain, Go transpiler, Go transpiling to JavaScript, Go truth values, Go tuples, Go type checking, Go type conversion, Go type inference, Go type safety, Go type system, Go web dev, Go while loops, Go work stealing, Go values, Go value types, Go variables, Go variable lifetime, Go variable scope, Go versions, Go virtual environments, Go virtual machine, Go Ubuntu, Go Unicode, Go unit testing, Go unsigned integers, Go usability, Go weakly typed, Go Windows, Go wrappers, Go written using, Go x86-64-Go AMD64, Go XML, Go YAML, Go Awesome list;

Go topics-Go courses-Go books-Go docs. (navbar_golang and navbar_golang_detailed)

navbar_programming and navbar_programming_detailed