https://quasilyte.dev/blog/ Recent content on Iskander (Alex) Sharipov technical blog Hugo -- gohugo.io en-us Fri, 13 Oct 2023 00:00:00 +0000 https://quasilyte.dev/blog/post/pathfinding/ Fri, 13 Oct 2023 00:00:00 +0000 https://quasilyte.dev/blog/post/pathfinding/ Intro Algorithms are important. The problem is you can implement the same algorithm so differently. The implementation performance can range from blazing fast to barely acceptable. Tutorial: if you see an underlined text that is not a link, hover over it to read a tooltip. If you like optimizations, specialized data structures and bit tricks then this article is for you. We’ll concentrate on two algorithms today: A-star and greedy BFS. https://quasilyte.dev/blog/post/gen-map/ Fri, 22 Sep 2023 00:00:00 +0000 https://quasilyte.dev/blog/post/gen-map/ Intro I was intrigued by the sparse map/set described in Russ Cox’s article. And I’m not the only one: this exact implementation is used in Go source code more than once! The compiler uses it for many ID-like maps and sets; regexp package uses it for a queue. But there is one thing that is still bugging me: it’s hard to make it very efficient. All operations I care about are O(1), but get and set operations clearly become slower in comparison with a straightforward slice approach. https://quasilyte.dev/blog/post/naive-ssa-alternative/ Sat, 26 Mar 2022 00:00:00 +0000 https://quasilyte.dev/blog/post/naive-ssa-alternative/ The SSA complexities Let’s suppose that you’re working on some small compiler-like project. At some point, you may start thinking about adding optimizations to the code generated by your compiler. Then you realize that it’s not enough to just have some IR that is suitable for modifications. It’s important to apply only those optimizations that keep the code correct (or at least don’t make it more broken than it was before). https://quasilyte.dev/blog/post/profile-guided-gogrep/ Tue, 21 Dec 2021 00:00:00 +0000 https://quasilyte.dev/blog/post/profile-guided-gogrep/ If you found a typo or a misspelling, please [file an issue](https://github.com/quasilyte/blog-src/issues/new) or send a PR that fixes it. Original (ru): https://habr.com/ru/post/596755/. If you combine a structural code search of gogrep and CPU profile filtering with perf-heatmap, you’ll get a profile-guided code search. This combo lets you find complex code patterns that occur only on the “hot” code path, so optimizing them can be worthwhile. perf-heatmap can also be used by a text editor to display the source code lines performance heat levels as shown below. https://quasilyte.dev/blog/post/single-exit/ Tue, 15 Jun 2021 00:48:18 +0000 https://quasilyte.dev/blog/post/single-exit/ There are other similar articles, like Why you shouldn’t use func main in Go. This post addresses the issue from a slightly different angle. tl;dr: You program should probably have only one os.Exit() call, if any. That includes all indirect calls: log.Fatal() and any other function that calls os.Exit() at some point. If your main looks like this, then this article is for you: func main() { x, err := doSomething() defer x. https://quasilyte.dev/blog/post/ruleguard-modules/ Mon, 21 Dec 2020 00:54:25 +0000 https://quasilyte.dev/blog/post/ruleguard-modules/ Bundles is a new feature coming to the ruleguard. It’ll make it possible to re-use third-party rules without having to copy/paste them. Creating an importable bundle A package that exports rules must define a Bundle object: package gorules import "github.com/quasilyte/go-ruleguard/dsl" // Bundle holds the rules package metadata. // // In order to be importable from other gorules package, // a package must define a Bundle variable. var Bundle = dsl.Bundle{} func boolComparison(m dsl. https://quasilyte.dev/blog/post/yaml5/ Thu, 10 Sep 2020 22:01:24 +0000 https://quasilyte.dev/blog/post/yaml5/ TL;DR: Write YAML as JSON5 (but use # for comments) Enforce this style with yaml5 lint # JSON5? YAML? {a: 1, b: ['x', 'y']} What you see above is a valid YAML 1.2 document. It uses the flow-style syntax for objects and arrays. If you look at the JSON5 feature list, you can deduce that YAML is a superset of JSON5. The only difference is the single-line comment syntax. https://quasilyte.dev/blog/post/call-go-from-jit/ Sat, 20 Jun 2020 10:41:50 +0000 https://quasilyte.dev/blog/post/call-go-from-jit/ If you found a typo or a misspelling, please [file an issue](https://github.com/quasilyte/blog-src/issues/new) or send a PR that fixes it. Original (ru): https://habr.com/ru/post/489482/. Intro As long as your assembler code does something simple, you’re golden. As soon as you’ll need to call a Go function from it, the first suggestion that you’ll probably get: don’t do it. Perhaps you would like to follow that advice, especially if you’re unsure why you needed it in the first place. https://quasilyte.dev/blog/post/gogrep/ Sun, 07 Jun 2020 14:11:49 +0000 https://quasilyte.dev/blog/post/gogrep/ If you found a typo or a misspelling, please [file an issue](https://github.com/quasilyte/blog-src/issues/new) or send a PR that fixes it. Original (ru): https://habr.com/post/481696/. gogrep is one of my favorite tools. It gives you the ability to search Go code using syntax patterns, filter matches by expression types, and perform structural replace. Today I’ll talk about how to use gogrep and about VS Code extension that integrates gogrep into the editor. https://quasilyte.dev/blog/post/pratt-parsers-go/ Fri, 27 Mar 2020 17:08:04 +0000 https://quasilyte.dev/blog/post/pratt-parsers-go/ If you found a typo or a misspelling, please [file an issue](https://github.com/quasilyte/blog-src/issues/new) or send a PR that fixes it. Original (ru): https://habr.com/ru/post/494316/. Recursive descent parsing works well when you can continue parsing using the current context and a given token. Some expressions make parsing harder: postfix, infix and other. They introduce a problem: you don’t know which kind of expression you’re processing until you’ve already parsed half of it. https://quasilyte.dev/blog/post/ruleguard/ Wed, 08 Jan 2020 21:54:02 +0000 https://quasilyte.dev/blog/post/ruleguard/ If you found a typo or a misspelling, please [file an issue](https://github.com/quasilyte/blog-src/issues/new) or send a PR that fixes it. Original (ru): https://habr.com/post/481696/. This article introduces a new static analysis library (and CLI utility) go-ruleguard. It’s like a gogrep that is adapted for the use inside your CI pipeline. You describe static analysis rules in terms of a special Go-like DSL. During the startup, ruleguard turns these definitions into a set of inspections to be executed. https://quasilyte.dev/blog/post/step-pattern/ Wed, 27 Feb 2019 22:15:32 +0000 https://quasilyte.dev/blog/post/step-pattern/ If you heard about table driven tests, the idea described in this article will be easier to grasp, since it’s the same technique, but used outside of the tests. Suppose you have a function that executes a lot of other functions. This function probably does two main things: It checks for all returned errors as they occur. It passes one function outputs as the inputs for another. // process is an example pipeline-like function. https://quasilyte.dev/blog/post/log-fatal-vs-log-panic/ Tue, 08 Jan 2019 01:46:18 +0000 https://quasilyte.dev/blog/post/log-fatal-vs-log-panic/ Update: probably the best alternative to log.Fatalf inside main is log.Printf followed by a return statement. If your main function contains a lot of such exit points, consider using a step driven evaluation pattern. I personally don’t like log.Fatal/Fatalf/Fatalln. I feel sad because of their ubiquity in Go examples as a form of reaction to an error. I personally prefer log.Panic. The log.Panic vs log.Fatal is essentially panic vs os. https://quasilyte.dev/blog/post/go_ssa_rules/ Sat, 30 Jun 2018 18:53:25 +0000 https://quasilyte.dev/blog/post/go_ssa_rules/ Original (ru): https://habr.com/post/415771/. Go compiler uses its own Lisp-like domain-specific language (DSL) for Static Single Assignment (SSA) optimization rules description. Lets dig into that language, its peculiarities and limitations. As an excercise, we’ll add a new optimization rule into Go compiler that would optimize expressions like a*b+c using new operations we’re going to implement along the way. This is the first article in the series about Go compiler SSA backend, this is why I’ve included some fundamental and architectural info besides DSL overview. https://quasilyte.dev/blog/post/go-avx512/ Fri, 08 Jun 2018 13:46:49 +0000 https://quasilyte.dev/blog/post/go-avx512/ About this document This article is going to be up-to-date source of AVX-512 information in Go context. It references other posts, official documentation and other useful resources. It’s short. By purpose. Only English content is referenced (original + translated). Documentation AVX-512 support in Go assembler: short reference that focuses on Go-specific implementation of AVX-512. It describes how to use all AVX-512 special features in Go assembly syntax as well as some encoder details. https://quasilyte.dev/blog/post/disassembling-go-avx512/ Fri, 08 Jun 2018 13:29:13 +0000 https://quasilyte.dev/blog/post/disassembling-go-avx512/ The problem Go 1.11 got updated assembler that supports AVX-512, but disassembler is left unchanged. In other words, go tool asm speaks AVX-512, go tool objdump does not. Suppose we have this avx.s file: TEXT ·avxCheck(SB), 0, $0 VPOR X0, X1, X2 //; AVX1 VPOR Y0, Y1, Y2 //; AVX2 VPORD.BCST (DX), Z1, K2, Z2 //; AVX-512 RET You will be surprised after assemble+disassemble attempt: $ go tool asm avx.s $ go tool objdump avx. https://quasilyte.dev/blog/post/go-asm-dispatch-tables/ Thu, 31 May 2018 01:39:59 +0000 https://quasilyte.dev/blog/post/go-asm-dispatch-tables/ Dispatch tables When you want to execute particular code path depending on some kind of tag/opcode or other integer value that can be easily mapped into index, dispatch tables can speed things up compared to the sequence of comparisons and conditional jumps. In interpreters, this technique is often used as an alternative to switch-based dispatch. It’s called direct threading in that domain. Each opcode corresponds to table index that contains machine code address that can execute operation specified by the opcode. https://quasilyte.dev/blog/post/goism-objects-layout-mode/ Sun, 14 Jan 2018 00:00:00 +0000 https://quasilyte.dev/blog/post/goism-objects-layout-mode/ Introduction Goism project requires Go pointers emulation inside Emacs Lisp code. This document describes how to achive (almost) full functionality with potential to have optimizations that eliminate some of the emulation-related overhead. The actual implementation can diverge. Only initial design is outlined. Struct representation Go structures represented by lists. Empty struct run-time value is unspecified, but it satisfies Go spec requirements. type a1 struct { f1 int } // a1{1} // (list 1) type a2 struct { f1, f2, f3, f4 int } // a2{1, 2, 3, 4} // (list 1 2 3 4) For the very small (1-3 fields) objects lists are a better choice than vectors, but generally, vectors are more memory-efficient and provide faster random access. https://quasilyte.dev/blog/post/writing-emacs-lisp-compiler-intrinsics/ Sat, 23 Sep 2017 00:00:00 +0000 https://quasilyte.dev/blog/post/writing-emacs-lisp-compiler-intrinsics/ The problem Given a particular programming task in Emacs Lisp, you almost always should implement it with function. Sometimes, macro is a proper tool. Even more rarely, cl-define-compiler-macro may be your choice. All these methods are safe to use. They almost certanly will not break with newer Emacs versions. One interesting task that can not be implemented efficiently with approaches that are outlined above is imperative return statement. Emacs Lisp lacks this kind of flow control and this is a problem we are goind to attack today. https://quasilyte.dev/blog/post/go-asm-complementary-reference/ Wed, 20 Sep 2017 00:00:00 +0000 https://quasilyte.dev/blog/post/go-asm-complementary-reference/ Third flavour of x86 assembly language This article is heavily inspired by AT&T VS Intel/Microsoft assembly syntax comparison page. It helped me very much in the past. Many tools understand both AT&T and Intel style assembly. Go derived Plan9 toolchain, so you should learn third kind of assembly language. It will not accept anything else. In this document: Comparison of Plan9/Go and AT&T/GNU assembly; Some non-obvious details that are not described anywhere else; Links to useful resources; Check external resources for information that is missing here. https://quasilyte.dev/blog/post/go-nested-functions-and-static-locals/ Mon, 18 Sep 2017 00:00:00 +0000 https://quasilyte.dev/blog/post/go-nested-functions-and-static-locals/ Symbol visibility Default symbol visibility should be as narrow as possible. This means that you use globals with internal linkage instead of external, local variables rather than globals, hide class-related constants inside it’s scope, and so on. If function is only called inside particular function, it should become a nested function. Most of these rely on the language support. Go has quite simple model of scopes and symbol visibility. User-defined identifier can be local or package-local (global). https://quasilyte.dev/blog/post/cgo-funcall/ Fri, 18 Aug 2017 00:00:00 +0000 https://quasilyte.dev/blog/post/cgo-funcall/ DWIM-style FFI CGo is a widely adopted way of calling C functions from Go: low level C FFI which does many things behind the scene, but exposes only minimal functionality that is required to interact with C. CGo does no implicit conversions or data copying during C functions call, even int and C.int are not compatible. Code that uses this mechanism without wrappers (bindings) will be polluted with explicit slice/array copies and type conversions. https://quasilyte.dev/blog/post/riscv32-custom-instruction-and-its-simulation/ Wed, 21 Jun 2017 00:00:00 +0000 https://quasilyte.dev/blog/post/riscv32-custom-instruction-and-its-simulation/ Agenda This article shows how to add a new instruction to RISC-V and simulate it. These topics are covered along the way: Whole GNU riscv toolchain installation; Implementation of a new instruction for spike RISC-V ISA simulator; Manual instruction encoding in C/C++; Custom instruction simulation (with visible output); [riscv32-]GCC plugin development; You may find associated repository useful. Many things can go wrong. Be prepared to fix upcoming issues by yourself. https://quasilyte.dev/blog/post/elisp-multi-return-values/ Fri, 19 May 2017 00:00:00 +0000 https://quasilyte.dev/blog/post/elisp-multi-return-values/ The missing feature Did you ever wrote a function in Emacs Lisp which should return more than one result? Emacs Lisp has no native support for multiple return values, but provides cl-lib that emulates it in a Common Lisp style. In this article I will show that cl-values is suboptimal and can be replaced without any sacrifices to the convenience. Naive solution cl-lib implements cl-values in terms of list. This approach is naive because each time you return with that, an allocation is involved. https://quasilyte.dev/blog/post/c-broken-defaults/ Mon, 26 Dec 2016 00:00:00 +0000 https://quasilyte.dev/blog/post/c-broken-defaults/ State of the C C fits its niche quite well. If you want relatively simple, ubiquitous and efficient language there is no much room for selection. It “evolves so slowly” because it is already quite complete. Most of the parts that can be improved without making C yet another bloated language require breaking changes. C could be designed better if we accept older code invalidation. …but in reallity it is impossible to achieve. https://quasilyte.dev/blog/post/faq/ Thu, 01 Dec 2016 00:00:00 +0000 https://quasilyte.dev/blog/post/faq/ Report an issue If you: Found a typo; Think some material is inappropriate or incorrect; Want to propose a new article; … or you looking for a way to contact author, just open new Github issue. Try to be polite and precise in your words, please. Subscribe Currently, the only way to “subscribe” for blog updates is to watch blog-src repository. Go to the linked repository and locate displayed button in the top-right part of the window.