# recursion

Published articles for recursion.

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

## What algorithm did Windows XP use to choose your initial user picture?

DevFeed: [What algorithm did Windows XP use to choose your initial user picture?](<https://devfeed.tech/articles/what-algorithm-did-windows-xp-use-to-choose-your-initial-user-picture-21759.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/oldnewthing/20260909-00/?p=112683>)

Author: Raymond Chen

Published: 2026-09-09T14:00:00Z

Content type: article

Language: en

Sources: [Raymond Chen](<https://devfeed.tech/sources/raymond-chen.md>)

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Randomizer](<https://devfeed.tech/topics/randomizer.md>), [Windows](<https://devfeed.tech/topics/windows.md>), [Filesystems](<https://devfeed.tech/topics/filesystems.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [files](<https://devfeed.tech/tags/files.md>), [history](<https://devfeed.tech/tags/history.md>), [old-new-thing](<https://devfeed.tech/tags/old-new-thing.md>), [random](<https://devfeed.tech/tags/random.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

The article explains that Windows XP selected an initial user picture randomly from the Default Pictures directory using the current time as the random seed. It describes a one-pass reservoir-sampling algorithm, including its efficiency and behavior when files change during selection, with a 100-picture safety limit.

### Source excerpt

It's random, really. The post What algorithm did Windows XP use to choose your initial user picture? appeared first on The Old New Thing.

## Too big to draw, but yet drawable

DevFeed: [Too big to draw, but yet drawable](<https://devfeed.tech/articles/too-big-to-draw-but-yet-drawable-37564.md>)

Original publisher: [Read original article](<https://blog.klipse.tech/aboulafia/2026/07/06/too-big-to-draw-but-yet-drawable.html>)

Author: Yehonathan Sharvit

Published: 2026-07-06T09:00:00Z

Content type: article

Language: en

Sources: [Klipse](<https://devfeed.tech/sources/klipse.md>)

Topics: [ordering](<https://devfeed.tech/topics/ordering.md>), [structure](<https://devfeed.tech/topics/structure.md>)

Tags: [aboulafia](<https://devfeed.tech/tags/aboulafia.md>), [caustics](<https://devfeed.tech/tags/caustics.md>), [generative](<https://devfeed.tech/tags/generative.md>), [math](<https://devfeed.tech/tags/math.md>), [permutation](<https://devfeed.tech/tags/permutation.md>), [permutations](<https://devfeed.tech/tags/permutations.md>), [random](<https://devfeed.tech/tags/random.md>), [ranking](<https://devfeed.tech/tags/ranking.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [visualization](<https://devfeed.tech/tags/visualization.md>)

### AI overview

The third article in a series explains how Aboulafia's tserouf orders all permutations of a word and visualizes them by placing the permutations around a circle and connecting each word to its reversal. Because the full permutation space becomes too large to draw, the article samples chords and shows that they form recurring caustic curves visible at multiple scales.

### Source excerpt

Aboulafia's Tserouf - Part 3 of 4 <- Previous: An elegant formulation, inspired by Bill Gates - Next: A wheel, the same forwards and backwards ->

## I tested nested subagents in Claude Code

DevFeed: [I tested nested subagents in Claude Code](<https://devfeed.tech/articles/i-tested-nested-subagents-in-claude-code-18319.md>)

Original publisher: [Read original article](<https://newsletter.aiengineer.co/p/i-tested-nested-subagents-in-claude>)

Author: Owain Lewis

Published: 2026-06-17T14:03:13Z

Content type: opinion

Language: en

Sources: [The AI Engineer](<https://devfeed.tech/sources/the-ai-engineer.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [context window](<https://devfeed.tech/topics/context-window.md>), [Code](<https://devfeed.tech/topics/code.md>), [GitHub](<https://devfeed.tech/topics/github.md>), [Go](<https://devfeed.tech/topics/go.md>), [Pull Request](<https://devfeed.tech/topics/pull-request.md>), [Code review](<https://devfeed.tech/topics/code-review.md>)

Tags: [claude-code](<https://devfeed.tech/tags/claude-code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [go](<https://devfeed.tech/tags/go.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [review](<https://devfeed.tech/tags/review.md>), [workflow](<https://devfeed.tech/tags/workflow.md>)

### AI overview

The article tests nested subagents in Claude Code, including recursion depth and a three-level workflow of orchestrator, workers, and sub-workers. In a Go project, the workflow implemented a change, ran checks and tests, reviewed the result, fixed minor issues, and opened a pull request.

### Source excerpt

Claude Code now let's you run nested subagents. But is it useful?

## How to Improve Coding Interview Performance with Personal Stories and Targeted Technical Practice

DevFeed: [How to Improve Coding Interview Performance with Personal Stories and Targeted Technical Practice](<https://devfeed.tech/articles/i-used-to-suck-at-coding-interviews-then-i-quadrupled-my-salary-32370.md>)

Original publisher: [Read original article](<https://brianjenney.substack.com/p/i-used-to-suck-at-coding-interviews-b9c>)

Author: Brian Jenney

Published: 2026-03-24T15:05:22Z

Content type: opinion

Language: en

Sources: [Brian Jenney](<https://devfeed.tech/sources/brian-jenney.md>)

Topics: [coding](<https://devfeed.tech/topics/coding.md>), [Development](<https://devfeed.tech/topics/development.md>), [Code](<https://devfeed.tech/topics/code.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>)

Tags: [approach](<https://devfeed.tech/tags/approach.md>), [career](<https://devfeed.tech/tags/career.md>), [coding](<https://devfeed.tech/tags/coding.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [manager](<https://devfeed.tech/tags/manager.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [software-engineer](<https://devfeed.tech/tags/software-engineer.md>)

### AI overview

The author describes struggling with coding interviews despite being able to do the underlying job. They recommend cataloging personal work stories for recurring behavioral questions and focusing practice on recurring technical gaps.

### Source excerpt

Five years ago, during an interview for a senior dev role, I had a panic attack.

## Designing a hierarchical Authorisation system

DevFeed: [Designing a hierarchical Authorisation system](<https://devfeed.tech/articles/designing-a-hierarchical-authorisation-system-39640.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2025-09-20_designing-a-hiearchical-authorisation-system>)

Author: Authorisation

Published: 2025-09-20T00:00:00Z

Content type: tutorial

Language: en

Sources: [Gaurav Sarma's Blog](<https://devfeed.tech/sources/gaurav-sarma-s-blog.md>)

Topics: [Actor](<https://devfeed.tech/topics/actor.md>), [object](<https://devfeed.tech/topics/object.md>), [structure](<https://devfeed.tech/topics/structure.md>), [service](<https://devfeed.tech/topics/service.md>), [properties](<https://devfeed.tech/topics/properties.md>)

Tags: [actor](<https://devfeed.tech/tags/actor.md>), [apis](<https://devfeed.tech/tags/apis.md>), [billing](<https://devfeed.tech/tags/billing.md>), [finance](<https://devfeed.tech/tags/finance.md>), [object](<https://devfeed.tech/tags/object.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [service](<https://devfeed.tech/tags/service.md>), [structure](<https://devfeed.tech/tags/structure.md>)

### AI overview

This article explains how to design a hierarchical authorization system for Goiter. It contrasts a flat mapping of users, objects, and actions with a hierarchical model in which groups can have multiple parents and inherit rules. The article notes that recursive parent lookup can reduce rule bloat, while assuming a maximum recursion depth of 10.

### Source excerpt

. [Designing a Hierarchical Authorisation System](designing-a-hierarchical-authorisation-system-cover...

## Running Routing Protocols over Tunnels

DevFeed: [Running Routing Protocols over Tunnels](<https://devfeed.tech/articles/running-routing-protocols-over-tunnels-11100.md>)

Original publisher: [Read original article](<https://blog.ipspace.net/2024/11/running-routing-protocols-over-tunnels/>)

Published: 2024-11-05T07:14:00Z

Content type: article

Language: en

Sources: [ipSpace.net blog](<https://devfeed.tech/sources/ipspace-net-blog.md>)

Topics: [networking](<https://devfeed.tech/topics/networking.md>), [Routing (disambiguation)](<https://devfeed.tech/topics/routing.md>), [Protocol (disambiguation)](<https://devfeed.tech/topics/protocol.md>), [BGP](<https://devfeed.tech/topics/bgp.md>), [IS-IS](<https://devfeed.tech/topics/is-is.md>), [MPLS-TE](<https://devfeed.tech/topics/mpls-te.md>), [MPLS VPN](<https://devfeed.tech/topics/mpls-vpn.md>), [evpn](<https://devfeed.tech/topics/evpn.md>), [VXLAN](<https://devfeed.tech/topics/vxlan.md>), [Reason](<https://devfeed.tech/topics/reason.md>)

Tags: [bgp](<https://devfeed.tech/tags/bgp.md>), [evpn](<https://devfeed.tech/tags/evpn.md>), [ip-routing](<https://devfeed.tech/tags/ip-routing.md>), [is-is](<https://devfeed.tech/tags/is-is.md>), [mpls](<https://devfeed.tech/tags/mpls.md>), [mpls-te](<https://devfeed.tech/tags/mpls-te.md>), [ospf](<https://devfeed.tech/tags/ospf.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [routing](<https://devfeed.tech/tags/routing.md>), [vxlan](<https://devfeed.tech/tags/vxlan.md>)

### AI overview

This article explains why routing protocols over tunnels can cause recursive routing and infinite encapsulation. It distinguishes traffic-engineering and IPsec tunnels from VPN designs, where routing protocols exchange customer and transport prefixes using separated address spaces or families.

### Source excerpt

James got confused by a statement made by Hannes Gredler in his IS-IS book: Things behave really badly if the total IGP cost over the tunnel undermines the total topologies' cost. What happens next is that the tunnel "wraps" around itself, ultimately causing a meltdown of the entire network. Let's unpack that, starting with "Why would you need a tunnel?" Read more ...

## How a Geo Data Pipeline Bug Disrupted Skyscanner Flight Search

DevFeed: [How a Geo Data Pipeline Bug Disrupted Skyscanner Flight Search](<https://devfeed.tech/articles/what-happened-32392.md>)

Original publisher: [Read original article](<https://medium.com/@SkyscannerEng/what-happened-f7c06f078a64?source=rss-401f3b3c958f------2>)

Author: Skyscanner Engineering

Published: 2023-11-21T11:36:51Z

Content type: article

Language: en

Sources: [Stories by Skyscanner Engineering on Medium](<https://devfeed.tech/sources/stories-by-skyscanner-engineering-on-medium.md>)

Topics: [Graphs](<https://devfeed.tech/topics/graphs.md>), [data](<https://devfeed.tech/topics/data.md>), [dataset](<https://devfeed.tech/topics/dataset.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Kubernetes clusters](<https://devfeed.tech/topics/kubernetes-clusters.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [data-pipeline](<https://devfeed.tech/tags/data-pipeline.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [graph](<https://devfeed.tech/tags/graph.md>), [issue](<https://devfeed.tech/tags/issue.md>), [kubernetes-clusters](<https://devfeed.tech/tags/kubernetes-clusters.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

A bug in Skyscanner's geo data materialisation process made some locations their own parents, creating loops in the location hierarchy and disrupting flight search. The article explains the geo data model and the incident's technical context.

### Source excerpt

How recursion brought down flight search at Skyscanner On 14th September, 2023 8:05 AM UTC (all timestamps in UTC) there was a critical bug in the output of our geo data pipeline which resulted in a number of geo locations being set as parents of themselves. This caused disruption to our service, and for this we're sorry. It gave us the opportunity to evaluate what went wrong, what we learned, and ways we could prevent a situation like this from happening again. Let's take a deep dive and explain things further. What is Geo Data? Geo data is a key dataset at Skyscanner which is used to provide systems, industry partners and travellers with a complete and accurate representation of the world. In simpler terms, any time you see an Airport, City, Region or Country used in Skyscanner, it's originating from this dataset. The most visible example across our offering can be seen when searching for flights where you will specify an airport, city or country for your journey. We use the geo data to populate origins/destinations and look for flights What was the issue? Skyscanner has been on a journey to upgrade our geo data set. At this time there are two versions, two geo models, running in parallel. Flights generally need to know about airports, cities, countries, contrary to other parts of the business where we need to model more complex relations such as districts, countries, islands, etc. Those relationships form a complex graph where locations are related to each others as parents and children. For this reason we kept our original "heritage" data set, merged it with our canonical dataset, our source of truth. We then basically generate (or reconstruct) our heritage dataset from the canonical data every day at 8am UTC. This generation is referred to as materialisation. The Materialisation Process On 14th September, a bug in the materialisation process updated some locations to be the parent of themselves. For example Scotland is now parent of Scotland. We've created a lo

## Arrow Core in Kotlin: Function Composition, Partial Application, and Recursive Functions

DevFeed: [Arrow Core in Kotlin: Function Composition, Partial Application, and Recursive Functions](<https://devfeed.tech/articles/a-birds-eye-view-of-arrow-working-with-function-with-arrow-core-39299.md>)

Original publisher: [Read original article](<https://kt.academy/article/fk-arrow-core>)

Published: 2022-11-28T00:15:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Library](<https://devfeed.tech/topics/library.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [generation](<https://devfeed.tech/tags/generation.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [library](<https://devfeed.tech/tags/library.md>), [programming](<https://devfeed.tech/tags/programming.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

A tutorial on Arrow Core, a Kotlin library for functional programming. It explains function composition, partial application, memoization, and recursive functions, including techniques for working with function arguments and preventing stack overflow in Fibonacci calculations.

### Source excerpt

Learn about essential Arrow functions used for composition, memoization, recursion and functions generation.

## Personal Heatmaps

DevFeed: [Personal Heatmaps](<https://devfeed.tech/articles/personal-heatmaps-26574.md>)

Original publisher: [Read original article](<https://medium.com/strava-engineering/personal-heatmaps-f51d15a0db2b?source=rss----89d4108ce2a3---4>)

Author: J Evans

Published: 2022-10-28T21:15:46Z

Content type: tutorial

Language: en

Sources: [Strava Engineering](<https://devfeed.tech/sources/strava-engineering.md>)

Topics: [data](<https://devfeed.tech/topics/data.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [navigation](<https://devfeed.tech/topics/navigation.md>), [pixel](<https://devfeed.tech/topics/pixel.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Google Maps](<https://devfeed.tech/topics/google-maps.md>), [Website](<https://devfeed.tech/topics/website.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [cycling](<https://devfeed.tech/tags/cycling.md>), [data](<https://devfeed.tech/tags/data.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [gis](<https://devfeed.tech/tags/gis.md>), [google-maps](<https://devfeed.tech/tags/google-maps.md>), [gps](<https://devfeed.tech/tags/gps.md>), [heat](<https://devfeed.tech/tags/heat.md>), [map](<https://devfeed.tech/tags/map.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [pixel](<https://devfeed.tech/tags/pixel.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [running](<https://devfeed.tech/tags/running.md>), [strava](<https://devfeed.tech/tags/strava.md>), [zoom](<https://devfeed.tech/tags/zoom.md>)

### AI overview

This article explains the algorithm behind Strava's Personal Heatmap, which renders an athlete's GPS activity as a frequency-based heatmap on an interactive world map. It focuses on Mercator projection and recursive map tiling, where 256x256 pixel tiles are served at different zoom levels for real-time navigation.

### Source excerpt

This post discusses the algorithm behind Personal Heatmap, one of Strava's most acclaimed subscriber features. Product Overview The Personal Heatmap feature has been around in some form since 2015, but we gave it a major overhaul in 2020. For those unfamiliar, the heatmap is an aggregated view of an athlete's GPS-enabled activities on Strava. Activity data is rendered onto a map according to path traversal frequency; the more an athlete runs on a road, the brighter -- i.e. "hotter" -- that road shows up on the map. The result is a beautiful color gradient displaying the intricate web of past activities, unique to each athlete. The Personal Heatmap is displayed on an interactive world map, also known as a slippy map. Athletes can seamlessly zoom in and out or pan around to arbitrary views of the map, and their activity heat stays displayed the entire time. To enable this, we must provide a scheme for rendering and serving subsections of the world map on the fly. Enter map tiling. Mercator Projection & Map Tiling Map tiling is the practice of subdividing a map into many discrete images that can be stitched together and rendered as a single image in real-time during map navigation. The first step in choosing a tiling scheme is picking what world map to use. Enter, the Mercator Projection, the most commonly used projection of Earth as a flat, rectangular surface. We use this projection in all of our mapping products, including heatmaps. https://medium.com/media/d9e120d13950dd0f1bb4ee14108aa9a9/href Now, imagine a grid overlaying the Mercator projection. Each grid section is known as a tile, a pixel image with resolution 256x256. Every tile has an associated zoom level, and tiles are defined recursively according to this zoom level. A tile at a given zoom level can be subdivided into four equal sized tiles at a next zoom level. For example, Zoom level 0 displays the entire planet in a single 256x256 pixel image. Zoom level 1 displays the world in four 256x256 pixel images.

## Object-oriented or functional? Two ways to see the world

DevFeed: [Object-oriented or functional? Two ways to see the world](<https://devfeed.tech/articles/object-oriented-or-functional-two-ways-to-see-the-world-39357.md>)

Original publisher: [Read original article](<https://kt.academy/article/oop-vs-fp>)

Published: 2022-08-18T00:00:00Z

Content type: opinion

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Object-oriented programming (OOP)](<https://devfeed.tech/topics/oop.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [fp](<https://devfeed.tech/tags/fp.md>), [functional](<https://devfeed.tech/tags/functional.md>), [immutability](<https://devfeed.tech/tags/immutability.md>), [inheritance](<https://devfeed.tech/tags/inheritance.md>), [object-oriented](<https://devfeed.tech/tags/object-oriented.md>), [oop](<https://devfeed.tech/tags/oop.md>), [polymorphism](<https://devfeed.tech/tags/polymorphism.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This opinion article compares object-oriented programming and functional programming as ways of thinking about program design, rather than merely collections of features. It uses different ways of viewing a bedroom--as objects or actions--to illustrate the distinction while acknowledging that modern languages commonly support both styles.

### Source excerpt

The difference between the OOP and FP paradigms is deeply rooted in how we see the world. A few words on the philosophy of both approaches.

## Making unwinding through JIT-ed code scalable - The b-tree

DevFeed: [Making unwinding through JIT-ed code scalable - The b-tree](<https://devfeed.tech/articles/making-unwinding-through-jit-ed-code-scalable-the-b-tree-25076.md>)

Original publisher: [Read original article](<https://databasearchitects.blogspot.com/2022/06/btree.html>)

Author: Thomas Neumann (noreply@blogger.com)

Published: 2022-06-26T08:56:00Z

Content type: article

Language: en

Sources: [Database Architects](<https://devfeed.tech/sources/database-architects.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [data-structure](<https://devfeed.tech/tags/data-structure.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [memory](<https://devfeed.tech/tags/memory.md>), [node](<https://devfeed.tech/tags/node.md>), [object](<https://devfeed.tech/tags/object.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [structure](<https://devfeed.tech/tags/structure.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>)

### AI overview

This article explains the data-structure and infrastructure portions of a scalable unwinding system that uses a B-tree for fast lookup and data locality. It describes node organization, invariants, fence keys, helper functions, optimistic lock coupling, memory reclamation through a free list, and recursive destruction; insert, remove, and lookup operations are deferred to the next article.

### Source excerpt

This article is part of the series about scalable unwinding that starts here. We use a b-tree because it offers fast lookup, good data locality, and a scalable implementation is reasonable easy when using optimistic lock coupling. Nevertheless a b-tree is a non-trivial data structure. To avoid having one huge article that includes all details of the b-tree, we just discuss the data structure themselves and some helper functions here, the insert/remove/lookup operations will be discussed in the next article. A b-tree partitions its elements by value. An inner node contains a sorted list of separator/child pairs, with the guarantee that the elements in the sub-tree rooted at the child pointer will be <= the separator. The leaf nodes contains sorted lists of (base, size, object) entries, where the object is responsible for unwinding entries between base and base+size. An b-tree maintains the invariants that 1) all nodes except the root are at least half full, and 2) a leaf nodes have the same distance to the root. This guarantees us logarithmic lookup costs. Note that we use fence-keys, i.e., the inner nodes have a separator for the right-most entries, too, which is not the case in all b-tree implementations: // The largest possible separator value static const uintptr_t max_separator = ~((uintptr_t) (0)); // Inner entry. The child tree contains all entries <= separator struct inner_entry { uintptr_t separator; struct btree_node *child; }; // Leaf entry. Stores an object entry struct leaf_entry { uintptr_t base, size; struct object *ob; }; // node types enum node_type { btree_node_inner, btree_node_leaf, btree_node_free }; // Node sizes. Chosen such that the result size is roughly 256 bytes #define max_fanout_inner 15 #define max_fanout_leaf 10 // A btree node struct btree_node { // The version lock used for optimistic lock coupling struct version_lock version_lock; // The number of entries unsigned entry_count; // The type enum node_type type; // The payload union { /

## Advent of Kotlin Solutions

DevFeed: [Advent of Kotlin Solutions](<https://devfeed.tech/articles/advent-of-kotlin-solutions-39189.md>)

Original publisher: [Read original article](<https://kt.academy/article/advent-2021-solutions>)

Published: 2022-01-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Kt. Academy](<https://devfeed.tech/sources/kt-academy.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [clustering](<https://devfeed.tech/topics/clustering.md>), [JSON](<https://devfeed.tech/topics/json.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [clustering](<https://devfeed.tech/tags/clustering.md>), [json](<https://devfeed.tech/tags/json.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [pattern-matching](<https://devfeed.tech/tags/pattern-matching.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [sealed-class](<https://devfeed.tech/tags/sealed-class.md>), [workshop-learning-programming](<https://devfeed.tech/tags/workshop-learning-programming.md>)

### AI overview

This article presents Kotlin solutions for Advent of Kotlin 2021 exercises, including JSON stringification, generating well-formed parentheses, tree algorithms, and k-means clustering. It discusses recursion, sealed classes, smart casting, and Kotlin functions used in the solutions.

### Source excerpt

Solutions to the Advent of Kotlin!

## Taming Deep Recursion

DevFeed: [Taming Deep Recursion](<https://devfeed.tech/articles/taming-deep-recursion-25071.md>)

Original publisher: [Read original article](<https://databasearchitects.blogspot.com/2020/11/taming-deep-recursion.html>)

Author: Thomas Neumann (noreply@blogger.com)

Published: 2020-11-22T16:50:00Z

Content type: tutorial

Language: en

Sources: [Database Architects](<https://devfeed.tech/sources/database-architects.md>)

Topics: [Data structures](<https://devfeed.tech/topics/data-structures.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [Code](<https://devfeed.tech/topics/code.md>), [Exception](<https://devfeed.tech/topics/exception.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [crash](<https://devfeed.tech/tags/crash.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [exception](<https://devfeed.tech/tags/exception.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [snippet](<https://devfeed.tech/tags/snippet.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

The article examines stack overflows caused by recursive traversal of very deep SQL expression and algebra trees. It discusses stack-usage checks, explicit-stack iteration, and compiler-supported split stacks as ways to handle unusually deep inputs while preserving simpler recursive code.

### Source excerpt

When operating on hierarchical data structures, it is often convenient to formulate that using pairwise recursive functions. For example, our semantic analysis walks that parse tree recursively and transforms it into an expression tree. This corresponding code looks roughly like this: unique_ptr<Expression> analyzeExpression(AST* astNode) { switch (astNode->getType()) { case AST::BinaryExpression: return analyzeBinaryExpression(astNode->as<BinaryExpAST>()); case AST::CaseExpression: return analyzeCaseExpression(astNode->as<CaseExpAST>()); ... } } unique_ptr<Expression> analyzeBinaryExpression(BinaryExpAST* astNode) { auto left = analyzeExpression(astNode->left); auto right = analyzeExpression(astNode->right); auto type = inferBinaryType(astNode->getOp(), left, right); return make_unique<BinaryExpression>(astNode->getOp(), move(left), move(right), type); } It recursively walks the tree, collects input expressions, infers types, and constructs new expressions. This works beautifully until you encounter a (generated) query with 300,000 expressions, which we did. At that point our program crashed due to stack overflow. Oops. Our first mitigation was using __builtin_frame_address(0) at the beginning of analyzeExpression to detect excessive stack usage, and to throw an exception if that happens. This prevented the crash, but is not very satisfying. First, it means we refuse a perfectly valid SQL query "just" because it uses 300,000 terms in one expression. And second, we cannot be sure that this is enough. There are several places in the code that recursively walk the algebra tree, and it is hard to predict their stack usage. Even worse, the depth of the tree can change due to optimizations. For example, when a query has 100,000 entries in the from clause, the initial tree is extremely wide but flat. Later, after we have stopped checking for stack overflows, the optimizer might transform that into a tree with 100,000 levels, again leading to stack overflow. Basically, all

## Deep recursion with coroutines

DevFeed: [Deep recursion with coroutines](<https://devfeed.tech/articles/deep-recursion-with-coroutines-26021.md>)

Original publisher: [Read original article](<https://elizarov.medium.com/deep-recursion-with-coroutines-7c53e15993e3?source=rss-4762e889f8fc------2>)

Author: Roman Elizarov

Published: 2020-04-25T20:33:55Z

Content type: tutorial

Language: en

Sources: [Stories by Roman Elizarov on Medium](<https://devfeed.tech/sources/stories-by-roman-elizarov-on-medium.md>)

Topics: [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Data structures](<https://devfeed.tech/topics/data-structures.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [coroutine](<https://devfeed.tech/tags/coroutine.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [exception](<https://devfeed.tech/tags/exception.md>), [jvm](<https://devfeed.tech/tags/jvm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [recursion](<https://devfeed.tech/tags/recursion.md>)

### AI overview

This tutorial explains how Kotlin coroutines can be used to handle deeply recursive functions. Using a 100,000-node binary tree as an example, it shows that ordinary recursion can exhaust the thread call stack and lead to a StackOverflowError, then introduces rewriting the algorithm to use heap memory instead.

### Source excerpt

Photo by Riccardo Pelati on Unsplash Kotlin Coroutines are typically used for asynchronous programming. However, the underlying design of coroutines and their implementation in Kotlin compiler are quite universal, solving problems beyond asynchronous programming. Let's take a look at one such problem that can be elegantly solved with coroutines-- writing deeply recursive functions. Setup Consider a tree data structure. For this example, let's use this simple binary tree where each Tree node has a reference to its left and right children: class Tree(val left: Tree?, val right: Tree?) The depth of the tree is defined as the length of the longest path from its root to its child nodes. It can be computed by the following recursive function: fun depth(t: Tree?): Int = if (t == null) 0 else maxOf( depth(t.left), // recursive call one depth(t.right) // recursive call two ) + 1 The logic here is straightforward. The depth is simply the maximum of the depth of the left and right children plus one, with the special case of zero when the tree is empty. Recursion is a great tool for working with tree-like data structures, but there is a catch. Let's generate a deep tree containing 100K nodes. Start with a leaf node Tree(null, null) as a seed and repeatedly generate parent nodes that link to the previous node as their left children: val n = 100_000 val deepTree = generateSequence(Tree(null, null)) { prev -> Tree(prev, null) }.take(n).last() This is not a particularly big data structure. It occupies less than 2MiB of memory, which is not much at all for a modern machine with gigabytes of available memory. Now, let's try to use our depth function on it: https://medium.com/media/f919e36404c4bf79aef919395ab51918/href If you run it in Kotlin Playground you'll get "Your program produces too much output!" message. If you run the same code on your local machine you'll see what kind of output that is: Exception in thread "main" java.lang.StackOverflowError at FileKt.depth(File.kt:5) ... /

## Yet another explanation of the Quicksort algorithm

DevFeed: [Yet another explanation of the Quicksort algorithm](<https://devfeed.tech/articles/yet-another-explanation-of-the-quicksort-algorithm-20576.md>)

Original publisher: [Read original article](<https://yurichev.com/blog/qsort/>)

Published: 2019-11-22T23:00:00Z

Content type: tutorial

Language: en

Sources: [Dennis Yurichev](<https://devfeed.tech/sources/dennis-yurichev.md>)

Topics: [Sorting](<https://devfeed.tech/topics/sorting.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [C](<https://devfeed.tech/topics/c.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [Haskell](<https://devfeed.tech/topics/haskell.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [c](<https://devfeed.tech/tags/c.md>), [go-language](<https://devfeed.tech/tags/go-language.md>), [partitioning](<https://devfeed.tech/tags/partitioning.md>), [python](<https://devfeed.tech/tags/python.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [sorting](<https://devfeed.tech/tags/sorting.md>)

### AI overview

An explanation of the Quicksort algorithm, contrasting a mean-based partitioning approach with randomized and classic in-place implementations. It also discusses recursive partitioning and switching to another sorting algorithm for small arrays.

### Source excerpt

Yet another explanation of the Quicksort algorithm

## Kotlin-Java Interop Can Cause Recursive Property Calls

DevFeed: [Kotlin-Java Interop Can Cause Recursive Property Calls](<https://devfeed.tech/articles/kotlin-stackoverflow-error-28672.md>)

Original publisher: [Read original article](<https://jeroenmols.com/blog/2018/11/01/kotlinstackoverflow/>)

Author: info@jeroenmols.com (Jeroen Mols)

Published: 2018-11-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [Jeroen Mols](<https://devfeed.tech/sources/jeroen-mols.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Java](<https://devfeed.tech/topics/java.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>)

Tags: [android-studio](<https://devfeed.tech/tags/android-studio.md>), [blogs](<https://devfeed.tech/tags/blogs.md>), [java](<https://devfeed.tech/tags/java.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [legacy-code](<https://devfeed.tech/tags/legacy-code.md>), [puzzle](<https://devfeed.tech/tags/puzzle.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [stackoverflow](<https://devfeed.tech/tags/stackoverflow.md>)

### AI overview

This article explains how Kotlin-Java interop can cause a property access to call itself recursively when inheriting from a Java class. It examines the resulting bytecode and notes that Android Studio can warn about the recursion.

### Source excerpt

Java interop is one of the best features of the Kotlin language, yet sometimes this also can cause unforeseen issues... Puzzle # Disclaimer, the example below is a consequence of legacy code and only serves to demonstrate a Kotlin puzzler.

## Let's Build A Simple Interpreter. Part 6.

DevFeed: [Let's Build A Simple Interpreter. Part 6.](<https://devfeed.tech/articles/let-s-build-a-simple-interpreter-part-6-33327.md>)

Original publisher: [Read original article](<https://ruslanspivak.com/lsbasi-part6/>)

Author: Ruslan Spivak

Published: 2015-11-02T12:00:00Z

Content type: tutorial

Language: en

Sources: [Ruslan Spivak](<https://devfeed.tech/sources/ruslan-spivak.md>)

Topics: [Parsing](<https://devfeed.tech/topics/parsing.md>), [syntax](<https://devfeed.tech/topics/syntax.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [code](<https://devfeed.tech/tags/code.md>), [expression](<https://devfeed.tech/tags/expression.md>), [lexer](<https://devfeed.tech/tags/lexer.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [syntax](<https://devfeed.tech/tags/syntax.md>), [tokens](<https://devfeed.tech/tags/tokens.md>)

### AI overview

This tutorial extends an arithmetic-expression grammar to support parenthesized expressions with arbitrarily deep nesting. It updates the lexer and interpreter to evaluate expressions containing integers and arithmetic operators.

### Source excerpt

Today is the day :) "Why?" you might ask. The reason is that today we're wrapping up our discussion of arithmetic expressions (well, almost) by adding parenthesized expressions to our grammar and implementing an interpreter that will be able to evaluate parenthesized expressions with arbitrarily deep nesting, like the expression ...

## Reducers explained (through Python)

DevFeed: [Reducers explained (through Python)](<https://devfeed.tech/articles/reducers-explained-through-python-32155.md>)

Original publisher: [Read original article](<https://adambard.com/blog/reducers-explained-through-python/>)

Published: 2013-07-07T00:00:00Z

Content type: tutorial

Language: en

Sources: [Adam Bard](<https://devfeed.tech/sources/adam-bard.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Clojure](<https://devfeed.tech/topics/clojure.md>), [Elixir](<https://devfeed.tech/topics/elixir.md>), [Library](<https://devfeed.tech/topics/library.md>), [Code](<https://devfeed.tech/topics/code.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [clojure](<https://devfeed.tech/tags/clojure.md>), [code](<https://devfeed.tech/tags/code.md>), [collections](<https://devfeed.tech/tags/collections.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [filter](<https://devfeed.tech/tags/filter.md>), [functional](<https://devfeed.tech/tags/functional.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [list](<https://devfeed.tech/tags/list.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [reduce](<https://devfeed.tech/tags/reduce.md>)

### AI overview

This tutorial explains reducers through Python. It introduces reduce or fold as a fundamental collection operator, shows how map and filter can be built from it, and describes how reducers combine collection operations into a single pass instead of repeatedly iterating over a list.

### Source excerpt

Last year, Clojure introduced a new library called core.reducers, which represented a new, efficient way to deal with operations across collections in functional languages. It's since been picked up by Elixir, and libraries have been written for some other languages. Today, I want to explain a bit about what reducers are, why they exist, and how they can be more efficient than other functional methods of handling collections, and help you write your code more prettier.

## Seven Languages in Seven Weeks: Erlang

DevFeed: [Seven Languages in Seven Weeks: Erlang](<https://devfeed.tech/articles/seven-languages-in-seven-weeks-erlang-37840.md>)

Original publisher: [Read original article](<https://carlosbecker.com/posts/seven-languages-in-seven-weeks-erlang/>)

Author: Carlos Alexandro Becker

Published: 2012-12-18T00:00:00Z

Content type: tutorial

Language: en

Sources: [Carlos Becker](<https://devfeed.tech/sources/carlos-becker.md>)

Topics: [Erlang](<https://devfeed.tech/topics/erlang.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [function](<https://devfeed.tech/topics/function.md>), [pattern matching](<https://devfeed.tech/topics/pattern-matching.md>), [Processes](<https://devfeed.tech/topics/processes.md>)

Tags: [concurrency](<https://devfeed.tech/tags/concurrency.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [function](<https://devfeed.tech/tags/function.md>), [pattern-matching](<https://devfeed.tech/tags/pattern-matching.md>), [process](<https://devfeed.tech/tags/process.md>), [recursion](<https://devfeed.tech/tags/recursion.md>)

### AI overview

A beginner documents working through Erlang exercises from "Seven Languages in Seven Weeks," covering recursion, pattern matching, list comprehensions, regular expressions, concurrency, process monitoring, and process restarts. The author notes that some solutions may contain errors while learning the language.

### Source excerpt

So, I just bought "Seven Languages in Seven Weeks". I've read the Ruby chapter, not a big deal at all, so I skipped it. I also skip Io, Prolog and Scala (for now), and then, fall in Erlang!

## A Spoonful of Python (and Dynamic Programming)

DevFeed: [A Spoonful of Python (and Dynamic Programming)](<https://devfeed.tech/articles/a-spoonful-of-python-and-dynamic-programming-40254.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2012/01/12/a-spoonful-of-python/>)

Published: 2012-01-12T23:11:26Z

Content type: tutorial

Language: en

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

Topics: [Python](<https://devfeed.tech/topics/python.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>)

Tags: [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [fibonacci](<https://devfeed.tech/tags/fibonacci.md>), [memoized-recursion](<https://devfeed.tech/tags/memoized-recursion.md>), [primer](<https://devfeed.tech/tags/primer.md>), [python](<https://devfeed.tech/tags/python.md>), [recursion](<https://devfeed.tech/tags/recursion.md>)

### AI overview

A Python primer covering built-in types such as lists, tuples, and dictionaries, with examples involving Fibonacci numbers and optimal coin change. It introduces dynamic programming and compares inefficient recursive and recursionless approaches.

### Source excerpt

This primer is a third look at Python, and is admittedly selective in which features we investigate (for instance, we don't use classes, as in our second primer on random psychedelic images). We do assume some familiarity with the syntax and basic concepts of the language. For a first primer on Python, see A Dash of Python. We'll investigate some of Python's useful built-in types, including lists, tuples, and dictionaries, and we use them to computing Fibonacci numbers and "optimal" coin change.

## Turing Machines and Conway's Dreams

DevFeed: [Turing Machines and Conway's Dreams](<https://devfeed.tech/articles/turing-machines-and-conway-s-dreams-40215.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/06/30/turing-machines-and-conways-dreams/>)

Published: 2011-06-30T20:50:04Z

Content type: tutorial

Language: en

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

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

Tags: [cellular](<https://devfeed.tech/tags/cellular.md>), [cellular-automata](<https://devfeed.tech/tags/cellular-automata.md>), [computability-theory](<https://devfeed.tech/tags/computability-theory.md>), [computational-complexity](<https://devfeed.tech/tags/computational-complexity.md>), [conway](<https://devfeed.tech/tags/conway.md>), [infinite](<https://devfeed.tech/tags/infinite.md>), [life](<https://devfeed.tech/tags/life.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [patterns](<https://devfeed.tech/tags/patterns.md>), [period](<https://devfeed.tech/tags/period.md>), [programming](<https://devfeed.tech/tags/programming.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [theory](<https://devfeed.tech/tags/theory.md>), [turing-machine](<https://devfeed.tech/tags/turing-machine.md>), [turing-machines](<https://devfeed.tech/tags/turing-machines.md>)

### AI overview

The article examines Conway's Game of Life patterns that do not stabilize, including Gosper's glider gun and puffers that produce continuing activity. It connects these patterns to computability, explaining that infinite looping is necessary for Turing-complete computation.

### Source excerpt

Additional Patterns Last time we left the reader with the assertion that Conway's game of life does not always stabilize. Specifically, there exist patterns which result in unbounded cell population growth. Although John Conway's original conjecture was that all patterns eventually stabilize (and offered $50 to anyone who could provide a proof or counterexample), he was proven wrong. Here we have the appropriately named glider gun, whose main body oscillates, expelling a glider once per period.

## Well Orderings and Search

DevFeed: [Well Orderings and Search](<https://devfeed.tech/articles/well-orderings-and-search-40202.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2011/06/14/well-orderings-and-search/>)

Published: 2011-06-14T11:18:04Z

Content type: tutorial

Language: en

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

Topics: [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>), [ordering](<https://devfeed.tech/topics/ordering.md>), [implementation](<https://devfeed.tech/topics/implementation.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [axiom-of-choice](<https://devfeed.tech/tags/axiom-of-choice.md>), [binary-search](<https://devfeed.tech/tags/binary-search.md>), [mathematica](<https://devfeed.tech/tags/mathematica.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [pseudocode](<https://devfeed.tech/tags/pseudocode.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [well-ordering](<https://devfeed.tech/tags/well-ordering.md>)

### AI overview

This tutorial explains binary search on sorted lists, including its recursive structure and O(log n) runtime. It then introduces strict total and well orders to explain why sorting and comparison work.

### Source excerpt

Binary Search Binary search is perhaps the first and most basic nontrivial algorithm a student learns. For the mathematicians out there, binary search is a fast procedure to determine whether a sorted list contains a particular element. Here is a pseudocode implementation: # Binary Search: # Given a list L, sorted via the total order <, and a sought # element x, return true iff L contains x. function binarySearch(L, x, <): # base case if(length(L) == 1): return L[0] == x middleIndex = floor(length(L) / 2) if (L[middleIndex] == x): return true # inductive step, with ellipsis notation meaning slices of L # from the beginning and to the end, respectively if (x < L[middleIndex]): return binarySort(L[.

## Erlang talk at London Hackspace

DevFeed: [Erlang talk at London Hackspace](<https://devfeed.tech/articles/erlang-talk-at-london-hackspace-25819.md>)

Original publisher: [Read original article](<https://www.metabrew.com/article/erlang-talk-at-london-hackspace>)

Author: {"image"=\>"rj-headshot.jpg", "greetings"=\>nil}

Published: 2009-10-08T05:00:00Z

Content type: article

Language: en

Sources: [Richard Jones](<https://devfeed.tech/sources/richard-jones.md>)

Topics: [Erlang](<https://devfeed.tech/topics/erlang.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Functional programming](<https://devfeed.tech/topics/functional-programming.md>), [Processes](<https://devfeed.tech/topics/processes.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [erlang](<https://devfeed.tech/tags/erlang.md>), [functional-programming](<https://devfeed.tech/tags/functional-programming.md>), [hackspace](<https://devfeed.tech/tags/hackspace.md>), [london](<https://devfeed.tech/tags/london.md>), [messages](<https://devfeed.tech/tags/messages.md>), [mochiweb](<https://devfeed.tech/tags/mochiweb.md>), [playdar](<https://devfeed.tech/tags/playdar.md>), [processes](<https://devfeed.tech/tags/processes.md>), [recursion](<https://devfeed.tech/tags/recursion.md>), [state](<https://devfeed.tech/tags/state.md>), [talk](<https://devfeed.tech/tags/talk.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>), [upgrade](<https://devfeed.tech/tags/upgrade.md>)

### AI overview

This article recaps an introductory Erlang talk at a London Hackspace meetup. It explains Erlang's use for scalable, reliable distributed systems and demonstrates processes, message passing, recursive state management, hot code reloading, and gen_server.

### Source excerpt

Last night I gave an "Intro to Erlang" talk at a London Hackspace meetup. I did a quick audience survey first: About 75% did "web programming" (ruby,python,php,etc). Around 30% admitted to regularly using C/C++/Java or desktop/mobile app development. Less than 10% had much experience with functional programming.