<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
	<atom:link href="https://www.gingerbill.org/article/index.xml" rel="self" type="application/rss+xml" />
	<title>gingerBill - Articles</title>
	<link>https://www.gingerbill.org/article/</link>
	<description>Articles by gingerBill</description>
	<item>
		<title>Good Tools Are Invisible</title>
		<link>https://www.gingerbill.org/article/2026/07/10/good-tools-are-invisible/</link>
		<guid>https://www.gingerbill.org/article/2026/07/10/good-tools-are-invisible/</guid>
		<pubDate>Fri, 10 Jul 2026 09:00:00 +0000</pubDate>
		<description>TL;DR: A good tool is and ought to be invisiblestriving to make such tools is the goal of a toolmaker.One habit I see a lot, and have to push back on, is taking a tool;s shortcomings and reselling them as a ;puzzle game; which is ;fun; to solve.I don;t want my tools to be ;fun;. I want my tools to be invisible.Text Editor WarsLet;s take vim as an example  This is just an example, and applies to other editors too.. I constantly see some people praise it not for what actually makes it good, but by taking the things ...</description>
	</item>
	<item>
		<title>The Aesthetic Problem of Namespacing</title>
		<link>https://www.gingerbill.org/article/2026/05/13/aesthetic-namespacing/</link>
		<guid>https://www.gingerbill.org/article/2026/05/13/aesthetic-namespacing/</guid>
		<pubDate>Wed, 13 May 2026 09:00:00 +0000</pubDate>
		<description>Karl Zylinski;s Tom;s Namespaces: An Odin Fanfic is an excellent exploration of the namespacing problem in imperative programming languages such as Odin  I highly recommend reading that article before reading this one!. After sharing it on many comment forum sites, I;ve concluded there;s no real ;solution.; AssociationThe article uses a simple example:The aesthetic argument against this form of namespacing is that this looks fine with short 1/2 word length type names, but becomes unwieldy with longer ones like :The proposed fix ...</description>
	</item>
	<item>
		<title>Signed By Default Camp</title>
		<link>https://www.gingerbill.org/article/2026/05/03/signed-by-default/</link>
		<guid>https://www.gingerbill.org/article/2026/05/03/signed-by-default/</guid>
		<pubDate>Sun, 03 May 2026 09:00:00 +0000</pubDate>
		<description>As with many discussions in the programming space, there are ;wars; between different ways of doing things. These are typically about minor aesthetic preferences, such as:Tabs vs Spaces for indentation vs  vs  for naming conventions vs  for strings (if the language allows both)1TBS vs K;R vs Allman for  brace stylesThese wars are largely pointless; what actually matters is coherency and consistency in your coding style. However, when it comes to designing a language, some binary choices have a massive impact. This article focuses on one such ...</description>
	</item>
	<item>
		<title>Blessed Syntax and Ergonomics</title>
		<link>https://www.gingerbill.org/article/2026/04/29/blessed-syntax-and-ergonomics/</link>
		<guid>https://www.gingerbill.org/article/2026/04/29/blessed-syntax-and-ergonomics/</guid>
		<pubDate>Wed, 29 Apr 2026 09:00:00 +0000</pubDate>
		<description>I have seen a common remark from people who are not the biggest fans of Odin and it is usually the remark that Odin is ;full of sugar; which only works for the ;blessed types; and it cannot be replaced or implemented for user-level types. Firstly, I don;t think this is necessarily an example of ;sugar; since that term implies it is shortening a construct / feature / idea into something smaller, whilst a lot of the ideas in Odin that would be classed as ;blessed syntax; by such people would not be classed ;sugar4...</description>
	</item>
	<item>
		<title>Odin's Fiasco with Wikipedia</title>
		<link>https://www.gingerbill.org/article/2026/04/20/odin-wikipedia-fiasco/</link>
		<guid>https://www.gingerbill.org/article/2026/04/20/odin-wikipedia-fiasco/</guid>
		<pubDate>Mon, 20 Apr 2026 09:00:00 +0000</pubDate>
		<description>Recently, Brodie Robertson produced a video on the Bizarre World of Wikipedia Deleting Programming Pages. I highly recommend watching the video.I thank Brodie for covering the Wikipedia fiasco for Odin. We don;t particularly care if Odin is on Wikipedia or not; especially when Wikipedia itself is rarely reliable, but we;ve been dealing with Wikipedia mods for years. Our best hypothesis  Which could very well be wrong too, and I'd love to be proven wrong. is quite simple: some of the mods just don;t like Odin as a language and don;t wa...</description>
	</item>
	<item>
		<title>Designing Odin's Casting Syntax</title>
		<link>https://www.gingerbill.org/article/2026/02/23/designing-odins-casting-syntax/</link>
		<guid>https://www.gingerbill.org/article/2026/02/23/designing-odins-casting-syntax/</guid>
		<pubDate>Mon, 23 Feb 2026 09:00:00 +0000</pubDate>
		<description>Odin;s declaration syntax becomes second nature to everyone who uses the language but I do sometimes get asked ;Why are there two ways to do type conversions?;  Enough that I had to make an FAQ entry..The reason that there are two ways to do type conversions is because one approach may feel better than the other case. If you are converting a large expression, it sometimes a lot easier to use the operator-style approach, . The call syntax is commonly used to specify a type of an expression which may be relatively short such as  or .There are...</description>
	</item>
	<item>
		<title>Does Syntax Matter?</title>
		<link>https://www.gingerbill.org/article/2026/02/21/does-syntax-matter/</link>
		<guid>https://www.gingerbill.org/article/2026/02/21/does-syntax-matter/</guid>
		<pubDate>Sat, 21 Feb 2026 09:00:00 +0000</pubDate>
		<description>Yes.But not necessarily in the ways you might think  n.b. This article could have been a lot longer than it currently is..Concrete and Abstract SyntaxesIn the previous article, Choosing a Language Based on its Syntax?, I talked about how many people will not pick up a language purely based on its declaration syntax not being familiar to them or the usage of semicolons or more.There were many lovely comments about the article, but some readers wrongly interpreted the article to mean that I don;t care about concrete syntax and only focus on the abstr...</description>
	</item>
	<item>
		<title>Choosing a Language Based on its Syntax?</title>
		<link>https://www.gingerbill.org/article/2026/02/19/choosing-a-language-based-on-syntax/</link>
		<guid>https://www.gingerbill.org/article/2026/02/19/choosing-a-language-based-on-syntax/</guid>
		<pubDate>Thu, 19 Feb 2026 09:00:00 +0000</pubDate>
		<description>I am still perplexed by how people judge a language purely by its declaration syntax, and will decide whether to use the language purely based on whether they like that aspect or not  I am specifically talking about declaration syntax here and not other aspects of concrete syntax. Please do not extrapolate further..The general categories of declarations can be classified as the following:---type-focused---name-focused---qualifier-focusedWhen designing a language, if your semantics are pretty clear you can trivially change this declaration syntax and th...</description>
	</item>
	<item>
		<title>The Only Two Markup Languages</title>
		<link>https://www.gingerbill.org/article/2026/01/19/two-families-of-markup-languages/</link>
		<guid>https://www.gingerbill.org/article/2026/01/19/two-families-of-markup-languages/</guid>
		<pubDate>Mon, 19 Jan 2026 09:00:00 +0000</pubDate>
		<description>There are only two families of proper arbitrary markup languages: TeX and SGML  I would normally link to official thing as reference but it's behind the "wonderful" ISO paywall: ISO 8879:1986.. By arbitrary, I mean the grammar specifically, and how it can be used to mark arbitrary plain text with information. And by proper, I mean the ability to have standalone nodes, user-definable nodes, nodes with attributes, and the wrapping of plain text. Everything else either lacks one of the these capabilities, or is a derivative or syntactic makeover of ...</description>
	</item>
	<item>
		<title>Mitigating the Billion Dollar Mistake</title>
		<link>https://www.gingerbill.org/article/2026/01/11/mitigating-the-billion-dollar-mistake/</link>
		<guid>https://www.gingerbill.org/article/2026/01/11/mitigating-the-billion-dollar-mistake/</guid>
		<pubDate>Sun, 11 Jan 2026 09:00:00 +0000</pubDate>
		<description>This article is continuation to: Was it really a Billion Dollar Mistake?.After reading a lot of the comments on numerous social media sites on the original article, I think I need to clarify a lot more.The main points I wanted to clarify:Null pointer dereferences are empirically the easiest class of invalid memory addresses to catch at runtime, and are the least common kind of invalid memory addresses that happen in memory unsafe languages.I do think it was a costly mistake but the ;obvious solutions; to the problem are probably just as costly, i...</description>
	</item>
	<item>
		<title>Was it really a Billion Dollar Mistake?</title>
		<link>https://www.gingerbill.org/article/2026/01/02/was-it-really-a-billion-dollar-mistake/</link>
		<guid>https://www.gingerbill.org/article/2026/01/02/was-it-really-a-billion-dollar-mistake/</guid>
		<pubDate>Fri, 02 Jan 2026 09:00:00 +0000</pubDate>
		<description>TL;DR  pointer dereferences are empirically the easiest class of invalid memory addresses to catch at runtime, and are the least common kind of invalid memory addresses that happen in memory unsafe languages. The trivial solutions to remove the ;problem;  pointers have numerous trade-offs which are not obvious, and the cause of why people think it is a ;problem; comes from a specific kind of individual-element mindset.Part Two of this article clarifies a lot more: Mitigating the Billion Dollar MistakeMost people have probably heard of the...</description>
	</item>
	<item>
		<title>context—Odin's Most Misunderstood Feature</title>
		<link>https://www.gingerbill.org/article/2025/12/15/odins-most-misunderstood-feature-context/</link>
		<guid>https://www.gingerbill.org/article/2025/12/15/odins-most-misunderstood-feature-context/</guid>
		<pubDate>Mon, 15 Dec 2025 09:00:00 +0000</pubDate>
		<description>Even with the documentation on the topic, many people completely misunderstand what the  system is for, and what problem it actually solves.For those not familiar with Odin, in each scope, there is an implicit value named . This context variable is local to each scope and is implicitly passed by pointer to any procedure call in that scope (if the procedure has the Odin calling convention).The main purpose of the implicit  system is for the ability to intercept third-party code and libraries and modify their functionality. One such case is modifying how a...</description>
	</item>
	<item>
		<title>Package Managers are Evil</title>
		<link>https://www.gingerbill.org/article/2025/09/08/package-managers-are-evil/</link>
		<guid>https://www.gingerbill.org/article/2025/09/08/package-managers-are-evil/</guid>
		<pubDate>Mon, 08 Sep 2025 09:00:00 +0000</pubDate>
		<description>n.b. This is a written version of a dialogue from a YouTube video: 2 Language Creators vs 2 Idiots | The StandupPackage managers (for programming languages) are evil  The term "evil" is being used partially hyperbolic to make a point..To start, I need to make a few distinctions between concepts a lot of programmers mix up:A packagePackage RepositoriesBuild SystemsPackage ManagersThese are all separate and can have no relation to one another. I have nothing wrong with packages, in fact Odin has packages built into the language. I have nothing wrong ...</description>
	</item>
	<item>
		<title>If Odin Had Macros</title>
		<link>https://www.gingerbill.org/article/2025/07/31/if-odin-had-macros/</link>
		<guid>https://www.gingerbill.org/article/2025/07/31/if-odin-had-macros/</guid>
		<pubDate>Thu, 31 Jul 2025 09:00:00 +0000</pubDate>
		<description>I sometimes get asked if Odin has any plans to add hygienic macros or some other similar construct. My general, and now (in)famous, answer is to many such questions is: No.I am not against macros nor metaprogramming in general, and in fact I do make metaprograms quite often (i.e. programs that make/analyse a program). However my approach with the design of Odin has been extremely pragmatic. I commonly ask people who ask for such things what are they specifically trying to solve? Usually they are not trying to do anything whatsoever and are just thinking ...</description>
	</item>
	<item>
		<title>Unstructured Thoughts on the Problems of OSS/FOSS</title>
		<link>https://www.gingerbill.org/article/2025/04/22/unstructured-thoughts-on-oss/</link>
		<guid>https://www.gingerbill.org/article/2025/04/22/unstructured-thoughts-on-oss/</guid>
		<pubDate>Tue, 22 Apr 2025 09:00:00 +0000</pubDate>
		<description>Originally from replies to a Twitter thread: https://x.com/TheGingerBill/status/1914389352416993395This is not a structured argument against FOSS/OSS but my uncommon thoughts on the topic.I am not sure if I agree [that FOSS/OSS derives from the same thinking process as the ideology of communism], but I understand the sentiment. The fundamental issue is that software is trivially copyable. I have loads of issues with FOSS and OSS  I am making a distinction between OSS (Open Source Software) and FOSS (Free [and] Open Source Software) in this article but ...</description>
	</item>
	<item>
		<title>OpenGL is not Right-Handed</title>
		<link>https://www.gingerbill.org/article/2024/11/10/opengl-is-not-right-handed/</link>
		<guid>https://www.gingerbill.org/article/2024/11/10/opengl-is-not-right-handed/</guid>
		<pubDate>Sun, 10 Nov 2024 09:00:00 +0000</pubDate>
		<description>The original Twitter thread: https://x.com/TheGingerBill/status/1508833104567414785I have a huge gripe when I read articles/tutorials on OpenGL: most people have no idea what they are talking about when it comes to coordinate systems and matrices.Specifically: OpenGL is NOT right-handed; the confusion over column-major ;matrices;.Let;s clear up the first point. Many people will say OpenGL uses a right-handed coordinate system. Loads of articles/tutorials will keep repeating the view that OpenGL uses a right-handed coordinate system. So the qu...</description>
	</item>
	<item>
		<title>Marketing the Odin Programming Language is Weird</title>
		<link>https://www.gingerbill.org/article/2024/09/08/odin-weird-to-market/</link>
		<guid>https://www.gingerbill.org/article/2024/09/08/odin-weird-to-market/</guid>
		<pubDate>Sun, 08 Sep 2024 09:00:00 +0000</pubDate>
		<description>[Originally from a Twitter Thread]Original Twitter Post;Killer Feature;Odin is a weird programming language to advertise/market for.Odin is very pragmatic in terms of its design and overall philosophy. Unlike all popular languages out there, it has no ;killer feature;. I;ve tried to design it to solve actual problems with actual solutions.Those languages with a ;killer feature; to them do make them ;standout; and consequentially more ;hypeable;. The problem is that those ;killer features; are usually ab...</description>
	</item>
	<item>
		<title>Why People are Angry over Go 1.23 Iterators</title>
		<link>https://www.gingerbill.org/article/2024/06/17/go-iterator-design/</link>
		<guid>https://www.gingerbill.org/article/2024/06/17/go-iterator-design/</guid>
		<pubDate>Mon, 17 Jun 2024 09:00:00 +0000</pubDate>
		<description>NOTE: This is based on, but completely rewritten, from a Twitter post:https://x.com/TheGingerBill/status/1802645945642799423TL;DR: It makes Go feel too ;functional; rather than being an unabashed imperative language.I recently saw a post on Twitter showing the upcoming Go iterator design for Go 1.23 (August 2024). From what I can gather, many people seem to dislike the design. I wanted to give my thoughts on it as a language designer.The merged PR for the proposal can be found here:https://github.com/golang/go/issues/61897It has a in-depth explan...</description>
	</item>
	<item>
		<title>String Type Distinctions</title>
		<link>https://www.gingerbill.org/article/2024/04/05/string-type-distinctions/</link>
		<guid>https://www.gingerbill.org/article/2024/04/05/string-type-distinctions/</guid>
		<pubDate>Fri, 05 Apr 2024 09:00:00 +0000</pubDate>
		<description>[Originally from a Twitter Thread]Original Twitter PostOne thing many languages ; API designers get wrong is the concept of a string. I try to make a firm distinction between:string value ( or )string builder ( or )Backing buffer for a string ( or )They are not equivalent even if you can theoretically use them as such, and so many garbage collected language use them as such.They have different use cases which don;t actually overlap in practice. Most of the issues with strings come from trying to merge concepts into one.In Odin, the distinction be...</description>
	</item>
	<item>
		<title>The Video That Inspired Me To Create Odin</title>
		<link>https://www.gingerbill.org/article/2024/04/04/video-that-inspired-odin/</link>
		<guid>https://www.gingerbill.org/article/2024/04/04/video-that-inspired-odin/</guid>
		<pubDate>Thu, 04 Apr 2024 09:00:00 +0000</pubDate>
		<description>[Originally from a Twitter Thread]Original Twitter PostMany people may not know this but this video by Sean Barrett @nothings is partially the reason why I made the Odin programming language.And I;ll explain what insights it gave me in this thread .A lot of these seem ;so obvious; but for some reason it never clicked to me before this video. A lot of the ;higher level; ;scripting; languages are not that much higher level than C. Those languages just have garbage collection and much better standard libraries than C.Those la...</description>
	</item>
	<item>
		<title>Why I Hate Language Benchmarks</title>
		<link>https://www.gingerbill.org/article/2024/01/22/comparing-language-benchmarks/</link>
		<guid>https://www.gingerbill.org/article/2024/01/22/comparing-language-benchmarks/</guid>
		<pubDate>Mon, 22 Jan 2024 09:00:00 +0000</pubDate>
		<description>[Originally from a Twitter Thread]Original Twitter PostI don;t know if I have ;ranted; about this here before but:I absolutely HATE comparing programming languages with ;benchmarks;.Language benchmarks rarely ever actually test for anything useful when comparing one language against another. This goes for ANY language.Even in the best case scenario: you are comparing different compilers for the same language (and the same input). This means that you are just comparing how well the optimizing backends work for those compilers. Comparin...</description>
	</item>
	<item>
		<title>Reverse Engineering Alembic</title>
		<link>https://www.gingerbill.org/article/2022/07/11/reverse-engineering-alembic/</link>
		<guid>https://www.gingerbill.org/article/2022/07/11/reverse-engineering-alembic/</guid>
		<pubDate>Mon, 11 Jul 2022 09:00:00 +0000</pubDate>
		<description>For my work at JangaFX, we require the use of the Alembic interchange file format. We have been using other libraries which wrap reading the Alembic file format but because it is not the native library, it has numerous issues due to the generic interface.I spent nearly 4 days trying to get the official Alembic C++ API, https://github.com/alembic/alembic/, to compile correctly and then use the API itself. Numerous times the compilation would get corrupted (it compiled but none of the tests even ran) and when I got it work (on another machine), the API its...</description>
	</item>
	<item>
		<title>Multiple Return Values Research</title>
		<link>https://www.gingerbill.org/article/2021/12/15/multiple-return-values-research/</link>
		<guid>https://www.gingerbill.org/article/2021/12/15/multiple-return-values-research/</guid>
		<pubDate>Wed, 15 Dec 2021 09:00:00 +0000</pubDate>
		<description>I have recently been thinking about multiple return values as a concept, and wondering if there has been any kind of literature into the topic of ;true; multiple return values which are not emulated through tuples. My current working hypothesis is that I think I have come to the conclusion (unless there is evidence to the contrary) Odin has invented a new kind of type system, something to the akin of polyadic expressions.It appears that Go and Odin are the only ones with what I call ;true; multiple return values, but Odin;s approach i...</description>
	</item>
	<item>
		<title>Memory Allocation Strategies - Part 6</title>
		<link>https://www.gingerbill.org/article/2021/12/02/memory-allocation-strategies-006/</link>
		<guid>https://www.gingerbill.org/article/2021/12/02/memory-allocation-strategies-006/</guid>
		<pubDate>Thu, 02 Dec 2021 09:00:00 +0000</pubDate>
		<description>Buddy Allocators</description>
	</item>
	<item>
		<title>Memory Allocation Strategies - Part 5</title>
		<link>https://www.gingerbill.org/article/2021/11/30/memory-allocation-strategies-005/</link>
		<guid>https://www.gingerbill.org/article/2021/11/30/memory-allocation-strategies-005/</guid>
		<pubDate>Tue, 30 Nov 2021 09:00:00 +0000</pubDate>
		<description>Free List Allocators</description>
	</item>
	<item>
		<title>The Value Propagation Experiment Part 2</title>
		<link>https://www.gingerbill.org/article/2021/09/06/value-propagation-experiment-part-2/</link>
		<guid>https://www.gingerbill.org/article/2021/09/06/value-propagation-experiment-part-2/</guid>
		<pubDate>Mon, 06 Sep 2021 09:00:00 +0000</pubDate>
		<description>[Originally from a Twitter Thread]I have revisited The Value Propagation Experiment and have come to a different conclusion as to why it failed and how I recovered it.The recovery work has been merged into master now with this PR: https://github.com/odin-lang/Odin/pull/1082I think there were three things which were confusing which make it look like a failure of an experiment: was a confusing name for what the semantics were. as a prefix was the wrong place.Unifying  with  was a bad idea for many reasons.Changes in the PR:Built-in  procedure became a bina...</description>
	</item>
	<item>
		<title>The Value Propagation Experiment</title>
		<link>https://www.gingerbill.org/article/2021/07/05/value-propagation-experiment/</link>
		<guid>https://www.gingerbill.org/article/2021/07/05/value-propagation-experiment/</guid>
		<pubDate>Mon, 05 Jul 2021 09:00:00 +0000</pubDate>
		<description>[Originally from a Twitter Thread]Part 2 of this ExperimentThe IdeaI recently experimented with adding a feature into Odin which allowed for a way to propagate a value by early returning if that value was  or not . It was in a similar vein to Rust;s  which became , or Zig;s , etc.I have now removed it from Odin. But why?The ProblemThe hypothesis was that that this idiom was common:where  may be an enum, a (discriminated) union, or any other kind of value that has .And replace it with  The concept of try worked by popping off the end value in a ...</description>
	</item>
	<item>
		<title>Untyped Types</title>
		<link>https://www.gingerbill.org/article/2021/03/07/untyped-types/</link>
		<guid>https://www.gingerbill.org/article/2021/03/07/untyped-types/</guid>
		<pubDate>Sun, 07 Mar 2021 09:00:00 +0000</pubDate>
		<description>When I was designing the constant value system in Odin, I wanted literals (especially numbers) to ;just work;. I was inspired by how both Ada  Ada Style Guide For Naming Conventions and Go  I highly recommend reading the article regarding how Go implements its constant value system https://blog.golang.org/constants both handled their constant value systems. But this lead me to a realization that there are two general different models of thought when it comes to values in programming languages.Model-1: Expressions have a type, not all expressi...</description>
	</item>
	<item>
		<title>Structured Control Flow (Brain Dump)</title>
		<link>https://www.gingerbill.org/article/2021/02/02/structured-control-flow/</link>
		<guid>https://www.gingerbill.org/article/2021/02/02/structured-control-flow/</guid>
		<pubDate>Tue, 02 Feb 2021 09:00:00 +0000</pubDate>
		<description>Note: This is a ;brain dump; article, and subject to be cleaned up.Categories of Structured Control FlowProcedure callTerminatingConditional, , Looping - loop with initial statement, condition, post statement, and body - loop with a value to be iterated over - loop with condition then body - loop with body then conditionBranching - go to end outside of the control statement - skip to the end of a loop - merge two switch case bodies, to have multiple entry points to the merged bodyLabels on other control flow statementsDeferred/Pseudo/Partial Cate...</description>
	</item>
	<item>
		<title>The Essence of Programming</title>
		<link>https://www.gingerbill.org/article/2021/02/01/the-essence-of-programming/</link>
		<guid>https://www.gingerbill.org/article/2021/02/01/the-essence-of-programming/</guid>
		<pubDate>Mon, 01 Feb 2021 09:00:00 +0000</pubDate>
		<description>One thing I have noticed a lot when a programmer is struggling to solve a problem, especially a novice, is that he is stuck worrying about the ;best way; to implement the solution rather than actually understanding the problem he has. I believe a lot of this stems from not understanding the essence of what programming fundamentally is.Essentially Ordered AspectsIn a previous article of mine, I state that ;Programming is a tool to solve problems that you have in the domain of computers;. At the essence of everything to do with programming,...</description>
	</item>
	<item>
		<title>The Fatal Flaw of Ownership Semantics</title>
		<link>https://www.gingerbill.org/article/2020/06/21/the-ownership-semantics-flaw/</link>
		<guid>https://www.gingerbill.org/article/2020/06/21/the-ownership-semantics-flaw/</guid>
		<pubDate>Sun, 21 Jun 2020 09:00:00 +0000</pubDate>
		<description>I have been toying with a theoretical idea for the past 18 months off-and-on in my head and I have not fully articulated it aloud yet. It is regarding the concept of Ownership Semantics (OS) or Move Semantics in programming languages. Fundamentally this article is a criticism of the concept and states that the concept is a duality of traditional OOP but applied to a different area.General Definitions of TerminologyA general list of definitions of terminology used within this article in order to minimize confusion.A Value is a datum with an associated typ...</description>
	</item>
	<item>
		<title>Flash Fads Model (Audio Article)</title>
		<link>https://www.gingerbill.org/article/2020/06/13/flash-fads-model/</link>
		<guid>https://www.gingerbill.org/article/2020/06/13/flash-fads-model/</guid>
		<pubDate>Sat, 13 Jun 2020 09:00:00 +0000</pubDate>
		<description>Audio Article:</description>
	</item>
	<item>
		<title>Pragmatism in Programming Proverbs</title>
		<link>https://www.gingerbill.org/article/2020/05/31/programming-pragmatist-proverbs/</link>
		<guid>https://www.gingerbill.org/article/2020/05/31/programming-pragmatist-proverbs/</guid>
		<pubDate>Sun, 31 May 2020 09:00:00 +0000</pubDate>
		<description>I was originally going to write a normal prose article regarding the topic of Pragmatism in Programming, however I thought I;d experiment in style by writing in a proverbial style.The following concepts express the school of thought that I subscribe to which I call Pragmatism in Programming.Proverbs written by Ginger BillThe concept of programmingProgramming is a tool to solve problems that you have in the domain of computersThe purpose of a program is, and ought to be, something that transforms data into other forms of dataTry to solve the specific ...</description>
	</item>
	<item>
		<title>Relative Pointers</title>
		<link>https://www.gingerbill.org/article/2020/05/17/relative-pointers/</link>
		<guid>https://www.gingerbill.org/article/2020/05/17/relative-pointers/</guid>
		<pubDate>Sun, 17 May 2020 09:00:00 +0000</pubDate>
		<description>Absolute PointersPointers are a value type in programming languages that store a memory address. A pointer references a location in memory, and obtaining the value stored at this location in memory is known as dereferencing a pointer. Pointers are part and parcel of using languages like C, and are an extremely powerful tool. Pointers can be treated as a form of reference type, a value that refers to another typed value in memory.When most people think of a pointer, they usually treat them as if the pointer refers a physical memory address. I will call th...</description>
	</item>
	<item>
		<title>A Reply to _Let's stop copying C_</title>
		<link>https://www.gingerbill.org/article/2020/01/25/a-reply-to-lets-stop-copying-c/</link>
		<guid>https://www.gingerbill.org/article/2020/01/25/a-reply-to-lets-stop-copying-c/</guid>
		<pubDate>Sat, 25 Jan 2020 09:00:00 +0000</pubDate>
		<description>I read the article Let;s stop copying C about 3 years ago. Recently someone brought it up again and I thought I would comment on the points being made. The article argues that newer languages ought not to copy the mistakes of C and comment on may of C;s mistakes.I recommend reading the original article first before reading this one as I will be commenting directly on the subsections of the article.A lot of my comments will be with regards to systems-level programming languages and not programming languages in general, and I will be referring back...</description>
	</item>
	<item>
		<title>A Reply to _The Road to Zig 1.0_</title>
		<link>https://www.gingerbill.org/article/2019/05/13/a-reply-to-the-road-to-zig/</link>
		<guid>https://www.gingerbill.org/article/2019/05/13/a-reply-to-the-road-to-zig/</guid>
		<pubDate>Mon, 13 May 2019 09:00:00 +0000</pubDate>
		<description>It is lovely to see many new programming languages being produced to solve different issues that the designers are trying to address. Many of the new big ones include Rust, Go, and Swift, all of which are trying to solve different problems. There are some not-as-big programming languages that I recommend everyone to checkout:Odin  For those who do not know, I am the creator of the Odin programming language.ScopesZigThey are all very good languages but with entirely different philosophies behind them. See if one suits your personal philosophy better!Whi...</description>
	</item>
	<item>
		<title>A Quine in Odin</title>
		<link>https://www.gingerbill.org/article/2019/03/10/quine-in-odin/</link>
		<guid>https://www.gingerbill.org/article/2019/03/10/quine-in-odin/</guid>
		<pubDate>Sun, 10 Mar 2019 09:00:00 +0000</pubDate>
		<description>A Quine in Odin:</description>
	</item>
	<item>
		<title>Memory Allocation Strategies - Part 4</title>
		<link>https://www.gingerbill.org/article/2019/02/16/memory-allocation-strategies-004/</link>
		<guid>https://www.gingerbill.org/article/2019/02/16/memory-allocation-strategies-004/</guid>
		<pubDate>Sat, 16 Feb 2019 09:00:00 +0000</pubDate>
		<description>Pool Allocators</description>
	</item>
	<item>
		<title>Memory Allocation Strategies - Part 3</title>
		<link>https://www.gingerbill.org/article/2019/02/15/memory-allocation-strategies-003/</link>
		<guid>https://www.gingerbill.org/article/2019/02/15/memory-allocation-strategies-003/</guid>
		<pubDate>Fri, 15 Feb 2019 09:00:00 +0000</pubDate>
		<description>Stack Allocators</description>
	</item>
	<item>
		<title>Memory Allocation Strategies - Part 2</title>
		<link>https://www.gingerbill.org/article/2019/02/08/memory-allocation-strategies-002/</link>
		<guid>https://www.gingerbill.org/article/2019/02/08/memory-allocation-strategies-002/</guid>
		<pubDate>Fri, 08 Feb 2019 09:00:00 +0000</pubDate>
		<description>Linear/Arena Allocators</description>
	</item>
	<item>
		<title>Memory Allocation Strategies - Part 1</title>
		<link>https://www.gingerbill.org/article/2019/02/01/memory-allocation-strategies-001/</link>
		<guid>https://www.gingerbill.org/article/2019/02/01/memory-allocation-strategies-001/</guid>
		<pubDate>Fri, 01 Feb 2019 09:00:00 +0000</pubDate>
		<description>Thinking About Memory and Allocation</description>
	</item>
	<item>
		<title>ExceptionsAnd Why Odin Will Never Have Them</title>
		<link>https://www.gingerbill.org/article/2018/09/05/exceptions---and-why-odin-will-never-have-them/</link>
		<guid>https://www.gingerbill.org/article/2018/09/05/exceptions---and-why-odin-will-never-have-them/</guid>
		<pubDate>Wed, 05 Sep 2018 09:00:00 +0000</pubDate>
		<description>Article was originally posted here: https://odin.handmade.network/blogs/p/3372-exceptions_-_and_why_odin_will_never_have_themOriginal Comments:https://github.com/odin-lang/Odin/issues/256#issuecomment-418073701https://github.com/odin-lang/Odin/issues/256#issuecomment-418289626There will never be software exceptions in the traditional sense. I hate the entire philosophy behind the concept. Go does have exceptions with the defer, panic, recover approach. They are weird on purpose. Odin could have something similar for exceptional cases. You can the exact s...</description>
	</item>
	<item>
		<title>On the Aesthetics of the Syntax of Declarations</title>
		<link>https://www.gingerbill.org/article/2018/03/12/on-the-aesthetics-of-the-syntax-of-declarations/</link>
		<guid>https://www.gingerbill.org/article/2018/03/12/on-the-aesthetics-of-the-syntax-of-declarations/</guid>
		<pubDate>Mon, 12 Mar 2018 09:00:00 +0000</pubDate>
		<description>Article was originally posted here: https://odin.handmade.network/blogs/p/2994-on_the_aesthetics_of_the_syntax_of_declarationsn.b. This is a philosophical article and not a technical article. There are no correct answers to the questions that I will pose -- only compromises.I;m considering what the ;best; declaration syntax would be. Historically, there have been two categories: which I will call qualifier-focused and type-focused. An example of qualifier-focused would be the Pascal family. An example of type-focused would be the C family. Od...</description>
	</item>
	<item>
		<title>The Metaprogramming Dilemma</title>
		<link>https://www.gingerbill.org/article/2016/12/01/the-metaprogramming-dilemma/</link>
		<guid>https://www.gingerbill.org/article/2016/12/01/the-metaprogramming-dilemma/</guid>
		<pubDate>Thu, 01 Dec 2016 09:00:00 +0000</pubDate>
		<description>Article was originally posted here: https://odin.handmade.network/blogs/p/1723-the_metaprogramming_dilemmaDesigning this language has been difficult but fun. Two of the original goals of this language were simplicity and metaprogramming however, these together could be an oxymoron. But before I explain why, I first need to explain what I mean by ;metaprogramming;.Metaprogramming is an ;art; of writing programs to treats other programs as their data. This means that a program could generate, read, analyse, and transform code or even itself...</description>
	</item>
	<item>
		<title>A Defer Statement For C++11</title>
		<link>https://www.gingerbill.org/article/2015/08/19/defer-in-cpp/</link>
		<guid>https://www.gingerbill.org/article/2015/08/19/defer-in-cpp/</guid>
		<pubDate>Wed, 19 Aug 2015 09:00:00 +0000</pubDate>
		<description>One of my favourite things about Go is the  statement. The  statement pushes a function call onto a list; the list of saved calls in called when the function returns.Imitating this is C++ is impossible. Instead of calling when the function calls, you can call at the end of scope; this is a better approach for C++. This is similar to how D has scope(exit).C++11 ImplementationExplanationOne of the most common examples for this in Go is files.In C/C++, before every return,  must be called.You may say that RAII in C++ solves this issue but this would require...</description>
	</item>
</channel>
</rss>
