<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Terms on Hillel Wayne</title>
    <link>https://www.hillelwayne.com/tags/terms/</link>
    <description>Recent content in Terms on Hillel Wayne</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Wed, 01 May 2024 00:00:00 +0000</lastBuildDate>
    
	<atom:link href="https://www.hillelwayne.com/tags/terms/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Software Friction</title>
      <link>https://www.hillelwayne.com/post/software-friction/</link>
      <pubDate>Wed, 01 May 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/software-friction/</guid>
      <description>In his book On War, Clausewitz defines friction as the difference between military theory and reality:
 Thus, then, in strategy everything is very simple, but not on that account very easy. Everything is very simple in war, but the simplest thing is difficult. These difficulties accumulate and produce a friction, which no man can imagine exactly who has not seen war.
As an instance of [friction], take the weather.</description>
    </item>
    
    <item>
      <title>The World and the Machine</title>
      <link>https://www.hillelwayne.com/post/world-vs-machine/</link>
      <pubDate>Thu, 04 Jan 2024 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/world-vs-machine/</guid>
      <description>This is just a way of thinking about formal specification that I find really useful. The terms originally come from Michael Jackson&amp;rsquo;s Software Requirements and Specifications.
In specification, the machine is the part of the system you have direct control over and the world is all the parts that you don&amp;rsquo;t. Take a simple transfer spec:
---- MODULE transfer ---- EXTENDS TLC, Integers CONSTANTS People, Money, NumTransfers (* --algorithm transfer variables acct \in [People -&amp;gt; Money]; define \* Invariant NoOverdrafts == \A p \in People: acct[p] &amp;gt;= 0 end define; process cheque \in 1.</description>
    </item>
    
    <item>
      <title>Sources of Complexity: Constraints</title>
      <link>https://www.hillelwayne.com/post/complexity-constraints/</link>
      <pubDate>Mon, 23 Jan 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/complexity-constraints/</guid>
      <description>Complexity is bad. Simple software is better than complex software.
But software is complex for a reason. While people like coming up with grand theories of complexity (Simple Made Easy, No Silver Bullet) there&amp;rsquo;s very little info out there on the nitty-gritty specific sources of complexity. Without that, all the theories feel to me like the four elements theory. We just don&amp;rsquo;t have the data needed to come up with something more predictive.</description>
    </item>
    
    <item>
      <title>Safety and Liveness Properties</title>
      <link>https://www.hillelwayne.com/post/safety-and-liveness/</link>
      <pubDate>Tue, 06 Sep 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/safety-and-liveness/</guid>
      <description>img {border-style: groove; border-width: 1px; padding: 5px; } 
Sounds like I should write a post on safety and liveness!
First, some definitions. A system is anything that has changing state. This is an incredibly broad definition that covers a wide variety of situations, like:
 Two threads in a thread scheduler Five servers behind a load balancer A reader and writer communicating on a FIFO queue A business workflow being manually followed A person waiting for the bus Etc.</description>
    </item>
    
    <item>
      <title>Software Mimicry</title>
      <link>https://www.hillelwayne.com/post/software-mimicry/</link>
      <pubDate>Mon, 29 Aug 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/software-mimicry/</guid>
      <description>Mimicry is when software X reimplements at a higher level a core feature of software Y. The produced facsimile has some, but not all, of the same properties, enough to &amp;ldquo;look like&amp;rdquo; it&amp;rsquo;s the same thing but missing many of the nuances. This exists in every kind of software. One language can mimic another, a library can mimic a language, a database engine can mimic a product, etc.
Example Design Patterns introduces the strategy pattern to apply multiple algorithms to the same call:</description>
    </item>
    
    <item>
      <title>Clever vs Insightful Code</title>
      <link>https://www.hillelwayne.com/post/cleverness/</link>
      <pubDate>Sun, 06 Jun 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/cleverness/</guid>
      <description>&amp;ldquo;Don&amp;rsquo;t write clever code.&amp;rdquo; Why not? &amp;ldquo;Because it&amp;rsquo;s hard to understand.&amp;rdquo; People who say this think of clever code such as Duff&amp;rsquo;s Device:
Duff&amp;#39;s Devicesend(to, from, count) registershort*to, *from; registercount; { registern =(count +7) /8; switch(count %8) { case0: do{ *to =*from++; case7: *to =*from++; case6: *to =*from++; case5: *to =*from++; case4: *to =*from++; case3: *to =*from++; case2: *to =*from++; case1: *to =*from++; } while(--n &amp;gt;0); } }  show allThis code is &amp;ldquo;clever&amp;rdquo; because it exploits knowledge about the language, in this case the peculiarities of fall-through.</description>
    </item>
    
    <item>
      <title>Constructive vs Predicative Data</title>
      <link>https://www.hillelwayne.com/post/constructive/</link>
      <pubDate>Mon, 18 May 2020 00:00:00 +0000</pubDate>
      
      <guid>https://www.hillelwayne.com/post/constructive/</guid>
      <description>Consider a data type that represents users, which includes &amp;ldquo;favorite people&amp;rdquo; and &amp;ldquo;blocked people&amp;rdquo;:1
data Person: favorites: set of Person blocked: set of Person  We want a validation that says that these two sets are disjoint, a.k.a. no person can belong to both sets at once. We call these kinds of validations predicates, or boolean functions that correspond to our requirements. The predicates determine if a representable item is also a valid item.</description>
    </item>
    
  </channel>
</rss>