<?xml version='1.0' encoding='UTF-8'?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
  <id>https://www.baturin.org/atom.xml</id>
  <title>Daniil Baturin's blog</title>
  <updated>2023-07-23T00:00:00+00:00</updated>
  <author>
    <name>Daniil Baturin</name>
    <email>daniil+website@baturin.org</email>
  </author>
  <generator uri="https://soupault.app" version="4.6.0">soupault</generator>
  <logo>https://baturin.org/images/favicon.png</logo>
  <subtitle>Programming and other subjects</subtitle>
  <entry>
    <id>https://www.baturin.org/blog/an-chead-bliana-in-eirinn</id>
    <title>An Chéad Bhliain in Éirinn / The first year in Ireland</title>
    <updated>2023-07-23T00:00:00+00:00</updated>
    <content type="html">
    It&apos;s been a year since I moved to Ireland, and I thought I could as well write a recollection
to remember the good moments of that year (there are many!) and reflect on them.
In short, I like it here, and I&apos;m grateful to everyone who helped me on the way.
There are many great people I wouldn&apos;t have met and many experiences I wouldn&apos;t have had
if I didn&apos;t come here. Here&apos;s a list of unrelated memories (mostly narrated in present tense, as an aesthetic choice)
and observations in vaguely chronological order.
    </content>
    <link href="https://www.baturin.org/blog/an-chead-bliana-in-eirinn" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/margarine-or-butter</id>
    <title>Margarine or butter: the secret ingredient of storytelling</title>
    <updated>2023-06-16T00:00:00+00:00</updated>
    <content type="html">
    When &lt;a href=&quot;https://en.wikipedia.org/wiki/The_Quiet_Girl&quot;&gt;An Cailín Ciúin&lt;/a&gt; got nominated for the Academy Award, I felt like a hipster
because I watched it before it was mainstream. I just went to watch it at UCC
with &lt;abbr title=&quot;The Gaelic Society&quot;&gt;An Chuallacht Ghaelach&lt;/abbr&gt; to practice listening to Irish, without any expectations
for the film itself but quickly reaized that the film and the story it was based on
were certainly very special — not merely beautiful but also very carefully crafted.
But I wouldn&apos;t be myself if I didn&apos;t make a silly joke and claim that the most important
unanswered question is whether Mrs. Kinsella uses margarine or butter for baking.
    </content>
    <link href="https://www.baturin.org/blog/margarine-or-butter" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/music-school-memories</id>
    <title>Music school memories</title>
    <updated>2023-06-11T00:00:00+00:00</updated>
    <content type="html">
    If you haven&apos;t heard that story, I studied clarinet performance in a classical music school from 2018 to 2022
and dropped out three months before my graduation... for a reason unrelated to the school itself, but let&apos;s not talk about that here.
I want to talk about the impact it had on me and share some funny stories from that time.
    </content>
    <link href="https://www.baturin.org/blog/music-school-memories" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/an-bhfuil-cead-agam-dul-go-dti-an-leithreas</id>
    <title>An bhfuil cead agam dul go dtí an leithreas? — a primer on Irish syntax</title>
    <updated>2023-06-01T00:00:00+00:00</updated>
    <content type="html">
    Some claim that &lt;em&gt;An bhfuil cead agam dul go dtí an leithreas?&lt;/em&gt; (May I go to the toilet?)
is often the only phrase that people remember from their Irish lessons in school,
and some use it to prank people unfamiliar with the language by claiming that it&apos;s how you say
“You will forever be in my heart” or similar.
However, that phrase actually makes an excellent illustration of the basic Irish morphology and syntax,
so let&apos;s examine it in detail.
    </content>
    <link href="https://www.baturin.org/blog/an-bhfuil-cead-agam-dul-go-dti-an-leithreas" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/learning-languages</id>
    <title>Learning languages</title>
    <updated>2022-11-12T00:00:00+00:00</updated>
    <content type="html">
    During this year, I have learned two completely unrelated (human) languages to a semblance of A1.
Many people claim that I have a talent for learning languages but I don&apos;t think it&apos;s the case.
I just have more experience and tools for learning them. I decided to write down some notes
that I hope can help other language learners, starting from pretty obvious facts that I didn&apos;t consciously realize
until some point and ending with somewhat controversial opinions.
    </content>
    <link href="https://www.baturin.org/blog/learning-languages" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/private-network-design</id>
    <title>Private network design basics</title>
    <updated>2022-01-16T00:00:00+00:00</updated>
    <content type="html">
    People without much networking experience may think that network design is something that is done for large organizations
by highly experienced specialists with fancy titles, while small networks
don&apos;t need any design at all. However, most networks start small and grow larger than anyone might have planned,
and the &quot;no design&quot; approach quickly shows its limits. Worse yet, changing the design of a production network
is much harder than building a network from scratch—even a very small network can take hours to reconfigure for a new addressing scheme
and ensure that everything is working correctly. Luckily, if you know a few facts and principles,
you can avoid most mistakes that take a lot of effort to fix.
If you are starting a network and want to get it right, read on.
    </content>
    <link href="https://www.baturin.org/blog/private-network-design" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/code-hosting-needs-federation</id>
    <title>Can non-federated code hosting replace GitHub?</title>
    <updated>2021-08-25T00:00:00+00:00</updated>
    <content type="html">
    You guessed my answer right: I believe federation is the only hope for decentralizing developer collaboration.
To back up this claim, I examine contribution patterns in a project that was moved
from a self-hosted MediaWiki &lt;em&gt;to&lt;/em&gt; GitHub—the repository with VyOS documentation. The key finding is that most contributor
accounts are older than the repository, so ability to use an existing account for contributing was likely crucial
for their decision to contribute.
    </content>
    <link href="https://www.baturin.org/blog/code-hosting-needs-federation" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/life-before-unicode</id>
    <title>Life before Unicode</title>
    <updated>2021-08-21T00:00:00+00:00</updated>
    <content type="html">
    Unicode definitely added a lot of complexity to string handling,
and people who use languages with ASCII alphabets exclusively may think it&apos;s unjustified.
However, I&apos;m a non-ASCII language speaker who&apos;s old enough to remember the alternatives,
and the alternatives are far worse than the complexity of Unicode.
    </content>
    <link href="https://www.baturin.org/blog/life-before-unicode" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/ccna-200-301-2021</id>
    <title>CCNA 200-301</title>
    <updated>2021-06-25T00:00:00+00:00</updated>
    <content type="html">
    Today I passed Cisco&apos;s CCNA 200-301 certification exam. In short, they fixed a lot of old problems
but added a few new ones. However, it&apos;s still much closer to an exam that a working network administrator
can walk into from the street and pass, compared to the last time I&apos;ve seen it. In this post I&apos;ll try to offer some preparation tips.
    </content>
    <link href="https://www.baturin.org/blog/ccna-200-301-2021" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/why-not-hugo</id>
    <title>Why not Hugo</title>
    <updated>2021-06-04T00:00:00+00:00</updated>
    <content type="html">
    People sometimes ask me why I wrote my own &lt;a href=&quot;https://soupault.app&quot;&gt;static site generator&lt;/a&gt; instead of using an existing one.
A lof of time their suggestion is Hugo. Well, a lot of the time I use Hugo as an example of what &lt;em&gt;not to do&lt;/em&gt;.
It suffers from creeping compatibility breakage and I find it highly limiting in many areas. I&apos;m not planning to use it and not recommend it to anyone else.
For the details, read on.
    </content>
    <link href="https://www.baturin.org/blog/why-not-hugo" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/lua-ml-embedding-and-projection</id>
    <title>Embedding and projection in Lua-ML</title>
    <updated>2020-08-28T00:00:00+00:00</updated>
    <content type="html">
    One thing I find odd about many interpreter projects is that they are designed as standalone and can&apos;t be used as embedded
scripting languages. Lua-ML is completely different in that regard: it&apos;s designed as an extension language first and offers
some unique features for that use case, including a reconfigurable runtime library. You can remove modules from its standard library or replace
them with your own implementations. Of course, you can also pass OCaml values to Lua code and take them back in a type-safe manner too.
That aspect isn&apos;t very obvious or well-documented, so in this post we&apos;ll try to uncover it.
    </content>
    <link href="https://www.baturin.org/blog/lua-ml-embedding-and-projection" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/js-like-its-2006</id>
    <title>Bundle NPM modules into static JS libraries like it’s 2006</title>
    <updated>2020-08-19T00:00:00+00:00</updated>
    <content type="html">
    A good thing about browser implementations of JavaScript is compatibility. The NPM ecosystem, however, is infamous for its fragility.
As a professional “not a frontend developer” I try to opt out of it as much as possible.
Luckily, if you just need a library from NPM, it&apos;s easy to package it into an “eternal” blob that will work forever.
In this post I&apos;ll share my procedure for creating such static JS blobs from NPM modules.
    </content>
    <link href="https://www.baturin.org/blog/js-like-its-2006" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/migrating-the-blog-to-soupault</id>
    <title>Migrating the blog to soupault</title>
    <updated>2020-04-05T00:00:00+00:00</updated>
    <content type="html">
    I&apos;ve migrated my blog to &lt;a href=&quot;https://soupault.neocities.org&quot;&gt;soupault&lt;/a&gt;. I hope it didn&apos;t break too many
links or anything else, if you spot a problem, let me know. If you are interested in the details of the migration,
read on. However, note that this post is a bit too full of idle musings on blogs, universe, and everything.
If a list of pages sorted by date is all you want, read &lt;a href=&quot;https://soupault.neocities.org/blog/blogs-and-section-indices/&quot;&gt;this post&lt;/a&gt;
instead.
    </content>
    <link href="https://www.baturin.org/blog/migrating-the-blog-to-soupault" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/if-you-think-reasonml-compiles-to-js-you-are-wrong</id>
    <title>If you think ReasonML compiles to JS, you are wrong</title>
    <updated>2019-09-05T00:00:00+00:00</updated>
    <content type="html">
    In this post we&apos;ll examine what &lt;a href=&quot;https://reasonml.github.io/&quot;&gt;ReasonML&lt;/a&gt; really is and what it compiles to.
Everyone coming from the ML community already knows the truth, but in the JS community, this misconception
seems surprisingly common. It&apos;s not just about giving credit, but about the true potential of the language
that is far greater than that of TypeScript or Elm.
    </content>
    <link href="https://www.baturin.org/blog/if-you-think-reasonml-compiles-to-js-you-are-wrong" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/declarative-parse-error-reporting-with-menhir</id>
    <title>Declarative parse error reporting with Menhir</title>
    <updated>2019-08-24T00:00:00+00:00</updated>
    <content type="html">
    Many parsers for custom formats aren&apos;t very user friendly when it comes to error handling.
At best you get the line and column where the error is, at worst a “Parse error”
message is all you get. Can we do better? With right tools, we definitely can and it&apos;s not that hard.
    </content>
    <link href="https://www.baturin.org/blog/declarative-parse-error-reporting-with-menhir" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/extending-ocaml-programs-with-lua-soupault-got-plugin-support</id>
    <title>Extending OCaml programs with Lua (soupault got plugin support)</title>
    <updated>2019-08-10T00:00:00+00:00</updated>
    <content type="html">
    Most of the time, when people make extensible programs in typed functional languages,
they make a DSL, not least because it&apos;s much easier to make a DSL in a language with algebraic types
and pattern matching than in one without.&lt;br&gt;
Some use cases really require a general-purpose language though. That&apos;s where things get
more interesting. Commonly used embeddable interpreters such as Lua, Guile, or Chicken are written in C.
It&apos;s possible to make OCaml or Haskell bindings for them and such bindings do exist,
but that&apos;s two high level languages communicating through a low level one.&lt;br&gt;
It would be much better to be able to expose native types to the embedded language in a type-safe and more or less convenient
fashion. Here&apos;s my take at it.
    </content>
    <link href="https://www.baturin.org/blog/extending-ocaml-programs-with-lua-soupault-got-plugin-support" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/migrating-to-the-new-server-part-2-moving-from-cyrus-to-dovecot</id>
    <title>Migrating to the new server part 2: moving from Cyrus to Dovecot</title>
    <updated>2018-08-19T00:00:00+00:00</updated>
    <content type="html">
    It&apos;s been a while since I published the &lt;a href=&quot;/blog/migrating-to-the-new-server-part-1-base-system-and-the-web-server&quot;&gt;first part&lt;/a&gt;.
In case you were worrying how the rest of migration went, well, I ended up with an operational system quickly, even if because I decided not to change
the rest of it yet. However, a bug in Cyrus IMAPd made me make perhaps the biggest change in my email setup since its inception.
This post chronicles my migration to Dovecot.
    </content>
    <link href="https://www.baturin.org/blog/migrating-to-the-new-server-part-2-moving-from-cyrus-to-dovecot" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/introduction-to-ocaml-part-5-exceptions-lists-and-structural-recursion</id>
    <title>Introduction to OCaml, part 5: exceptions, lists, and structural recursion</title>
    <updated>2018-08-18T00:00:00+00:00</updated>
    <content type="html">
    In OCaml, exceptions are not objects, and there are no exception hierarchies. It may look unusual now,
but in fact exceptions predate the rise of object oriented languages and it&apos;s more in line with original
implementations. The advantage is that they are very lightweight.
    </content>
    <link href="https://www.baturin.org/blog/introduction-to-ocaml-part-5-exceptions-lists-and-structural-recursion" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/introduction-to-ocaml-part-4-higher-order-functions-parametric-polymorphism-and-algebraic-data-types</id>
    <title>Introduction to OCaml, part 4: higher order functions, parametric polymorphism and algebraic data types</title>
    <updated>2018-08-12T00:00:00+00:00</updated>
    <content type="html">
    So far we have only worked with functions that take value of a single type known beforehand.
However, we have already seen functions whose types were left without explanation, such as
&lt;code&gt;let hello _ = print_endline &quot;hello world&quot;&lt;/code&gt; that we used to demonstrate the wildcard pattern.
&lt;br&gt;
What is its type? If you enter it into the REPL, you will see that it&apos;s &lt;code&gt;&apos;a -&amp;gt; unit&lt;/code&gt;.
What does the mysterious &apos;a mean? Simply put, it&apos;s a placeholder for any type.
Essentially, a variable for types —a &lt;em&gt;type variable&lt;/em&gt;.
    </content>
    <link href="https://www.baturin.org/blog/introduction-to-ocaml-part-4-higher-order-functions-parametric-polymorphism-and-algebraic-data-types" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/introduction-to-ocaml-part-3</id>
    <title>Introduction to OCaml, part 3</title>
    <updated>2018-08-08T00:00:00+00:00</updated>
    <content type="html">
    This should have been covered earlier, but better late than even later.
In this chapter we&apos;ll learn about booleans and conditional expressions.
    </content>
    <link href="https://www.baturin.org/blog/introduction-to-ocaml-part-3" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/introduction-to-ocaml-part-2</id>
    <title>Introduction to OCaml, part 2</title>
    <updated>2018-08-07T00:00:00+00:00</updated>
    <content type="html">
    In the previous chapter we&apos;ve learnt how to use variables and arithmetic functions.
Now it&apos;s time to learn how to make our own functions.
    </content>
    <link href="https://www.baturin.org/blog/introduction-to-ocaml-part-2" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/introduction-to-ocaml</id>
    <title>Introduction to OCaml</title>
    <updated>2018-08-06T00:00:00+00:00</updated>
    <content type="html">
    This post series started as a response to requests from some friends curious about OCaml.
There are quite a few nice books already, but I realized that if I just recommend them any one of those
books, it still will leave me with quite a few things to explain in depth, or force me to recommend another
just to learn about that part. So I thought I may as well write something that hopefully will allow
a person who already knows how to program in some other language get started with writing OCaml programs
and continue learning on their own and find their own sources.
    </content>
    <link href="https://www.baturin.org/blog/introduction-to-ocaml" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/implementing-sets-with-functions-alone</id>
    <title>Implementing sets with functions alone</title>
    <updated>2018-04-12T00:00:00+00:00</updated>
    <content type="html">
    Implementation of sets using nothing but functions would be one of the first tricks in the
“100 Fun Things to Do With Functions and Closures” book if that book existed.
It may not be very practical, but it may help people get into the functional mindset.
We&apos;ll use &lt;a href=&quot;http://ocaml.org&quot;&gt;OCaml&lt;/a&gt; for demonstration.
    </content>
    <link href="https://www.baturin.org/blog/implementing-sets-with-functions-alone" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/hello-from-a-compiler-free-x86-64-world</id>
    <title>Hello from a compiler-free x86-64 world</title>
    <updated>2018-04-07T00:00:00+00:00</updated>
    <content type="html">
    I&apos;ve stumbled upon &lt;a href=&quot;https://blogs.oracle.com/ksplice/hello-from-a-libc-free-world-part-1&quot;&gt;two&lt;/a&gt;
&lt;a href=&quot;https://blogs.oracle.com/ksplice/hello-from-a-libc-free-world-part-2&quot;&gt;posts&lt;/a&gt; where Jessica McKellar
demonstrates how to make a C program on Linux without using libc. They were written in 2010 when
32-bit x86 was far from extinct though, and use the old 32-bit ABI—a problem most examples
of low level programming on UNIX-like systems suffer from, even if it&apos;s not their fault.
    </content>
    <link href="https://www.baturin.org/blog/hello-from-a-compiler-free-x86-64-world" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/installing-python-package-data-by-relative-path</id>
    <title>Installing Python package data by relative path</title>
    <updated>2018-04-02T00:00:00+00:00</updated>
    <content type="html">
    Package data installation sometimes requires balance between ease of writing installation procecures for it
and ease of accessing that data. That&apos;s especially apparent when someone who is not a developer wants to be
able to edit that data in place. Editing it in place is a bad practice of course, but sometimes that&apos;s just
what you get. For example, if there are two people of whom one is a developer who wrote code solely from data format
specification, and the other understands what the data actually means but has no coding skills.
    </content>
    <link href="https://www.baturin.org/blog/installing-python-package-data-by-relative-path" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/network-access-and-authentication-in-cisco-catalyst-switches</id>
    <title>Network access and authentication in Cisco Catalyst switches</title>
    <updated>2018-03-31T00:00:00+00:00</updated>
    <content type="html">
    From the fact that I&apos;m a &lt;a href=&quot;https://vyos.io&quot;&gt;VyOS&lt;/a&gt; maintainer, you can guess that I&apos;m not a fan of Cisco routers,
but I&apos;m a big fan of Cisco Catalyst switches. They have never failed me yet, and among all L2 switches they have
the least annoying CLI, even though it does have its issues. For L3 switches there may be better alternatives,
but for L2, I haven&apos;t seen anything better than Catalyst so far.
    </content>
    <link href="https://www.baturin.org/blog/network-access-and-authentication-in-cisco-catalyst-switches" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/mtu-calculator-makeover</id>
    <title>MTU calculator makeover</title>
    <updated>2018-03-14T00:00:00+00:00</updated>
    <content type="html">
    A new version of encapcalc, an MTU/MSS calculator, is now live at &lt;a href=&quot;https://baturin.org/tools/encapcalc&quot;&gt;baturin.org/tools/encapcalc&lt;/a&gt;,
with an improved and sort of mobile friendly UI.
    </content>
    <link href="https://www.baturin.org/blog/mtu-calculator-makeover" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/migrating-to-the-new-server-part-1-base-system-and-the-web-server</id>
    <title>Migrating to the new server part 1: base system and the web server</title>
    <updated>2018-03-09T00:00:00+00:00</updated>
    <content type="html">
    My current VPS is running CentOS 6, and, frankly, it long started showing its age. Not very surprising if we remember that
it was released in 2011. Even with all efforts from EPEL, Remi, and Software Collections maintainers, running new applications
on new OS versions is obviously easier than on old verions. That&apos;s why I decided to migrate to Fedora, and it was much easier
than I thought.
    </content>
    <link href="https://www.baturin.org/blog/migrating-to-the-new-server-part-1-base-system-and-the-web-server" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/anycast-routing</id>
    <title>Anycast routing</title>
    <updated>2018-02-28T00:00:00+00:00</updated>
    <content type="html">
    It is well known that due to limited practical size of a UDP packet that can be transmitted without
fragmentation, the number of DNS root servers is limited to 13 addresses. There are indeed 13 root servers
named from A to M (a.root-servers.net, b.root-servers.net and so on).
However, if you visit &lt;a href=&quot;http://root-servers.org/&quot;&gt;root-servers.org&lt;/a&gt;, you can see that most of those servers
somehow have dozens and even hundreds locations around the world. How is it possible for one server to
have more than one location? The answer is &lt;em&gt;anycast routing&lt;/em&gt;.
    </content>
    <link href="https://www.baturin.org/blog/anycast-routing" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/duck-typing</id>
    <title>Duck typing</title>
    <updated>2018-02-21T00:00:00+00:00</updated>
    <content type="html">
    So called “duck typing” is often poorly explained and thus often misunderstood.
Its name and the adage associated with it (“if it walks like a duck and quacks like a duck,
then it is a duck”) don&apos;t do it any favors either.
    </content>
    <link href="https://www.baturin.org/blog/duck-typing" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/yet-another-dmbaturins-blog-iteration</id>
    <title>Yet another dmbaturin’s blog iteration</title>
    <updated>2018-02-20T00:00:00+00:00</updated>
    <content type="html">
    Looks like my blogging cycle is two years in and two years out. Not that I run out of things
to write about, it&apos;s just that good technical writing is a surprisingly time consuming endeavor.
You get to verify every example, check every proof, look up every detail in the standards and so on.
The world doesn&apos;t need more posts that create more troubles for the reader than they solve.&lt;br&gt;
Still last time what drove me away from blogging was, surprisingly, the tools. So many blogging
platforms are horrible, and finding a good one is a challenge.
    </content>
    <link href="https://www.baturin.org/blog/yet-another-dmbaturins-blog-iteration" rel="alternate"/>
  </entry>
  
  <entry>
    <id>https://www.baturin.org/blog/linux-api</id>
    <title>Linux API without lies for children</title>
    <updated></updated>
    <content type="html">
    One day my friend and I were arguing about the UNIX philosophy.
The starting point was my explanation of &lt;code&gt;/proc/cpuinfo&lt;/code&gt; to beginners,
which went along these lines:
    </content>
    <link href="https://www.baturin.org/blog/linux-api" rel="alternate"/>
  </entry>
  
</feed>