# symbols

Published articles for symbols.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Call relocation types

DevFeed: [Call relocation types](<https://devfeed.tech/articles/call-relocation-types-31126.md>)

Original publisher: [Read original article](<https://maskray.me/blog/call-relocation-types>)

Published: 2026-02-16T08:00:00Z

Content type: article

Language: en

Sources: [MaskRay](<https://devfeed.tech/sources/maskray.md>)

Topics: [x86](<https://devfeed.tech/topics/x86.md>), [Assembly](<https://devfeed.tech/topics/assembly.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [binutils](<https://devfeed.tech/tags/binutils.md>), [function](<https://devfeed.tech/tags/function.md>), [linker](<https://devfeed.tech/tags/linker.md>), [static-linking](<https://devfeed.tech/tags/static-linking.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [x86](<https://devfeed.tech/tags/x86.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

This technical post explains why some architectures use separate ELF relocation types for direct function calls and tail calls. It contrasts static linking, where a PC-relative relocation can often be reused, with dynamic linking, where calls may use PLT indirection and therefore require relocation types that encode call semantics.

### Source excerpt

Most architectures encode direct branch/call instructions with a PC-relative displacement. This post discusses a specific category of branch relocations: those used for direct function calls and tail calls. Some architectures use two ELF relocation types for a call instruction: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 # i386, x86-64 call foo # R_386_PC32, R_X86_64_PC32 call foo@plt # R_386_PLT32, R_X86_64_PLT32 # m68k bsr.l foo # R_68K_PC32 bsr.l foo@plt # R_68K_PLT32 # s390/s390x brasl %r14, foo # R_390_PC32DBL brasl %r14, foo@plt # R_390_PLT32DBL # sparc call foo, 0 # not PIC: R_SPARC_WDISP30 call foo, 0 # gas -KPIC: R_SPARC_WPLT30

## The making of a product icon

DevFeed: [The making of a product icon](<https://devfeed.tech/articles/the-making-of-a-product-icon-10126.md>)

Original publisher: [Read original article](<https://www.figma.com/blog/the-making-of-a-product-icon/>)

Author: Emma Webster

Published: 2025-07-25T00:00:00Z

Content type: article

Language: en

Sources: [Figma Blog](<https://devfeed.tech/sources/figma-blog.md>)

Topics: [Figma](<https://devfeed.tech/topics/figma.md>), [MEAN](<https://devfeed.tech/topics/mean-stack.md>)

Tags: [creativity](<https://devfeed.tech/tags/creativity.md>), [design](<https://devfeed.tech/tags/design.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [figma](<https://devfeed.tech/tags/figma.md>), [marketing](<https://devfeed.tech/tags/marketing.md>), [process](<https://devfeed.tech/tags/process.md>), [product](<https://devfeed.tech/tags/product.md>), [symbols](<https://devfeed.tech/tags/symbols.md>)

### AI overview

A behind-the-scenes look at how Figma product icons are developed through extensive iteration, design guidelines, team brainstorming, and visual testing across different sizes and formats.

### Source excerpt

Creating product icons at Figma involves dozens--sometimes hundreds--of iterations. Product Designer Tim Van Damme shares his thoughtful approach to icon design and the creative exploration that shapes each final result.

## Writing a Debugger From Scratch - DbgRs Part 8 - Source and Symbols

DevFeed: [Writing a Debugger From Scratch - DbgRs Part 8 - Source and Symbols](<https://devfeed.tech/articles/writing-a-debugger-from-scratch-dbgrs-part-8-source-and-symbols-39740.md>)

Original publisher: [Read original article](<https://www.timdbg.com/posts/writing-a-debugger-from-scratch-part-8/>)

Author: Tim Misiak

Published: 2024-05-29T15:50:13Z

Content type: tutorial

Language: en

Sources: [TimDbg](<https://devfeed.tech/sources/timdbg.md>)

Topics: [debug](<https://devfeed.tech/topics/debug.md>), [Windows](<https://devfeed.tech/topics/windows.md>), [Streams](<https://devfeed.tech/topics/streams.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [streams](<https://devfeed.tech/tags/streams.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

This installment of the DbgRs debugger series introduces source-level debugging through symbols, focusing on Windows PDB files. It explains how PDBs connect compiled code with source code and can contain function signatures, type definitions, local variables, and stream-based file data.

### Source excerpt

(New to this series? Consider starting from part 1) At the end of the last post, DbgRs gained the ability to disassemble the code that it was debugging. While disassembly is critical for many debugging tasks, using source code to step through the code line by line is usually more convenient when it's available. In this post we'll start looking at how to use symbols (PDB files on Windows) so that we can display the source for the code that's being debugged.

## Symbol and Binary Indexing

DevFeed: [Symbol and Binary Indexing](<https://devfeed.tech/articles/symbol-and-binary-indexing-39727.md>)

Original publisher: [Read original article](<https://www.timdbg.com/posts/symbol-indexing/>)

Author: Tim Misiak

Published: 2022-08-10T15:30:09Z

Content type: tutorial

Language: en

Sources: [TimDbg](<https://devfeed.tech/sources/timdbg.md>)

Topics: [debugging](<https://devfeed.tech/topics/debugging.md>), [Windows](<https://devfeed.tech/topics/windows.md>), [Visual Studio](<https://devfeed.tech/topics/visual-studio.md>)

Tags: [binaries](<https://devfeed.tech/tags/binaries.md>), [debug](<https://devfeed.tech/tags/debug.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [files](<https://devfeed.tech/tags/files.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [windbg](<https://devfeed.tech/tags/windbg.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

This article explains why WinDbg debugging benefits from indexing both symbols and binaries. Symbols provide names, type definitions, and source files, while indexed binaries help debuggers reconstruct missing module data and perform reliable stack walking, especially when analyzing crash dumps from another machine.

### Source excerpt

Symbol indexing is one of those features of WinDbg that can make things "just work" in a way that seems like magic. But it can also be the most painful things when it goes wrong. Why should I index symbols and binaries? Most of us have tried to debug without symbols at one point, and it can quickly become an exercise in frustration. It's much more productive to debug an executable where you have symbols because it gives you function names, variable names, type definitions, and source files.

## Remote debugging

DevFeed: [Remote debugging](<https://devfeed.tech/articles/remote-debugging-39741.md>)

Original publisher: [Read original article](<https://www.timdbg.com/remote-debugging/>)

Author: Tim Misiak

Published: 2022-08-05T14:00:00Z

Content type: tutorial

Language: en

Sources: [TimDbg](<https://devfeed.tech/sources/timdbg.md>)

Topics: [debugging](<https://devfeed.tech/topics/debugging.md>), [Development](<https://devfeed.tech/topics/development.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [Server](<https://devfeed.tech/topics/server.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>)

Tags: [binaries](<https://devfeed.tech/tags/binaries.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [development](<https://devfeed.tech/tags/development.md>), [exceptions](<https://devfeed.tech/tags/exceptions.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [os](<https://devfeed.tech/tags/os.md>), [remote](<https://devfeed.tech/tags/remote.md>), [server](<https://devfeed.tech/tags/server.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [windbg](<https://devfeed.tech/tags/windbg.md>)

### AI overview

This tutorial explains how to set up remote debugging with WinDbg and NTSD. It defines target and host terminology, compares NTSD/CDB with DbgSrv, and explains how debugger logic, binaries, symbols, memory, registers, and debugging events are distributed between machines.

### Source excerpt

A key feature of WinDbg and NTSD is the ability to debug a target "remotely" from a separate computer. For kernel debugging, this is often the only way to debug, since the entire OS is "frozen" when broken into a kernel debugger. Remote debugging is also available for usermode debugging, and is often just as useful. Sometimes it's useful because the target that you are testing on is different from the one you are using for development.

## Introducing Material Symbols

DevFeed: [Introducing Material Symbols](<https://devfeed.tech/articles/introducing-material-symbols-29269.md>)

Original publisher: [Read original article](<https://material.io/blog/introducing-symbols>)

Published: 2022-04-19T10:00:00Z

Content type: article

Language: en

Sources: [Material.io - Material Design](<https://devfeed.tech/sources/material-io-material-design.md>)

Topics: [Icon font](<https://devfeed.tech/topics/icon-font.md>), [Font](<https://devfeed.tech/topics/font.md>), [Google](<https://devfeed.tech/topics/google.md>)

Tags: [fonts](<https://devfeed.tech/tags/fonts.md>), [google](<https://devfeed.tech/tags/google.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [variable](<https://devfeed.tech/tags/variable.md>)

### AI overview

Material Symbols is a variable icon font available on Google Fonts. It supports adjusting weight, fill, optical size, and grade.

### Source excerpt

Fine-tune weight, fill, optical size, and grade with the variable icon font, available on Google Fonts

## Bloaty McBloatface 1.0

DevFeed: [Bloaty McBloatface 1.0](<https://devfeed.tech/articles/bloaty-mcbloatface-1-0-21132.md>)

Original publisher: [Read original article](<https://blog.reverberate.org/2018/08/07/bloaty-1.0.html>)

Author: Haberman

Published: 2018-08-07T00:00:00Z

Content type: release

Language: en

Sources: [Josh Haberman](<https://devfeed.tech/sources/josh-haberman.md>)

Topics: [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>), [C](<https://devfeed.tech/topics/c.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [binaries](<https://devfeed.tech/tags/binaries.md>), [bugfixes](<https://devfeed.tech/tags/bugfixes.md>), [c](<https://devfeed.tech/tags/c.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [data-quality](<https://devfeed.tech/tags/data-quality.md>), [ocaml](<https://devfeed.tech/tags/ocaml.md>), [release](<https://devfeed.tech/tags/release.md>), [symbols](<https://devfeed.tech/tags/symbols.md>)

### AI overview

The article announces Bloaty McBloatface 1.0, a size profiler for ELF and Mach-O binaries. It explains that the release improves data quality by parsing binary sections such as unwind information, DWARF debug information, symbol and string tables, and relocations more thoroughly.

### Source excerpt

Today I am releasing Bloaty McBloatface 1.0. Bloaty is a size profiler for binaries. It helps you peek into ELF/Mach-O binaries to see what is taking up space inside. Bloaty has gotten lots new features, bugfixes, and overall improvements since I announced it in 2016. I listed these changes briefly on the release page, but I wanted to go into a bit more detail here. Improving Data Quality Perhaps the biggest overall improvement to Bloaty is its data quality. When I first announced Bloaty, I got very understandable complaints like this one: I ran it and it gives an awful lot of "[None]": $ ~/d/bloaty/bloaty builder/virt-builder -d compileunits VM SIZE FILE SIZE -------------- -------------- 75.5% 1.96Mi [None] 3.67Mi 85.2% 8.7% 232Ki guestfs-c-actions.c 232Ki 5.3% 8.2% 219Ki guestfs.ml 219Ki 5.0% 2.0% 52.4Ki [Other] 52.4Ki 1.2% 1.3% 33.7Ki _none_ 33.7Ki 0.8% 0.7% 17.5Ki customize_cmdline.ml 17.5Ki 0.4% 0.6% 17.3Ki builder.ml 17.3Ki 0.4% 0.4% 11.8Ki customize_run.ml 11.8Ki 0.3% 0.4% 10.4Ki cmdline.ml 10.4Ki 0.2% 0.3% 7.08Ki firstboot.ml 7.08Ki 0.2% 0.2% 6.21Ki index-scan.c 6.21Ki 0.1% 0.2% 5.90Ki index_parser.ml 5.90Ki 0.1% 0.2% 5.15Ki sigchecker.ml 5.15Ki 0.1% 0.2% 4.87Ki getopt-c.c 4.87Ki 0.1% [...] It's a mixed OCaml/C executable, but I ran it on a build from the local directory and all debug symbols are still available. Indeed, a profiler tool that has no idea what to say about 85.2% of the binary is not going to be very useful. This was Bloaty's biggest weakness when I first released it. At first I misunderstood the nature of this problem. Bloaty's design at the time was simple: it was reading .debug_aranges to assign ranges of the binary to compilation units. DWARF's .debug_aranges section is an {address range -> compileunit} map that debuggers use to decide what compile unit a given function or data variable is from, given its address. The output above indicates that .debug_aranges was only covering about 15% of the binary. What gives? My theory at the time was

## Data Flow Diagrams 3.0

DevFeed: [Data Flow Diagrams 3.0](<https://devfeed.tech/articles/data-flow-diagrams-3-0-36754.md>)

Original publisher: [Read original article](<https://shostack.org/blog/data-flow-diagrams-3-0/>)

Author: Adam

Published: 2017-11-05T00:00:00Z

Content type: tutorial

Language: en

Sources: [Shostack & Friends Blog](<https://devfeed.tech/sources/shostack-friends-blog.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [trust](<https://devfeed.tech/topics/trust.md>), [context](<https://devfeed.tech/topics/context.md>), [Processes](<https://devfeed.tech/topics/processes.md>)

Tags: [context](<https://devfeed.tech/tags/context.md>), [data](<https://devfeed.tech/tags/data.md>), [diagram](<https://devfeed.tech/tags/diagram.md>), [flow](<https://devfeed.tech/tags/flow.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [process](<https://devfeed.tech/tags/process.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [trust](<https://devfeed.tech/tags/trust.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

This article defines Data Flow Diagrams 3.0 as a named approach to threat-modeling diagrams. It explains its five symbols, trust boundaries, labeling rules, optional context diagrams, and guidance on color and arrow direction.

### Source excerpt

[no description provided]

## Understanding color blindness

DevFeed: [Understanding color blindness](<https://devfeed.tech/articles/understanding-color-blindness-9418.md>)

Original publisher: [Read original article](<https://a11yproject.com/posts/understanding-colourblindness/>)

Author: Matthew Higgins

Published: 2017-10-18T00:00:00Z

Content type: article

Language: en

Sources: [The A11Y Project](<https://devfeed.tech/sources/the-a11y-project.md>)

Topics: [Accessibility](<https://devfeed.tech/topics/accessibility.md>), [Web](<https://devfeed.tech/topics/web.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [article](<https://devfeed.tech/tags/article.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [tools](<https://devfeed.tech/tags/tools.md>), [vision](<https://devfeed.tech/tags/vision.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

This article explains color blindness and its implications for web accessibility. It recommends avoiding color as the sole means of communication, choosing distinguishable colors, and adding secondary visual cues such as icons or symbols, in line with WCAG guideline 1.4.1. It also mentions tools for evaluating color accessibility.

### Source excerpt

Color blindness is a common genetic condition in which some peoples' eyes can't tell the difference between certain colors. That's not to say these people see the world in greyscale-- just that many colors seem identical to one another. Total color blindness is very rare in humans. Color vision deficiencies (typically grouped together as "color blindness") are not rare. Some form of color blindness affects at least one in twenty people. Wikipedia has a helpful table, based on a journal article from biomedcentral.com. There are several different forms of color blindness. The most common, red-green color blindness, affects around one in twelve men. Color blindness is less profound than many impairments, but people with color vision problems often face restrictions on certain activities, which vary around the world. For example, Romania prohibits residents who are color blind from driving. The USA doesn't consider color blindness a disability because of workplace discrimination purposes. Though there are multiple types of color blindness, they are the same in principle. For more information, check out Wikipedia's article on color blindness, which has some excellent descriptions. What does this mean for accessibility on the web? To make sure your site is readable for individuals with color blindness, avoid relying on color alone to communicate. These guidelines are compliant with the WCAG; guideline 1.4.1 covers making content distinguishable using color. In practice, you can achieve this by choosing colors that are easily distinguished from one another, and by adding secondary visualizations for icons and tasks. For example, say you're using red and green buttons to represent tasks a user has outstanding. It might seem logical to show items that need attention in red, and those that are good in green. One small change, such as overlaying a check mark icon over the "good" or "completed" items, will help communicate which items are approved and those that need attention.

## 10 LDFLAGS I Love

DevFeed: [10 LDFLAGS I Love](<https://devfeed.tech/articles/10-ldflags-i-love-35211.md>)

Original publisher: [Read original article](<https://blog.jessfraz.com/post/top-10-favorite-ldflags/>)

Published: 2016-07-18T20:00:14Z

Content type: article

Language: en

Sources: [Jessie Frazelle](<https://devfeed.tech/sources/jessie-frazelle.md>)

Topics: [linker](<https://devfeed.tech/topics/linker.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [binaries](<https://devfeed.tech/tags/binaries.md>), [debug](<https://devfeed.tech/tags/debug.md>), [linker](<https://devfeed.tech/tags/linker.md>), [map](<https://devfeed.tech/tags/map.md>), [symbols](<https://devfeed.tech/tags/symbols.md>)

### AI overview

A sarcastic programming article presents ten favorite LDFLAGS and briefly explains their linker behavior, including static linking, symbol export, archive inclusion, link-map generation, symbol stripping, tracing, library search restrictions, and unresolved symbols.

### Source excerpt

Hello and welcome to what will become the most sarcastic post on my blog. This is going to be a series of "buzzfeed" style programming articles and after this post I very happily pass the baton to Filippo Valsorda to continue. And I urge you to write your own as well. @jessfraz "We asked Jess for her top 10 ldflags; you won't believe what happened next" -- adg (@enneff) July 17, 2016 So here they are: -static I would be an embarassment to myself if I didn't start with the flag that tells the linker to not link against shared libraries. This is the best flag. STATIC BINARIES FTW. --export-dynamic This flag tells the linker to add all the symbols to the dynamic symbol table. This is especially important if you want to do "The Macgyver of Dlopening" and dlopen yourself. --whole-archive This is another flag that comes in handy when you want to dlopen yourself. See most linkers will only take into account the things it knows it needs. But with this flag, you tell it "YOLO, I want it all" so that later you can dlopen yourself with that symbol that was never actually used until runtime. FUN! --no-whole-archive This flag un-sets the --whole-archive flag which is nice for when you only want the whole archive of one library but not all the others you are linking to. --print-map This flag is just dope. It prints a link map to stdout. This gives you information about object files, common symbols, and the values assigned to symbols. --strip-all This flag strips all the symbol information from the artifact produced. If say you are a few KB/MB off from your binary fitting on a floppy disk, this flag is your friend. --strip-debug This flag is very similar to --strip-all except it only strips the debug symbol information. This all really depends on how much you need to shave off to fit that binary on a floppy disk. --trace This flag is great for debugging. It prints the names of the input files as ld processes them. -nostdlib This flag forces the linker to only search the libraries y

## Set Theory--A Primer

DevFeed: [Set Theory--A Primer](<https://devfeed.tech/articles/set-theory-a-primer-40223.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/07/09/set-theory-a-primer/>)

Published: 2011-07-09T18:14:59Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [Math and Logic](<https://devfeed.tech/topics/math-and-logic.md>)

Tags: [axiom-of-choice](<https://devfeed.tech/tags/axiom-of-choice.md>), [bijections](<https://devfeed.tech/tags/bijections.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [countability](<https://devfeed.tech/tags/countability.md>), [example](<https://devfeed.tech/tags/example.md>), [functions](<https://devfeed.tech/tags/functions.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [numbers](<https://devfeed.tech/tags/numbers.md>), [power-set](<https://devfeed.tech/tags/power-set.md>), [primer](<https://devfeed.tech/tags/primer.md>), [set](<https://devfeed.tech/tags/set.md>), [set-theory](<https://devfeed.tech/tags/set-theory.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [theory](<https://devfeed.tech/tags/theory.md>), [variable](<https://devfeed.tech/tags/variable.md>)

### AI overview

This primer introduces set theory by defining sets, elements, membership, cardinality, notation, and several ways to construct sets. It uses numerical examples and introduces natural numbers, integers, and rational numbers while noting that unrestricted operations can lead to paradoxes.

### Source excerpt

It's often that a student's first exposure to rigorous mathematics is through set theory, as originally studied by Georg Cantor. This means we will not treat set theory axiomatically (as in ZF set theory), but rather we will take the definition of a set for granted, and allow any operation to be performed on a set. This will be clear when we present examples, and it will be clear why this is a bad idea when we present paradoxes.

## Turing Machines--A Primer

DevFeed: [Turing Machines--A Primer](<https://devfeed.tech/articles/turing-machines-a-primer-40218.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/07/04/turing-machines-a-primer/>)

Published: 2011-07-04T16:35:44Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Automaton](<https://devfeed.tech/topics/automaton.md>), [function](<https://devfeed.tech/topics/function.md>)

Tags: [acceptance](<https://devfeed.tech/tags/acceptance.md>), [computability-theory](<https://devfeed.tech/tags/computability-theory.md>), [computers](<https://devfeed.tech/tags/computers.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [decidability](<https://devfeed.tech/tags/decidability.md>), [halting-problem](<https://devfeed.tech/tags/halting-problem.md>), [input](<https://devfeed.tech/tags/input.md>), [machine](<https://devfeed.tech/tags/machine.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [primer](<https://devfeed.tech/tags/primer.md>), [process](<https://devfeed.tech/tags/process.md>), [pushdown-automata](<https://devfeed.tech/tags/pushdown-automata.md>), [state](<https://devfeed.tech/tags/state.md>), [symbols](<https://devfeed.tech/tags/symbols.md>), [turing-machines](<https://devfeed.tech/tags/turing-machines.md>)

### AI overview

This tutorial introduces Turing machines as a model of computation. It defines their states, tape symbols, input symbols, initial state, accepting and rejecting states, and transition function, then explains how the tape, read-write head, state transitions, and halting behavior work.

### Source excerpt

We assume the reader is familiar with the concepts of determinism and finite automata, or has read the corresponding primer on this blog. The Mother of All Computers Last time we saw some models for computation, and saw in turn how limited they were. Now, we open Pandrora's hard drive: Definition: A Turing machine is a tuple $ (S, \Gamma, \Sigma, s_0, F, \tau)$, where $ S$ is a set of states, $ \Gamma$ is a set of tape symbols, including a special blank symbol $ b$, $ \Sigma \subset \Gamma$ is a set of input symbols, not including $ b$, $ s_0$ is the initial state, $ A \subset S$ is a set of accepting states, $ R \subset S$ is a set of rejecting states, $ \tau: S - (A \cup R) \times \Gamma \to S \times \Gamma \times \left \{ L, R \right \}$ is a partial function called the transition function, where $ L, R$ correspond to "left shift" and "right shift," respectively.