index.xml

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0"
      xmlns:atom="http://www.w3.org/2005/Atom"
      xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title></title>
    <link>https://www.vijayanant.com/</link>
    <description>Recent content on </description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <lastBuildDate>Mon, 03 Apr 2023 00:00:00 +0000</lastBuildDate><atom:link href="https://www.vijayanant.com/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Design Principles and Design Patterns</title>
      <link>https://www.vijayanant.com/posts/design-principles-and-design-patterns/</link>
      <pubDate>Mon, 03 Apr 2023 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/design-principles-and-design-patterns/</guid>
      <description>Design principles and design patterns are related but serve different purposes.
Design principles are high-level guidelines for designing software that helps developers create code that is maintainable, extensible, and adaptable. These principles are not specific to any programming language or technology and can be applied to any software development project. Design principles provide a foundation for good software design and help developers create code that is easier to maintain and change over time.</description>
      <content:encoded>&lt;p&gt;Design principles and design patterns are related but serve different purposes.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Design principles&lt;/em&gt; are high-level guidelines for designing software that helps
developers create code that is maintainable, extensible, and adaptable. These
principles are not specific to any programming language or technology and can be
applied to any software development project. Design principles provide a
foundation for good software design and help developers create code that is
easier to maintain and change over time.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Design patterns&lt;/em&gt;, on the other hand, are specific solutions to recurring design
problems in software development. They are practical, reusable solutions that
can be applied to specific programming languages or technologies. Design
patterns are based on design principles but provide specific implementations
that can be used to solve specific problems. They also help developers avoid
common pitfalls in software development and ensure that their code is efficient,
scalable, and easy to understand.&lt;/p&gt;
&lt;p&gt;The relationship between design patterns and design principles is complimentary.
Design principles provide high-level guidelines and best practices for designing
software. Design patterns provide concrete implementations to specific design
problems while adhering to the design principles&lt;/p&gt;
&lt;p&gt;In fact, many design patterns provide solutions that adhere to multiple
principles. While it is ideal for a design pattern to adhere to all the design
principles, it is not always possible to achieve this. Design principles are not
absolute rules that must be followed in all cases. Some design principles may be
more important than others depending on the specific problem being solved, and
some principles may even conflict with each other. There may be situations where
adhering to a design principle is not practical or even desirable, and in such
cases, a design pattern that addresses the specific problem at hand may be a
better choice.&lt;/p&gt;
&lt;p&gt;Let us see some examples:&lt;/p&gt;
&lt;h3 id=&#34;single-responsibility-principle-srp&#34;&gt;Single Responsibility Principle (SRP)&lt;/h3&gt;
&lt;p&gt;The SRP states that a class should have only one responsibility or reason to
change. This means that a class should only be responsible for one thing, and if
that thing changes, the class should be the only one that needs to change. The
goal is to keep classes focused and maintainable and reduce the risk of
unintended consequences when making changes.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The Observer Pattern: The Observer pattern is a behavioural design pattern
that defines a one-to-many dependency between objects, where a change in one
object (the subject) causes all its dependents (observers) to be notified and
updated automatically. This pattern adheres to the SRP by separating the
responsibilities of the subject and the observers. The subject&amp;rsquo;s
responsibility is to manage the state and notify the observers, while the
observers&#39; responsibility is to respond to the notifications and update
themselves.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Command Pattern: The Command pattern is a behavioural design pattern that
encapsulates a request as an object, thereby allowing for the separation of
the requester (client) from the executor (receiver) of the request. This
pattern adheres to the SRP by separating the responsibility of the client from
the responsibility of the receiver. The client&amp;rsquo;s responsibility is to create
and invoke the command objects, while the receiver&amp;rsquo;s responsibility is to
execute the commands.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;openclosed-principle-ocp&#34;&gt;Open/Closed Principle (OCP)&lt;/h3&gt;
&lt;p&gt;The OCP states that software entities should be open for extension but closed
for modification. This means that you should be able to add new functionality to
a system without changing the existing code. The goal is to reduce the risk
of introducing new bugs when making changes and allow for greater
flexibility and adaptability in the system.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The Strategy Pattern: The Strategy pattern is a behavioural design pattern
that defines a family of algorithms, encapsulates each one, and makes them
interchangeable. This pattern adheres to the OCP by allowing the behaviour of
an object to be modified without changing its class. The behaviour of an object
can be modified by changing the strategy object that the object uses.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Decorator Pattern: The Decorator pattern is a structural design pattern
that allows behaviour to be added to an individual object, either statically or
dynamically, without affecting the behaviour of other objects from the same
class. This pattern adheres to the OCP by allowing functionality to be added
to an object without changing its interface or the behaviour of other objects.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;liskov-substitution-principle-lsp&#34;&gt;Liskov Substitution Principle (LSP)&lt;/h3&gt;
&lt;p&gt;The LSP states that subtypes must be substitutable for their base types. This
means that if you have a variable of a certain type, you should be able to
substitute any subtype of that type without affecting the behaviour of the
system. The goal is to ensure that code is reusable and maintainable and reduce
the risk of introducing bugs when making changes.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The Factory Method Pattern: The Factory Method pattern is a creational design
pattern that defines an interface for creating objects, but allows subclasses
to decide which class to instantiate. This pattern adheres to the LSP by
ensuring that the objects created by the factory can be used interchangeably,
regardless of their concrete types.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Template Method Pattern: The Template Method pattern is a behavioural
design pattern that defines the skeleton of an algorithm in a superclass, but
lets subclasses override specific steps of the algorithm without changing its
structure. This pattern adheres to the LSP by ensuring that the subclasses can
be used in place of the superclass without changing the correctness of the
algorithm.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;interface-segregation-principle-isp&#34;&gt;Interface Segregation Principle (ISP)&lt;/h3&gt;
&lt;p&gt;The ISP states that clients should not be forced to depend on interfaces they do
not use. This means that if a client only needs a subset of the functionality
provided by an interface, it should only depend on that subset. The goal is to
reduce coupling between components and make it easier to change or replace
components without affecting the behaviour of the system.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The Adapter Pattern: The Adapter pattern is a structural design pattern that
allows incompatible classes to work together by converting the interface of
one class into another interface that the client expects. This pattern adheres
to the ISP by ensuring that the adapter only provides the methods that are
relevant to the client, and not the entire interface of the adapted class.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Observer Pattern: The Observer pattern is a behavioural design pattern
that defines a one-to-many dependency between objects, such that when the
object changes state, all its dependents are notified and updated
automatically. This pattern adheres to the ISP by ensuring that the Observer
interface only includes the methods required by the observers to receive
notifications from the subject, and not any additional methods that may not be
relevant or used.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;dependency-inversion-principle-dip&#34;&gt;Dependency Inversion Principle (DIP)&lt;/h3&gt;
&lt;p&gt;The DIP states that high-level modules should not depend on low-level modules.
Instead, both should depend on abstractions. This means that the details of how
a system works should be hidden behind abstractions, and changes to the
implementation should not affect the behaviour of the system. The goal is to make
systems more modular and easier to maintain.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The Dependency Injection Pattern: The Dependency Injection pattern is a design
pattern that allows the creation of dependent objects to be inverted and
delegated to a separate component, thereby decoupling the client from the
implementation details of the dependent objects. This pattern adheres to the
DIP by ensuring that the client depends only on abstractions, and not on
concrete implementations, thus allowing for flexibility and easy substitution
of dependencies.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Strategy Pattern: The Strategy pattern is a behavioural design pattern
that defines a family of algorithms, encapsulates each one, and makes them
interchangeable at runtime. This pattern adheres to the DIP by ensuring that
the algorithms are defined as interfaces or abstract classes, which can be
easily extended or modified without affecting the client code.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;the-other-way-around&#34;&gt;The Other Way Around&lt;/h2&gt;
&lt;p&gt;It is also possible for a single design pattern to cater for more than one
design principle. Design patterns are in widespread use because they do not go
against any of the principles and address many (if not all) design principles.
For example -&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;The Strategy pattern is often used to address the Open/Closed Principle (OCP)
and the Single Responsibility Principle (SRP) at the same time. The OCP states
that software entities should be open for extension but closed for
modification, while the SRP states that a class should have only one reason to
change. The Strategy pattern allows the behaviour of an object to be modified
at runtime without modifying the object itself, thus adhering to the OCP. It
also separates the implementation of the algorithm from the object that uses
it, adhering to the SRP.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The Factory Method pattern can address the SRP, the OCP, and the Dependency
Inversion Principle (DIP) at the same time. The Factory Method pattern
separates the creation of objects from their use, allowing for greater
flexibility in object creation and adherence to the SRP. It also allows for
the creation of objects at runtime, adhering to the OCP. Finally, by using
abstractions to create objects, it adheres to the DIP.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;While it is important to understand the concepts behind each design pattern, it
is also important to choose the right pattern for the specific problem you are
trying to solve. Not all patterns will apply to every situation, and it
is important to consider the trade-offs and benefits of each pattern before
choosing the one that is best suited for your needs.&lt;/p&gt;
&lt;p&gt;In conclusion, the five major design principles and design patterns are
essential for creating maintainable, extensible, and adaptable code. By
following these principles and patterns, developers can reduce the risk of
introducing bugs when making changes, and make systems more modular and easier
to maintain, and create code that is easier to test and reuse.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Why YOU Should Blog Too!</title>
      <link>https://www.vijayanant.com/posts/why-you-should-blog-too/</link>
      <pubDate>Thu, 30 Mar 2023 13:21:32 +0530</pubDate>
      
      <guid>https://www.vijayanant.com/posts/why-you-should-blog-too/</guid>
      <description>When I first thought about blogging it was daunting. Even though I liked the idea of blogging, I didn&amp;rsquo;t know why I should blog. What was I going to add to the world when all I know comes from reading other&amp;rsquo;s books and blogs? I had no reason to write about topics that are already written about extensively by experts in that area. I didn&amp;rsquo;t think I knew enough contribute.</description>
      <content:encoded>&lt;p&gt;When I first thought about blogging it was daunting. Even though I liked the
idea of blogging, I didn&amp;rsquo;t know why I should blog. What was I going to add to
the world when all I know comes from reading other&amp;rsquo;s books and blogs? I had no
reason to write about topics that are already written about extensively by
experts in that area. I didn&amp;rsquo;t think I knew enough contribute.&lt;/p&gt;
&lt;p&gt;Then I found a reason &amp;ndash; to document my own learnings. It was supposed to be my
notebook. I started to document things I had learnt and things I was learning at
that moment. It was a &amp;lsquo;blog&amp;rsquo; in the sense that it was on the web. Few of the
&amp;lsquo;notes&amp;rsquo;, I felt, were better than the others. I shared them with few friends.
They liked it and encouraged me to start a &amp;lsquo;blog&amp;rsquo;. Even though I was not sure
they convinced me that there was nothing to lose. That&amp;rsquo;s how I started to write.&lt;/p&gt;
&lt;p&gt;Blogging isn&amp;rsquo;t for everyone. Tons of amazing developers don&amp;rsquo;t have blogs or
personal websites at all. I write because it&amp;rsquo;s fun for me and it helps me
organize my thoughts.&lt;/p&gt;
&lt;p&gt;This post is for anyone who is still thinking why they should start blogging.&lt;/p&gt;
&lt;h3 id=&#34;share-your-unique-experience&#34;&gt;Share Your Unique Experience&lt;/h3&gt;
&lt;p&gt;Even though a particular technology or topic may have been covered extensively
by others, you likely have your own unique experiences and insights to bring to
the conversation. Maybe you&amp;rsquo;ve used a particular technology in a novel way, or
have encountered challenges that others haven&amp;rsquo;t. By sharing your own experience,
you can add a valuable perspective to the conversation and offer new insights to
your readers.&lt;/p&gt;
&lt;h3 id=&#34;learn-more&#34;&gt;Learn More&lt;/h3&gt;
&lt;p&gt;Starting a tech blog can also be a great way to learn more about technology. As
you research and write about different topics, you&amp;rsquo;ll inevitably come across new
information and insights that you may not have otherwise discovered. Plus, by
interacting with your readers and other tech enthusiasts online, you can learn
even more about the latest trends and developments.&lt;/p&gt;
&lt;h3 id=&#34;provide-a-different-format&#34;&gt;Provide a Different Format&lt;/h3&gt;
&lt;p&gt;While there may be many articles, books, or video tutorials on a particular
technology or topic, not everyone may want to consume information in those
formats. Writing a blog post can provide a quick and easy-to-digest summary or
guide to a particular technology. Additionally, you can provide your own unique
voice and style to make the information more accessible to your readers.&lt;/p&gt;
&lt;h3 id=&#34;reach-a-different-audience&#34;&gt;Reach a Different Audience&lt;/h3&gt;
&lt;p&gt;While established tech bloggers may have a loyal following of readers, there are
likely still many people who are interested in the topic but haven&amp;rsquo;t yet found a
resource that speaks to them. By writing a blog post on the topic, you can reach
a new and different audience who may not have been exposed to the information
before.&lt;/p&gt;
&lt;h3 id=&#34;update-information&#34;&gt;Update Information&lt;/h3&gt;
&lt;p&gt;Technology is constantly changing and evolving. Even if a topic has been covered
extensively in the past, there may be new updates, features, or security
vulnerabilities that need to be addressed. By writing about these updates, you
can provide valuable and up-to-date information to your readers.&lt;/p&gt;
&lt;h3 id=&#34;connect-with-like-minded-people&#34;&gt;Connect with Like-Minded People&lt;/h3&gt;
&lt;p&gt;Starting a blog can also help you connect with like-minded people from all over
the world. By sharing your thoughts and insights online, you can engage with
other tech enthusiasts and build a community of people who share your passion
for technology. This can lead to new friendships, collaborations, and even
business opportunities.&lt;/p&gt;
&lt;h3 id=&#34;establish-yourself-as-an-expert&#34;&gt;Establish Yourself as an Expert&lt;/h3&gt;
&lt;p&gt;Writing about a particular technology or topic consistently can help you
establish yourself as an expert in that field. This can be valuable for your
career, as it can help to establish you as a thought leader in your industry or
area of expertise. Additionally, by building a following of readers who are
interested in your content, you may be able to leverage this following for other
opportunities, such as speaking engagements, consulting work, or job offers.&lt;/p&gt;
&lt;h3 id=&#34;have-fun&#34;&gt;Have Fun!&lt;/h3&gt;
&lt;p&gt;Finally, starting a blog should be fun! It&amp;rsquo;s a great way to share your
interests and connect with others who share your passions. Plus, there&amp;rsquo;s
something uniquely satisfying about creating content and putting it out into the
world for others to enjoy.&lt;/p&gt;
&lt;p&gt;While my blog is mostly tech, the benefits of blogging apply to any niche or
topic. Blogging is a versatile medium that can be used to share your knowledge,
connect with like-minded individuals, and build your personal brand, regardless
of the subject matter.&lt;/p&gt;
&lt;p&gt;I encourage you to be the new blogger to explore different topics and niches
that interest you. Whether it&amp;rsquo;s fashion, cooking, travel, or personal
development, there&amp;rsquo;s an audience out there for every type of content. By
starting a blog and sharing your unique perspectives and experiences, you can
create valuable content that resonates with your audience.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Technical Debt</title>
      <link>https://www.vijayanant.com/posts/technical-debt/</link>
      <pubDate>Wed, 28 Dec 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/technical-debt/</guid>
      <description>Ward Cunningham, co-author of the Agile Manifesto and a pioneer in design patterns and XP, came up with this metaphor as a way of explaining (to non-technical stakeholders) why refactoring was an essential part of software development. He conveys to them that refactoring is as important as shipping software early to maintain their place in the market. He used the debt metaphor as a way of making an analogy to how venture capital is used to get a business off the ground.</description>
      <content:encoded>&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Ward_Cunningham&#34;&gt;Ward Cunningham&lt;/a&gt;, co-author of
the Agile Manifesto and a pioneer in design patterns and XP, came up with this
metaphor as a way of explaining (to non-technical stakeholders) why refactoring
was an essential part of software development. He conveys to them that
refactoring is as important as shipping software early to maintain their place
in the market. He used the &lt;strong&gt;debt metaphor as a way of making an analogy to how
venture capital is used to get a business off the ground.&lt;/strong&gt;&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;With borrowed money you can do something sooner than you might otherwise, but
then until you pay back that money you&amp;rsquo;ll be paying interest. I thought
borrowing money was a good idea, I thought that rushing software out the door
to get some experience with it was a good idea, but that of course, you would
eventually go back and as you learned things about that software you would
repay that loan by refactoring the program to reflect your experience as you
acquired it.&lt;/p&gt;
&lt;p&gt;&amp;ndash; Ward Cunningham&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;it-is-not-a-bad-thing&#34;&gt;It Is Not A Bad Thing&lt;/h2&gt;
&lt;p&gt;The idea that technical debt is inherently a bad thing is a corruption of
Cunningham&amp;rsquo;s original concept. He makes it clear when he says &lt;em&gt;&amp;ldquo;I thought
borrowing money was a good idea&amp;rdquo;.&lt;/em&gt; He sees it as the trade-offs made between
rushing to capture the market vs the long-term viability of code.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&amp;ldquo;Rushing software out the door to get experience with it is a good idea, but
you need to refactor the code to reflect your experience as understanding
increases.&amp;quot;&lt;/em&gt;&lt;/p&gt;
&lt;p&gt;We have moved quickly to capture the market by taking on some debt. This is
surely a competitive advantage but it comes with a cost.&lt;/p&gt;
&lt;h2 id=&#34;bad-code-is-not-encouraged&#34;&gt;Bad Code Is NOT Encouraged!&lt;/h2&gt;
&lt;p&gt;There is a misunderstanding that it is OK to write bad code in order to push
software faster. The argument is - &lt;em&gt;we are going to come back and fix it later
anyway, so why spend time writing clean code now?&lt;/em&gt; This is not correct.
Cunningham talks of &lt;em&gt;experience gained&lt;/em&gt; as the software progresses, and we are
expected to &lt;em&gt;refactor&lt;/em&gt; our code to reflect that experience gained.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;I&amp;rsquo;m never in favour of writing code poorly, but I am in favour of writing code
to reflect your current understanding of a problem even if that understanding
is partial.&lt;/p&gt;
&lt;p&gt;&amp;ndash; Ward Cunningham&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;He is asking us to write good-quality code even when we accrue debt. &lt;strong&gt;Bad code
is bad at explaining the intent of the code.&lt;/strong&gt; It is not clear what was the
understanding when you wrote it. And when the time comes to refactor, it is that
much harder to change the code as you don&amp;rsquo;t understand why it is the way it is.&lt;/p&gt;
&lt;p&gt;The debt is supposed to be easier to pay back. Bad code makes repayment harder.
In fact, the debt metaphor works to our advantage only if we write code that is
clean enough to be understood and refactor easily when our understanding of the
problem improves.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;If you can&amp;rsquo;t refactor your software because it is poorly architected or poorly
written, &lt;strong&gt;you don&amp;rsquo;t have technical debt, you have bad software.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;&lt;strong&gt;Then, if bad code is not Tech Debt, what is?&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&#34;what-is-tech-debt&#34;&gt;What is Tech Debt?&lt;/h2&gt;
&lt;p&gt;Our understanding of the problem evolves with time, and our code should reflect
our current understanding of the problem. We accrue technical debt as the gap
between our current level of understanding and the level of understanding
reflected by the code grows. When we gain experience and understand more
subtleties and nuances of the problem, we refactor our existing code to match
the latest model. We use that experience to &lt;strong&gt;pay down the principle&lt;/strong&gt; that we
borrowed when we released code that we knew was not going to reflect a changing
reality.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Technical Debt here is the accumulated distance between our understanding of
the problem domain and the understanding that the system reflects.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;If we fail to refactor the code, we are &lt;strong&gt;paying interest on the debt&lt;/strong&gt; every
time we interact with the code; combining the two disparate models of
understanding increases cognitive overhead, leads to communications problems,
and the cost of adding features becomes higher and higher. Eventually, we simply
can&amp;rsquo;t.&lt;/p&gt;
&lt;h2 id=&#34;this-is-unfamiliar&#34;&gt;This Is Unfamiliar&amp;hellip;&lt;/h2&gt;
&lt;p&gt;If all this sounds unfamiliar, or is different from what you have read before,
it is probably because Technical Debt has become conflated with another concept
-&lt;a href=&#34;https://en.wikipedia.org/wiki/Entropy&#34;&gt;system entropy&lt;/a&gt; (a measure of the
degree of disorder in a system). It&amp;rsquo;s easy to write code quickly and ignore good
practices and factoring. Over time, all of these neglects accumulate and we end
up with code that looks more like a jungle than a clean understandable guide to
the behaviour of a system. Code that is hard to understand is very different
from code that has a different understanding of the problem.&lt;/p&gt;
&lt;h2 id=&#34;an-example-may-help&#34;&gt;An example May Help&lt;/h2&gt;
&lt;p&gt;Let us assume I am working on a feature that needs to send SMS.  I check with
other teams if we already have a service/system that can send SMS. I am told
that you are working on a Notification System/Service that combines email, SMS,
and/or InApp notifications. It will be ready in 2 months. I am also told that
every system will have to use this notification system going forward.&lt;/p&gt;
&lt;p&gt;But, I have to launch my feature in 2 weeks; I will not wait for your system to
be ready. I will use a simple SMS library/service to get things rolling.&lt;/p&gt;
&lt;p&gt;I have now taken a debt. Once the Notification system is ready and is the
de-facto thing, the debt becomes obvious. Every time we deal with my service we
have to pay the interest in the form of dealing with that SMS library. Any time
we change the Notification, we have to deal with the SMS library. Our mental
model is that every system uses the same notification system, but our code
doesn&amp;rsquo;t follow that model.&lt;/p&gt;
&lt;p&gt;Once I switch to using the notification system, I paid back the premium. No more
debt.&lt;/p&gt;
&lt;h2 id=&#34;another-example-with-code-please&#34;&gt;Another Example, With Code Please?&lt;/h2&gt;
&lt;p&gt;OK, let us take another example with code. We have an &lt;code&gt;addEvent&lt;/code&gt; method that
adds the scheduling event to a collection.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-java&#34; data-lang=&#34;java&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Scheduler&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
    &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;addEvent&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;SchedulingEvent event&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
        events&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;event&lt;span style=&#34;color:#f92672&#34;&gt;);&lt;/span&gt;
    &lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;

    &lt;span style=&#34;color:#f92672&#34;&gt;...&lt;/span&gt;
&lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;We are asked to have it do another. Whenever we receive a scheduling event, we
need to save it and send it to a peer system also. How can we make this change?&lt;/p&gt;
&lt;p&gt;It&amp;rsquo;s very easy. We just add two lines to the code:&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-java&#34; data-lang=&#34;java&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Scheduler&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
    &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;addEvent&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;SchedulingEvent event&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
        events&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;event&lt;span style=&#34;color:#f92672&#34;&gt;);&lt;/span&gt;
        peerNotifier&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;notify&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;event&lt;span style=&#34;color:#f92672&#34;&gt;);&lt;/span&gt;
        store&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;save&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;event&lt;span style=&#34;color:#f92672&#34;&gt;);&lt;/span&gt;
    &lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;

    &lt;span style=&#34;color:#f92672&#34;&gt;...&lt;/span&gt;
&lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;We’re adding more responsibilities to a class that is concerned with a different
thing. Schedulers should be about scheduling, not logging, displaying, saving,
or sending information to peers. This is violating Single Responsibility
Principle. Many incorrectly think this is &amp;lsquo;taking on tech debt&amp;rsquo;, a temporary
fix/solution to get the feature out quickly. But we are simply writing bad/messy
code.&lt;/p&gt;
&lt;p&gt;What would it be like if we refactored the original code to make it possible to
add our new feature in a pleasant way?&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-java&#34; data-lang=&#34;java&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Scheduler&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
    &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;registerEventListener&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;SchedulingEventListener listener&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
        listeners&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;listener&lt;span style=&#34;color:#f92672&#34;&gt;);&lt;/span&gt;
    &lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;

    &lt;span style=&#34;color:#66d9ef&#34;&gt;public&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;void&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;addEvent&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;SchedulingEvent event&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
        events&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;event&lt;span style=&#34;color:#f92672&#34;&gt;);&lt;/span&gt;

        &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;SchedulingEventListener listener &lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt; listeners&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;{&lt;/span&gt;
            listener&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;eventAdded&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;(&lt;/span&gt;event&lt;span style=&#34;color:#f92672&#34;&gt;)&lt;/span&gt;
        &lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;
    &lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;

    &lt;span style=&#34;color:#f92672&#34;&gt;...&lt;/span&gt;
&lt;span style=&#34;color:#f92672&#34;&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;In this version, We can easily register one listener that logs, another that
displays, and another that notifies peers - and in each of these cases, the code
in Scheduler does not have to change. We had to do a bit of work to refactor the
code to this state, but once we have, adding the feature is trivial, and
non-invasive.&lt;/p&gt;
&lt;h2 id=&#34;tracking-tech-debt&#34;&gt;Tracking Tech Debt&lt;/h2&gt;
&lt;p&gt;Now that we have some understanding of tech debt and the need for refactoring,
let us think about tracking our debt.&lt;/p&gt;
&lt;p&gt;Over time people have come up with many ways to track tech debt. One is through
&lt;strong&gt;code comments.&lt;/strong&gt; You add code comments where appropriate to document technical
debt as it arises. Try to include why you are doing it the way you are doing it
and at least one potential solution. Such comments usually start with &lt;code&gt;FIXME&lt;/code&gt;,
&lt;code&gt;TODO&lt;/code&gt;, or &lt;code&gt;OPTIMIZE&lt;/code&gt; tag. Again, remember, bad code is not tech debt. Don&amp;rsquo;t
fill your code base with FIXMEs and TODOs.&lt;/p&gt;
&lt;p&gt;It is hard to pin down all tech debt to a location in the code. It is hard to
track if there&amp;rsquo;s nowhere to document it. A &lt;strong&gt;DEBT.md&lt;/strong&gt; file provides that
location. DEBT.md is the canonical source of where and how the application code
can and should be improved. This should not be confused with how the application
can be improved.&lt;/p&gt;
&lt;p&gt;Instead of maintaining a separate file for debt, some use an &lt;strong&gt;issue tracker&lt;/strong&gt;
(Bugzilla or Jira) with a &lt;code&gt;debt&lt;/code&gt; tag.&lt;/p&gt;
&lt;p&gt;All of this may sound good in theory but have little practicality. Unless you
have a way of measuring the value/cost associated with it, there is no way you
can prioritise such a list and act upon it. And there is no good way to assign
such a value/cost to tech debt.&lt;/p&gt;
&lt;h2 id=&#34;when-to-refactor&#34;&gt;When To Refactor&lt;/h2&gt;
&lt;p&gt;Since we cannot assign a cost, we cannot prioritise debts. Then, how do we
decide when and which of the debts we tackle? The answer is simple - just like
your product backlog, for example, the priority is &amp;lsquo;when you need it&amp;rsquo;.&lt;/p&gt;
&lt;p&gt;One way to look at this problem (of picking a debt to work on) is to consider
the existing code when we are thinking of adding a feature and ask ourselves
what the code should look like to make it easier for us to add this feature.
Most of the time this involves some generalization, renaming and/or a clarifying
extraction. We can alter the structure a bit and make it ready for the change.
Sometimes this may involve a bigger change. It all depends on whether the
original design anticipated the current change or not.&lt;/p&gt;
&lt;p&gt;Look at the example above, the &lt;code&gt;Scheduler&lt;/code&gt; class did not anticipate such a
change. Or perhaps it was overkill at that time to add the observer pattern.
Either way, we changed the code to make it easier to add a new feature. We could
say this refactoring effort is the cost. But we couldn&amp;rsquo;t have known this before
the feature was even thought of.&lt;/p&gt;
&lt;p&gt;The message is clear, don&amp;rsquo;t use the debt metaphor to justify writing bad code;
you are simply degrading the internal quality. The argument that &amp;lsquo;new features
are needed urgently, and perhaps it is OK to let the code be messy&amp;rsquo; isn&amp;rsquo;t well
founded. Bad code impacts quickly and slows down the new features that are
needed quickly. We usually end up releasing slower than expected and with messy
code which is harder to refactor taking up even more effort when the time comes.
Taking on debt to speed-up delivery only works if you  write code that is clean
enough to be understood and refactored.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Consequence of Tech Debt is quicker to market now and refactoring effort
later. Consequence of bad code is apparent speed now coupled with legacy code
and code rewrite later.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;finally&#34;&gt;Finally&amp;hellip;&lt;/h2&gt;
&lt;p&gt;Technical Debt is a metaphor initially used to explain the management need for
code refactoring; it is not a development methodology or a design philosophy; it
neither tell you how to design or write code nor does it tell you when to take
debt. The debt metaphor helps us think about how to deal with design problems
and how to communicate that thinking.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Struggles Of A Newcomer To FP</title>
      <link>https://www.vijayanant.com/posts/struggles-of-a-newcomer-to-fp/</link>
      <pubDate>Thu, 09 Jun 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/struggles-of-a-newcomer-to-fp/</guid>
      <description>One of the challenges that I faced earlier on with FP is coming up with non-imperative solutions (I still do sometimes). I am sure many have faced similar hardships. We, those who have trained ourselves to think imperatively, jump to imperative solution first, then remember/realise we are lacking the corresponding tools (loops, mutability, etc) in our new favourite language (Haskell for example). Quite often this results in ugly recursive solution that we think is functional.</description>
      <content:encoded>&lt;p&gt;One of the challenges that I faced earlier on with FP is coming up with
non-imperative solutions (I still do sometimes). I am sure many have faced
similar hardships. We, those who have trained ourselves to think imperatively,
jump to imperative solution first, then remember/realise we are lacking the
corresponding tools (loops, mutability, etc) in our new favourite language
(Haskell for example). Quite often this results in ugly recursive solution that
we think is functional.&lt;/p&gt;
&lt;p&gt;Today we repeat that once again. We write a &lt;strong&gt;recursive&lt;/strong&gt; algorithm and then
modify it to work with &lt;code&gt;fold&lt;/code&gt; (and make it worse!). And then realise we missed
something basic and come up with a neat solution or two.&lt;/p&gt;
&lt;h2 id=&#34;run-length-encoding&#34;&gt;Run Length Encoding&lt;/h2&gt;
&lt;p&gt;We choose &lt;a href=&#34;https://en.wikipedia.org/wiki/Run-length_encoding&#34;&gt;Run-Length
Encoding&lt;/a&gt; (RLE) &amp;ndash; a lossless
data compression technique to implement. RLE has been used in encoding analog TV
signals, bitmap images, and in possibly many more places. Simply put, RLE
compresses a stream of data items by encoding it as data item  followed by count
of consecutive repetitions of that data. For example, &lt;code&gt;AABBBAAAAC&lt;/code&gt; is encoded as
&lt;code&gt;A2B3A4C&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Here are some more examples:&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Original&lt;/th&gt;
&lt;th&gt;Encoded&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;AAAA&lt;/td&gt;
&lt;td&gt;A4&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AABBCC&lt;/td&gt;
&lt;td&gt;A2B2C2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ABBC&lt;/td&gt;
&lt;td&gt;AB2C&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AB&lt;/td&gt;
&lt;td&gt;AB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;aaaAAAaBBb&lt;/td&gt;
&lt;td&gt;a3A3aB2b&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Vijay&lt;/td&gt;
&lt;td&gt;Vijay&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;RunLengthEncoding&lt;/td&gt;
&lt;td&gt;RunLengthEncoding&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;h2 id=&#34;approach-1---basic-recursion&#34;&gt;Approach 1 - Basic Recursion&lt;/h2&gt;
&lt;p&gt;A quick look at the example gives us our first approach. We pass through the
sequence of data while keeping a running count of repetitions and when the
repetition breaks we replace the repetition with the encoding, reset the count,
and continue with the sequence. Seems straight forward, right?&lt;/p&gt;
&lt;p&gt;The idea is simple, we start from the left, process each element (of the list)
one at a time, and accumulate the result (encoded list) in each step.&lt;/p&gt;
&lt;p&gt;Here is a &lt;code&gt;Haskell&lt;/code&gt; version.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-haskell&#34; data-lang=&#34;haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;rle1&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle1&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle1&lt;/span&gt; (x&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;xs) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; myenc1 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt; x &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt; xs

&lt;span style=&#34;color:#a6e22e&#34;&gt;myenc1&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Char&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;myenc1&lt;/span&gt; enc x n &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; enc &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; (x&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;(check n))
&lt;span style=&#34;color:#a6e22e&#34;&gt;myenc1&lt;/span&gt; enc x n  (y&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;ys) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; y &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; x &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;  myenc1 enc x (n&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;) ys
      &lt;span style=&#34;color:#66d9ef&#34;&gt;False&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; myenc1 (enc &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; (x&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;(check n))) y &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt; ys

&lt;span style=&#34;color:#a6e22e&#34;&gt;check&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;check&lt;/span&gt; n &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; n &lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; show n
        &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; otherwise &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Yes, we are going to have problem understanding what we did here in few months.
We basically have a function &lt;code&gt;myenc1&lt;/code&gt; called recursively with the current state
of the program passed as arguments.&lt;/p&gt;
&lt;p&gt;After marvelling (crying?) at the code for a while it hits us. We have turned a
list into another (possibly shorter) list. Isn&amp;rsquo;t this similar to folding
(reducing) a list?  Can we simplify this code by using &lt;code&gt;fold&lt;/code&gt;? Using higher
order functions like fold is supposed to make our code simple and &amp;lsquo;more
functional,&amp;rsquo; right?&lt;/p&gt;
&lt;p&gt;Let us give folds a shot.&lt;/p&gt;
&lt;h2 id=&#34;approach-2---folds&#34;&gt;Approach 2 - Folds&lt;/h2&gt;
&lt;p&gt;Folding is very much what we are doing. We start from the left, process each
element one at a time, and accumulate the result. Even though conceptually we
can use &lt;code&gt;foldl&#39;&lt;/code&gt; here, we have to make some changes.&lt;/p&gt;
&lt;p&gt;Firstly, the recursion is handled by fold itself. So, manual recursion calls are
no longer needed. Secondly, the fold function expects a binary function as
argument.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-haskell&#34; data-lang=&#34;haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;foldl&amp;#39;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Foldable&lt;/span&gt; t &lt;span style=&#34;color:#f92672&#34;&gt;=&amp;gt;&lt;/span&gt; (b &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; b) &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; b &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; t a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; b
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Here is what we get &amp;ndash;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-haskell&#34; data-lang=&#34;haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;rle2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle2&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle2&lt;/span&gt; (x&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;xs) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; (e, c, n) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; foldl&amp;#39; myenc2 (&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;, x, &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;) xs
    &lt;span style=&#34;color:#66d9ef&#34;&gt;in&lt;/span&gt; e &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; (c&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; check n)

&lt;span style=&#34;color:#a6e22e&#34;&gt;myenc2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;Char&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Char&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;Char&lt;/span&gt;, &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;)
&lt;span style=&#34;color:#a6e22e&#34;&gt;myenc2&lt;/span&gt; (enc, current, count) x &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;
    &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; x &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; current &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; (enc, current, count&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)
      &lt;span style=&#34;color:#66d9ef&#34;&gt;False&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; (enc &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; (current&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;check count), x, &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;strong&gt;Yuck&lt;/strong&gt;, this isn&amp;rsquo;t any better at all!!&lt;/p&gt;
&lt;h2 id=&#34;what-is-wrong&#34;&gt;What is wrong?&lt;/h2&gt;
&lt;p&gt;At this point we are frustrated enough. This is the point at which we ask
ourself what went wrong? And this is when we have to take a step back and
rethink. Is there a better way? Can we rethink the solution?&lt;/p&gt;
&lt;h2 id=&#34;a-better-approach&#34;&gt;A Better Approach?&lt;/h2&gt;
&lt;p&gt;Instead of looking at each letter, we can look at a pattern or sub-sequence as a
whole. That is, &lt;code&gt;AAADDCCCCBB&lt;/code&gt; can be seen a sequence of &lt;code&gt;A&lt;/code&gt;&amp;rsquo;s,&lt;code&gt;D&lt;/code&gt;&amp;rsquo;s,&lt;code&gt;C&lt;/code&gt;&amp;rsquo;s, and
&lt;code&gt;B&lt;/code&gt;&amp;rsquo;s in that order. If we can split the whole thing into a such a grouping, we
can treat each group separately.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-haskell&#34; data-lang=&#34;haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;rle3&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle3&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle3&lt;/span&gt; (x&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;xs) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; x&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; showLen first &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; rle3 rest
  &lt;span style=&#34;color:#66d9ef&#34;&gt;where&lt;/span&gt; (first, rest) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; span (&lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; x) xs
        showLen &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt;
        showLen s &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; show (&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;length s)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;This is much better compared to the initial solution. We no longer maintain
state between function calls. Let us take it to next level.&lt;/p&gt;
&lt;h2 id=&#34;aha&#34;&gt;Aha!!&lt;/h2&gt;
&lt;p&gt;What changed in our 3rd approach? Why is it better than the first two? One thing
for sure is we no longer have messy state management. What else? A major
enhancement is that we no longer deal with individual letters. We look at a
bunch of letter as a whole.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;The beauty of programming is to solve smaller generic problems and combining
them to solve much larger problem.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;We are onto something here! Let us look at the problem from this perspective.
Can we identify a smaller, generic problem that we can solve?&lt;/p&gt;
&lt;p&gt;Yes, here is a smaller problem - given a bunch of repeating letters, like
&amp;ldquo;&lt;code&gt;AAAAAAAA&lt;/code&gt;&amp;rdquo;, can we encode it as &amp;ldquo;&lt;code&gt;A8&lt;/code&gt;&amp;rdquo;? The next problem, then, is given a
random string of letters, can I split it into multiple smaller strings of
repeating letters? The only part left now is  how to string together these two
smaller solutions to get RLE.&lt;/p&gt;
&lt;p&gt;In summary all we need to do is&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Split a string like &amp;ldquo;AAABCCDD&amp;rdquo; into &amp;ldquo;AAA&amp;rdquo;, &amp;ldquo;B&amp;rdquo;, &amp;ldquo;CC&amp;rdquo;, and &amp;ldquo;DD&amp;rdquo;&lt;/li&gt;
&lt;li&gt;Encode the smaller strings as &amp;ldquo;A3&amp;rdquo;, &amp;ldquo;B&amp;rdquo;, &amp;ldquo;C2&amp;rdquo;, and &amp;ldquo;D2&amp;rdquo;&lt;/li&gt;
&lt;li&gt;Combine the result to get &amp;ldquo;A3BC2D2&amp;rdquo;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Here is how it will look -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-haskell&#34; data-lang=&#34;haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;encode&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;encode&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;[]&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;encode&lt;/span&gt; [x] &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; [x]
&lt;span style=&#34;color:#a6e22e&#34;&gt;encode&lt;/span&gt; s &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; head s &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; (show &lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt; length) s

&lt;span style=&#34;color:#a6e22e&#34;&gt;rle&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;rle&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; concat &lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt; map encode &lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt; group
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The &lt;code&gt;group&lt;/code&gt; function from &lt;code&gt;Data.List&lt;/code&gt; does the first part, &lt;code&gt;encode&lt;/code&gt; does the
second part, &lt;code&gt;concat&lt;/code&gt; combines the result. We then compose them together.&lt;/p&gt;
&lt;h2 id=&#34;so-what-does-it-mean&#34;&gt;So, What Does It Mean?&lt;/h2&gt;
&lt;p&gt;If we take a look at how our code/solution evolved, we notice a few things - 1)
our code improved drastically once we removed state management, 2) in the final
solution, most of the work is done by standard library functions 3) our code
evolved from describing how to solve the problem to declaring how the problem is
to be solved&lt;/p&gt;
&lt;p&gt;Aren&amp;rsquo;t these the first few things we hear about FP? Pure functions, a few but
well known abstractions, and most importantly declarative style of programming
where we write code that describes what will be done, not how it will be done.
As a beginner, sticking to these three guidelines/principles will help a lot. Of
course, there is much more to FP, but no need to hurry, it will come to you
naturally as you write more functional code.&lt;/p&gt;
&lt;p&gt;There is another lesson here for us - using a language that promotes functional
style of programming (like Haskell, Scala, Clojure, etc.) does not automatically
guarantee simple and maintainable code. If not careful, even FP cannot save us
from ugly and unmaintainable code.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Higher Ranked Types</title>
      <link>https://www.vijayanant.com/posts/higher-ranked-types/</link>
      <pubDate>Thu, 24 Jan 2019 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/higher-ranked-types/</guid>
      <description>Let&amp;rsquo;s get started with a monomorphic function -
incr :: Int -&amp;gt; Int incr = (+1) The function incr works on values of type Int and nothing else. We can make our function polymorphic by using type parameters in place of concrete types -
incr&amp;#39; :: Num a =&amp;gt; a -&amp;gt; a incr&amp;#39; = (+1) The modified function incr&#39; can work with any type that has a Num instance. Now let us move on and look at a simple higher order function -</description>
      <content:encoded>&lt;p&gt;Let&amp;rsquo;s get started with a &lt;em&gt;monomorphic&lt;/em&gt; function -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;incr&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;incr&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The function &lt;code&gt;incr&lt;/code&gt; works on values of type &lt;code&gt;Int&lt;/code&gt; and nothing else. We can make
our function &lt;em&gt;polymorphic&lt;/em&gt; by using type parameters in place of concrete types -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;incr&amp;#39;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Num&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;=&amp;gt;&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a
&lt;span style=&#34;color:#a6e22e&#34;&gt;incr&amp;#39;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; (&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The modified function &lt;code&gt;incr&#39;&lt;/code&gt; can work with any type that has a &lt;code&gt;Num&lt;/code&gt; instance.
Now let us move on and look at a simple &lt;em&gt;higher order&lt;/em&gt; function -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;foo&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; (a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a) &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a
&lt;span style=&#34;color:#a6e22e&#34;&gt;foo&lt;/span&gt; g x &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; g x

&lt;span style=&#34;color:#a6e22e&#34;&gt;intval&lt;/span&gt;  &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; foo (&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;) &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;       &lt;span style=&#34;color:#75715e&#34;&gt;-- 2&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;listval&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; foo (&lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt;[&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;]) [&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;]  &lt;span style=&#34;color:#75715e&#34;&gt;-- [1, 1]&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The first argument to &lt;code&gt;foo&lt;/code&gt; is a function of type &lt;code&gt;a -&amp;gt; a&lt;/code&gt; bound to &lt;code&gt;g&lt;/code&gt;. Is the
function &lt;code&gt;g&lt;/code&gt; polymorphic here? The answer is &lt;strong&gt;No!&lt;/strong&gt; The &lt;code&gt;a&lt;/code&gt; type is being used
polymorphically here, however, &lt;code&gt;a&lt;/code&gt; is bound to whatever is the type of &lt;code&gt;x&lt;/code&gt; when
&lt;code&gt;g&lt;/code&gt; is applied to &lt;code&gt;x&lt;/code&gt; i.e., &lt;code&gt;g&lt;/code&gt; is monomorphic!&lt;/p&gt;
&lt;p&gt;You don&amp;rsquo;t believe me? Try this&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;badfoo&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Show&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;=&amp;gt;&lt;/span&gt; (a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a) &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;badfoo&lt;/span&gt; g &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; (show (g &lt;span style=&#34;color:#ae81ff&#34;&gt;1000&lt;/span&gt;)) &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; (g &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;? what!&amp;#34;&lt;/span&gt;)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Or this function -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;badbar&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Show&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;=&amp;gt;&lt;/span&gt; (a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a) &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;IO&lt;/span&gt; ()
&lt;span style=&#34;color:#a6e22e&#34;&gt;badbar&lt;/span&gt; g &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;do&lt;/span&gt;
    print &lt;span style=&#34;color:#f92672&#34;&gt;$&lt;/span&gt; g &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;
    print &lt;span style=&#34;color:#f92672&#34;&gt;$&lt;/span&gt; g &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;why?&amp;#34;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The compiler will not be happy with this code. If &lt;code&gt;g&lt;/code&gt; were polymorphic, we
could apply it to both numeric and string values!&lt;/p&gt;
&lt;h2 id=&#34;polymorphic-functions&#34;&gt;Polymorphic Functions&lt;/h2&gt;
&lt;p&gt;We make our functions polymorphic by using type parameters instead of fixing the
types. When the function is s applied to a value, the type parameter(s) are
bound to actual type(s). We say the function is &lt;em&gt;instantiated&lt;/em&gt; with the given
types. The actual types (of type variables) are set to the types of values
passed to the function.&lt;/p&gt;
&lt;p&gt;Actual type of a polymorphic function is decided where the function is used, not
where the function is defined, i.e., the user of the function decides the type.&lt;/p&gt;
&lt;p&gt;Same applies to higher order functions. If the types of the argument function are
parameterised, the actual types are decided when the argument function is used.&lt;/p&gt;
&lt;p&gt;Coming back to &lt;code&gt;badfoo&lt;/code&gt; function, the type of the argument function is &lt;code&gt;(a -&amp;gt; a)&lt;/code&gt;. The type for type variable  &lt;code&gt;a&lt;/code&gt; in &lt;code&gt;(a -&amp;gt; a)&lt;/code&gt; is bound when this function
is applied to a value (when we call &lt;code&gt;g 1&lt;/code&gt;). This means, for the reminder of this
function body, &lt;code&gt;g&lt;/code&gt; is monomorphic.&lt;/p&gt;
&lt;p&gt;What we wanted, though, is for &lt;code&gt;g&lt;/code&gt; to be polymorphic. We want the type of &lt;code&gt;g&lt;/code&gt; to
be bound when user calls &lt;code&gt;badfoo&lt;/code&gt; - not when &lt;code&gt;g&lt;/code&gt; is used within &lt;code&gt;badfoo&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&#34;rank&#34;&gt;Rank&lt;/h2&gt;
&lt;p&gt;Whenever we want to pass a polymorphic function &lt;code&gt;g&lt;/code&gt; as an argument to another
function &lt;code&gt;f&lt;/code&gt;, we want the type of &lt;code&gt;g&lt;/code&gt; to be decided not within the body of &lt;code&gt;f&lt;/code&gt;
but at the caller site - one level up so to say. We say, &lt;code&gt;f&lt;/code&gt; is ranked one level
higher than &lt;code&gt;g&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;All monomorphic functions are &lt;strong&gt;Rank 0&lt;/strong&gt;. All polymorphic functions are Rank 1.
A rank-2 polymorphic function takes as an argument a rank-1 polymorphic
function. A rank-3 functions takes as an argument a rank-2 polymorphic function,
and so on.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;If a higher order function takes as argument a rank (N-1) function,
then it is said to be &lt;strong&gt;Rank-N&lt;/strong&gt; polymorphic function.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;rankntypes-ghc-extension&#34;&gt;RankNTypes GHC Extension&lt;/h2&gt;
&lt;p&gt;Haskell is based on the Hindley-Milner type system - and while it allows us to
write polymorphic functions, it doesn&amp;rsquo;t allow us to write functions which take
polymorphic functions as arguments.&lt;/p&gt;
&lt;p&gt;Higher Ranked Types are provided in GHC as a language extension. It can be
enabled via the &lt;code&gt;RankNTypes&lt;/code&gt; extension. Practically speaking, enabling
higher-ranked types lets us introduce new variable scopes inside of type
signatures.&lt;/p&gt;
&lt;p&gt;Here&amp;rsquo;s the implementation we want:&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#75715e&#34;&gt;{-# LANGUAGE RankNTypes #-}&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;goodfoo&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; (forall a&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Show&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;=&amp;gt;&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a) &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;goodfoo&lt;/span&gt; g &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; (show (g &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)) &lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt; (g &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;Works!&amp;#34;&lt;/span&gt;)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Higher Ranked Types make polymorphic Haskell functions &lt;em&gt;first class&lt;/em&gt;.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>GADTs Talk - Bengaluru Haskell Meetup</title>
      <link>https://www.vijayanant.com/posts/gadts-talk-bengaluru-haskell-meetup/</link>
      <pubDate>Thu, 29 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/gadts-talk-bengaluru-haskell-meetup/</guid>
      <description>Last week I gave a talk at [The Bangalore Haskell User Group] (https://www.meetup.com/The-Bangalore-Haskell-User-Group/) on using GADTs to bring compile time correctness to Haskell programs. The focus of the talk was more towards advocating using Haskell type system features where possible to simplify code. The aim was to show how error handling code can be avoided/removed and still achieve type-safety.
The presentation used for the talk is available here.
I had written a more detailed writeup on the same topic here.</description>
      <content:encoded>&lt;p&gt;Last week I gave a talk at [The Bangalore Haskell User Group]
(&lt;a href=&#34;https://www.meetup.com/The-Bangalore-Haskell-User-Group/&#34;&gt;https://www.meetup.com/The-Bangalore-Haskell-User-Group/&lt;/a&gt;) on using GADTs to
bring compile time correctness to Haskell programs. The focus of the talk was
more towards advocating using Haskell type system features where possible to
simplify code. The aim was to show  how error handling code can be
avoided/removed and still achieve type-safety.&lt;/p&gt;
&lt;p&gt;The presentation used for the talk is available
&lt;a href=&#34;https://www.vijayanant.com/presentations/gadt.pdf&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;I had written a more detailed writeup on the same topic &lt;a href=&#34;https://www.vijayanant.com/posts/gadts-to-eliminate-runtime-checks/&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>The Expression Problem</title>
      <link>https://www.vijayanant.com/posts/the-expression-problem/</link>
      <pubDate>Tue, 13 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/the-expression-problem/</guid>
      <description>In the previous post I had put forward (rather hastily, I must add) my thoughts on what does expressiveness mean for programming languages. I had this feeling of forgetting something important but couldn&amp;rsquo;t pinpoint what it was. Today, while sipping a hot cup of coffee, I remembered the expression problem.
The Expression Problem is a well known problem in programming language theory dealing with the expressiveness of a programming language. Here is Philip Wadler&amp;rsquo;s original statement of the problem.</description>
      <content:encoded>&lt;p&gt;In the &lt;a href=&#34;https://www.vijayanant.com/posts/expressiveness/&#34;&gt;previous post&lt;/a&gt; I had put forward
(rather hastily, I must add) my thoughts on what does expressiveness mean for
programming languages. I had this feeling of forgetting something important but
couldn&amp;rsquo;t pinpoint what it was. Today, while sipping a hot cup of coffee, I
remembered &lt;strong&gt;the expression problem&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;The Expression Problem is a well known problem in programming language theory
dealing with the expressiveness of a programming language. Here is &lt;a href=&#34;http://homepages.inf.ed.ac.uk/wadler/papers/expression/expression.txt&#34;&gt;Philip
Wadler&amp;rsquo;s original statement&lt;/a&gt; of the
problem.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;The Expression Problem is a new name for an old problem. The goal is to define
a datatype by cases, where one can add new cases to the datatype and new
functions over the datatype, without recompiling existing code, and while
retaining static type safety (e.g., no casts).&lt;/p&gt;
&lt;p&gt;&amp;ndash;  &lt;em&gt;Philip Wadler&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;He goes on to say &amp;ldquo;&lt;em&gt;Whether a language can solve the Expression Problem is a salient
indicator of its capacity for expression.&lt;/em&gt;&amp;rdquo;&lt;/p&gt;
&lt;p&gt;In this post, we will see two examples, one in Java and one in Haskell to
understand the problem.&lt;/p&gt;
&lt;h2 id=&#34;oo-programming&#34;&gt;OO Programming&lt;/h2&gt;
&lt;p&gt;In Object Oriented Programming, it is easy to add new datatypes by defining new
(sub)classes. Since classes encapsulate the operations on the data type, no existing
code needs to be modified. However, adding new functions (operations) over the
datatype is hard. All the datatypes have to be modified and recompiled.&lt;/p&gt;
&lt;p&gt;Below is a java version explaining the problem. If you want to add new operation
on the expressions (say, to type-check), you will have to add the new operation
to each object type (Literal and Add) forcing a recompilation of these classes.&lt;/p&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://gist.github.com/vijayanant/231b2470b98a92d38d54c7b982ab6503.js?file=ExpressonProblem.java&#34;&gt;&lt;/script&gt;

&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Visitor_pattern&#34;&gt;Visitor design pattern&lt;/a&gt; in OO
programming is a known solution to cases where new operations are added over
existing type (hierarchy). However, by using this pattern we will restrict our
ability to add new types. Adding new (element) class (to the hierarchy) forces
changes to all the visitor classes and needs recompilation.&lt;/p&gt;
&lt;!-- raw HTML omitted --&gt;
&lt;!-- raw HTML omitted --&gt;
&lt;h2 id=&#34;functional-programming&#34;&gt;Functional Programming&lt;/h2&gt;
&lt;p&gt;In functional programming, we think of functions that operate on values of
certain types. It is easy to add new functions that operate on a datatype. To
add new case to the datatype, we will have to modify all the functions to cater
for the new case.&lt;/p&gt;
&lt;p&gt;Typeclasses in Haskell offer a solution. But a naive use of type classes will
not work either! In the below code, the expression&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;then&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Lit&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;10&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Add&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Lit&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;) (&lt;span style=&#34;color:#66d9ef&#34;&gt;Lit&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;does not typecheck even thought both &lt;code&gt;Lit&lt;/code&gt; and &lt;code&gt;Add&lt;/code&gt; are instances of &lt;code&gt;Exp&lt;/code&gt;
typeclass.&lt;/p&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://gist.github.com/vijayanant/231b2470b98a92d38d54c7b982ab6503.js?file=ExpressionProblem.hs&#34;&gt;&lt;/script&gt;

&lt;p&gt;In the &lt;em&gt;functional pearl&lt;/em&gt; &lt;a href=&#34;http://www.cs.ru.nl/~W.Swierstra/Publications/DataTypesALaCarte.pdf&#34;&gt;Data types a la carte&lt;/a&gt;,  &lt;em&gt;Wouter
Swierstra&lt;/em&gt; proposes a solution to the expression problem. Philip Wadler himself
calls this the &lt;a href=&#34;http://wadler.blogspot.com/2008/02/data-types-la-carte.html&#34;&gt;best solution in Haskell&lt;/a&gt;.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Expressiveness</title>
      <link>https://www.vijayanant.com/posts/expressiveness/</link>
      <pubDate>Thu, 08 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/expressiveness/</guid>
      <description>Last week, I wrote a post comparing simple programs written in Haskell, Python, and Java to demonstrate the expressiveness of Haskell. It got me thinking whether expressiveness is something we can compare between any two programming languages.
Conciseness One thing that is very visible among the three implementations is the size of the programs. Is that a good measure of expressiveness of a language? I don&amp;rsquo;t think so. If being concise is what makes a language expressive, obfuscated C programs would be everywhere and even encouraged.</description>
      <content:encoded>&lt;p&gt;Last week, I wrote a post comparing simple programs written in Haskell, Python,
and Java to demonstrate the &lt;a href=&#34;https://www.vijayanant.com/posts/expressiveness-of-haskell/&#34;&gt;expressiveness of Haskell&lt;/a&gt;. It got me thinking
whether expressiveness is something we can compare between any two programming
languages.&lt;/p&gt;
&lt;h2 id=&#34;conciseness&#34;&gt;Conciseness&lt;/h2&gt;
&lt;p&gt;One thing that is very visible among the three implementations is the size of
the programs. Is that a good measure of expressiveness of a language? I don&amp;rsquo;t
think so. If being concise is what makes a language expressive, &lt;a href=&#34;https://www.ioccc.org&#34;&gt;obfuscated C&lt;/a&gt; programs would be everywhere and even encouraged.&lt;/p&gt;
&lt;p&gt;We also have &lt;a href=&#34;https://en.wikipedia.org/wiki/APL_(programming_language)&#34;&gt;APL&lt;/a&gt;, a
unique mathematically-inclined programming language designed for conciseness. To
anyone unfamiliar with the syntax of the language, APL looks like a series of
nonsensical graphical symbols, letters, and numbers. However, to an APL
programmer, each graphical symbol or set of symbols stands in for a mathematical
function.&lt;/p&gt;
&lt;p&gt;Trying to be concise took away expressiveness in the case of C but is the
strength of APL.&lt;/p&gt;
&lt;h2 id=&#34;type-system&#34;&gt;Type System&lt;/h2&gt;
&lt;p&gt;Type systems restrict possible valid programs in a language. This, in some
sense, should make the statically checked, strongly typed languages less
expressive than the dynamically checked, weakly typed languages as there are
less valid programs that can be constructed. Some programs are invalid in
strongly typed languages but are valid in weakly typed languages.&lt;/p&gt;
&lt;p&gt;But, both &lt;a href=&#34;https://en.wikipedia.org/wiki/Haskell_(programming_language)&#34;&gt;Haskell&lt;/a&gt; and &lt;a href=&#34;https://en.wikipedia.org/wiki/Lisp_(programming_language)&#34;&gt;Lisp&lt;/a&gt; are considered
highly expressive languages. Haskell is strongly typed and statically checked
where as Lisp is weakly typed (compared to Haskell) and dynamically checked
language.&lt;/p&gt;
&lt;h2 id=&#34;programming-paradigm&#34;&gt;Programming Paradigm&lt;/h2&gt;
&lt;p&gt;I don&amp;rsquo;t consider &lt;a href=&#34;https://www.vijayanant.com/posts/thinking-in-imperative-object-oriented-and-functional-way/&#34;&gt;programming paradigm&lt;/a&gt; to be a property of a programming language, it is rather something that a
language promotes. This is evident in Python which provides many constructs to
supports procedural, object oriented, and functional style of programming.&lt;/p&gt;
&lt;p&gt;However, it is definitely possible that some problems and/or their solutions are
better expressed in one style than in other.&lt;/p&gt;
&lt;h2 id=&#34;time&#34;&gt;Time&lt;/h2&gt;
&lt;p&gt;How quickly can you express your ideas in a language can also be a measure of
expressiveness. Dynamically typed languages, like Python, Ruby, etc., are
considered to excel at this.  However, proponents of modern statically typed
languages like Haskell claim that its &lt;a href=&#34;https://en.wikipedia.org/wiki/Type_inference&#34;&gt;type inferencing&lt;/a&gt; mechanism nullifies this
advantage by being quick to write programs and providing static type safety.&lt;/p&gt;
&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;It might be safe to consider expressiveness of a language to be some combination
of each of the above factors. But that adds more fuel to the confusion. What is
the right balance? How do we compare two languages with different &lt;em&gt;weights&lt;/em&gt;
associated with each the above factors?&lt;/p&gt;
&lt;p&gt;We can also go by the definition where expressiveness is simple measure of all
the things that can be expressed in that language. Most general purpose
programing languages are &lt;a href=&#34;https://en.wikipedia.org/wiki/Turing_completeness&#34;&gt;Turing Complete&lt;/a&gt;, that is  they can express
anything &lt;em&gt;computable&lt;/em&gt;.&lt;/p&gt;
&lt;p&gt;I think each programming language defines what expressiveness means for that
language.&lt;/p&gt;
&lt;p&gt;For Lisp and family, being able to express almost anything with its macro system
is its expressive power. For Haskell and family, it is its type system which
allows expressing abstract concepts clearly with added type safety. For Python and
other dynamic languages, expressiveness is a measure of how quickly you can
express the abstraction.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Expressiveness of Haskell</title>
      <link>https://www.vijayanant.com/posts/expressiveness-of-haskell/</link>
      <pubDate>Sun, 04 Nov 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/expressiveness-of-haskell/</guid>
      <description>My goto answer when someone asks why I like Haskell so much these days is usually &amp;ldquo;I like the expressiveness and run time guarantees of Haskell&amp;rdquo;. For those who are little more interested, I would usually show the popular quick sort or merge sort implementations. I wanted a slightly more complicated, yet commonly known, example to demonstrate what I claimed. This is an attempt at coming up with such an example.</description>
      <content:encoded>&lt;p&gt;My goto answer when someone asks why I like &lt;a href=&#34;https://www.haskell.org&#34;&gt;Haskell&lt;/a&gt;
so much these days is usually &lt;em&gt;&amp;ldquo;I like the expressiveness and run time
guarantees of Haskell&amp;rdquo;.&lt;/em&gt; For those who are little more interested, I would
usually show the popular quick sort or merge sort implementations. I wanted a
slightly more complicated, yet commonly known, example to demonstrate what I
claimed. This is an attempt at coming up with such an example.   And turning it
into a blog post makes it available for me all the time (and for other too!!).&lt;/p&gt;
&lt;p&gt;I choose Python and Java as other two languages as they are the ones I am fairly
comfortable with and also because they are representatives of objected oriented
and dynamically typed languages. I do not claim mastery over any of these
languages. If you have any suggestions on making any of the these
implementations more expressive, let me know and I will update the sample
accordingly. Other languages are welcome too!&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Edit: &lt;a href=&#34;https://www.vijayanant.com/posts/expressiveness/&#34;&gt;Here&lt;/a&gt; is my take on what
expressiveness mean&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;All three versions do the same thing. Define a simple &lt;code&gt;Tree&lt;/code&gt; type. Instead of
constructing the tree one-element-at-a-time, we provide a convenient function
&lt;code&gt;fromList&lt;/code&gt; which takes a list and adds its elements to tree. We also provide a
way to turn the &lt;code&gt;Tree&lt;/code&gt; back to a list by providing &lt;code&gt;inorder&lt;/code&gt; function to
&lt;a href=&#34;https://en.wikipedia.org/wiki/Tree_traversal&#34;&gt;traverse the tree in-order&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The tree construction happens like this: we split the list in to three parts -
middle element, left-sublist and right-sublist. Then, we recursively construct
left and right sub-tree with the two split parts of the list. The middle element
is used at the current node. Why we do it this way? If you pass a sorted list,
this will construct a binary search tree. In-order traversal on that tree should
return the original sorted list back!&lt;/p&gt;
&lt;h2 id=&#34;haskell&#34;&gt;Haskell&lt;/h2&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://gist.github.com/vijayanant/d557b72bea0eda2b3490ba8e059fb486.js?file=Tree.hs&#34;&gt;&lt;/script&gt;

&lt;h2 id=&#34;python&#34;&gt;Python&lt;/h2&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://gist.github.com/vijayanant/d557b72bea0eda2b3490ba8e059fb486.js?file=Tree.py&#34;&gt;&lt;/script&gt;

&lt;h2 id=&#34;java&#34;&gt;Java&lt;/h2&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://gist.github.com/vijayanant/d557b72bea0eda2b3490ba8e059fb486.js?file=Tree.java&#34;&gt;&lt;/script&gt;

</content:encoded>
    </item>
    
    <item>
      <title>Dependent Types To Eliminate Runtime Checks</title>
      <link>https://www.vijayanant.com/posts/dependent-types-to-eliminate-runtime-checks/</link>
      <pubDate>Fri, 26 Oct 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/dependent-types-to-eliminate-runtime-checks/</guid>
      <description>One of the main advantages of static type checking is to catch errors before we deploy code to production. Dependent Types allow us to eliminate some checks that are usually done at run time. I take a simple example to show how dependent types can be used in that regard in day-to-day programming.
Give Me The Money! Let us start with an example. We will define a simple type for representing money and a function to add money.</description>
      <content:encoded>&lt;p&gt;One of the main advantages of &lt;a href=&#34;https://en.wikipedia.org/wiki/Type_system#Static_type_checking&#34;&gt;static type checking&lt;/a&gt; is to catch
errors before we deploy code to production.  &lt;a href=&#34;https://en.wikipedia.org/wiki/Dependent_type&#34;&gt;Dependent Types&lt;/a&gt; allow us to eliminate some checks
that are usually done at run time. I take a simple example to show how dependent
types can be used in that regard in day-to-day programming.&lt;/p&gt;
&lt;h2 id=&#34;give-me-the-money&#34;&gt;Give Me The Money!&lt;/h2&gt;
&lt;p&gt;Let us start with an example. We will define a simple type for representing
money and a function to add money.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Rational&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Now we can add them together as&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; m1) (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; m2)  &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (m1 &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; m2)

&lt;span style=&#34;color:#a6e22e&#34;&gt;money1&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (&lt;span style=&#34;color:#ae81ff&#34;&gt;50&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;)
&lt;span style=&#34;color:#a6e22e&#34;&gt;money2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (&lt;span style=&#34;color:#ae81ff&#34;&gt;25&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;)

&lt;span style=&#34;color:#a6e22e&#34;&gt;total&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; add money1 money2
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;everything-ok-there&#34;&gt;Everything OK There?&lt;/h2&gt;
&lt;p&gt;There is something we have missed here. The currency. Money is represented in
some &lt;em&gt;currency&lt;/em&gt; (like US Dollar) and we cannot add money in different
currencies. For example, you cannot add 2 US dollars and 2 British Pounds.&lt;/p&gt;
&lt;p&gt;Lets include currency information in our &lt;code&gt;Money&lt;/code&gt; type. A simple approach is to
keep a string representing the currency (&amp;ldquo;GBP&amp;rdquo;, &amp;ldquo;USD&amp;rdquo;, etc.) along with the
amount.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;String&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Rational&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;twoDollars&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;twoDollars&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;USD&amp;#34;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;houston-weve-got-a-problem&#34;&gt;Houston, We&amp;rsquo;ve Got a Problem&lt;/h2&gt;
&lt;p&gt;The constraint that only &lt;code&gt;Money&lt;/code&gt; values with same &lt;code&gt;currency&lt;/code&gt; can be added makes
our &lt;code&gt;add&lt;/code&gt; function &lt;a href=&#34;https://en.wikipedia.org/wiki/Partial_function&#34;&gt;partial&lt;/a&gt;.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;   (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c1 m1) (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c2 m2) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; c1 &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; c2 &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
          &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt;  &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;  &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c1 (m2 &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; m2)
      &lt;span style=&#34;color:#75715e&#34;&gt;--  False -&amp;gt;  ??  -- the function is not defined for this value &lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Partial functions are bad. They pass type check and fail at runtime. The
application crashes when inputs for which the function is not defined are
passed. Our &lt;code&gt;add&lt;/code&gt; function above fails if it is ever called with two &lt;code&gt;Money&lt;/code&gt;
values with different currency.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t add fiftyPence twoDollars
&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; fiftyPence twoDollars &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; add fiftyPence twoDollars
&lt;span style=&#34;color:#f92672&#34;&gt;***&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Exception:&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Users&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt;vj&lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt;workspace&lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Haskell&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;/&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;hs&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;(&lt;span style=&#34;color:#ae81ff&#34;&gt;23&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;)&lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;(&lt;span style=&#34;color:#ae81ff&#34;&gt;24&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;37&lt;/span&gt;)&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Non&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;exhaustive patterns &lt;span style=&#34;color:#66d9ef&#34;&gt;in&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;improvise-adapt-overcome&#34;&gt;Improvise, Adapt, Overcome&lt;/h2&gt;
&lt;p&gt;A simple way to overcome this problem is to extend the function to return a
specific value (an &lt;em&gt;error&lt;/em&gt; value) for all those inputs for which the function is
not defined.&lt;/p&gt;
&lt;p&gt;Wrapping the return type with &lt;code&gt;Maybe&lt;/code&gt; or &lt;code&gt;Either e&lt;/code&gt; are common approaches to
extending the function. A special value of &lt;code&gt;Nothing::Maybe Money&lt;/code&gt; (or &lt;code&gt;Left &amp;quot;Incompatible Currency&amp;quot;::Either String Money&lt;/code&gt;) can be returned for all the
inputs where &lt;code&gt;add&lt;/code&gt; is originally not defined.&lt;/p&gt;
&lt;p&gt;A simple addition function now has to deal with error cases. If we decide to
indicate an error using &lt;code&gt;Maybe Money&lt;/code&gt; or &lt;code&gt;Either Error Money&lt;/code&gt; as return type,
the calling function also has to deal with such a value appropriately (may be by
returning an error to its caller!).&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Maybe&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt;   (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c1 m1) (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c2 m2) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; 
      &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; c1 &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; c2 &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
          &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt;  &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Just&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c1 (m2 &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; m2))
          &lt;span style=&#34;color:#66d9ef&#34;&gt;False&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Nothing&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;independence-freedom-what&#34;&gt;Independence? Freedom? What?&lt;/h2&gt;
&lt;p&gt;Using dependent types we can avoid the runtime check by making it possible for
the compiler to do that check for us. Since the compiler prohibits calling our
&lt;code&gt;add&lt;/code&gt; function with incompatible money values, we are not only freed from
runtime check, we also don&amp;rsquo;t have to worry about error handling.&lt;/p&gt;
&lt;p&gt;This is in contrast to extending the function. Here we &lt;em&gt;restrict the domain of
the function&lt;/em&gt; to contain only those values for which the function is defined.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Dependent Types are advanced concepts. But we don&amp;rsquo;t have to know all the
theory and concepts behind it as many good people have made it so simple for
us to use it. But I recommend you all to read and know more to use them in
more interesting ways.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#75715e&#34;&gt;{-# LANGUAGE KindSignatures, DataKinds #-}&lt;/span&gt;

&lt;span style=&#34;color:#66d9ef&#34;&gt;import&lt;/span&gt; GHC.TypeLits (&lt;span style=&#34;color:#66d9ef&#34;&gt;Symbol&lt;/span&gt;)
&lt;span style=&#34;color:#66d9ef&#34;&gt;import&lt;/span&gt; Data.Ratio ((&lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt;))

&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (currency &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Symbol&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Rational&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;fiftyPence&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;fiftyPence&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (&lt;span style=&#34;color:#ae81ff&#34;&gt;50&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;)

&lt;span style=&#34;color:#a6e22e&#34;&gt;twoDollars&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;USD&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;twoDollars&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; c
&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; m1) (&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; m2) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (m1 &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; m2)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Notice how the implementation of &lt;code&gt;add&lt;/code&gt; function is same as the one before
introducing &lt;code&gt;currency&lt;/code&gt; parameter. It has no if/case expressions and no &lt;code&gt;Maybe&lt;/code&gt;
return type. It is a compilation error to add &lt;code&gt;Money&lt;/code&gt; values with different
currency.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t add fiftyPence fiftyPence
&lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; fiftyPence fiftyPence &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t add fiftyPence twoDollars

&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;interactive&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;16&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;error&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;
    &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;•&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Couldn&amp;#39;t&lt;/span&gt; match &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;USD&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt; with &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;Expected&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;
        &lt;span style=&#34;color:#66d9ef&#34;&gt;Actual&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;USD&amp;#34;&lt;/span&gt;
    &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;•&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;In&lt;/span&gt; the second argument &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;add&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;, namely &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;twoDollars&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;In&lt;/span&gt; the expression&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; add fiftyPence twoDollars
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;We use &lt;em&gt;language extensions&lt;/em&gt; in GHC for using dependent types. I will try to
explain their usage in simple terms.&lt;/p&gt;
&lt;h2 id=&#34;be-kind-to-others&#34;&gt;Be Kind To Others&lt;/h2&gt;
&lt;p&gt;Notice the type of &lt;code&gt;fiftyPence&lt;/code&gt; -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;fiftyPence&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;Money&lt;/code&gt; is a &lt;em&gt;type constructor&lt;/em&gt;, as we know, type constructors only accepts
other types as parameters (&lt;code&gt;Maybe Int&lt;/code&gt;, &lt;code&gt;[Int]&lt;/code&gt; etc.). But, &lt;code&gt;&amp;quot;GBP&amp;quot;&lt;/code&gt; looks like a
String value! How is this possible?&lt;/p&gt;
&lt;p&gt;Firstly, &lt;code&gt;&amp;quot;GBP&amp;quot;&lt;/code&gt; in &lt;code&gt;fiftyPence :: Money &amp;quot;GBP&amp;quot;&lt;/code&gt; is not a value but a type with
&lt;strong&gt;kind&lt;/strong&gt; &lt;code&gt;Symbol&lt;/code&gt;. You can see that in the data definition of Money. &lt;code&gt;currency&lt;/code&gt;
type parameter is of kind &lt;code&gt;Symbol&lt;/code&gt;.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (currency &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Symbol&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Rational&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;Symbol&lt;/code&gt; is a convenient Kind provided by GHC in the &lt;code&gt;GHC.TypeLits&lt;/code&gt; module which
is the kind for type-level strings. It lets us use string literals like &amp;ldquo;GBP&amp;rdquo; as
a type.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;You know that we can manually specify a variable&amp;rsquo;s type. Similarly, we can also
manually specify a type variable&amp;rsquo;s kind using the &lt;em&gt;&lt;strong&gt;KindSignatures&lt;/strong&gt;&lt;/em&gt;
extension.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;congratulations-you-have-been-promoted&#34;&gt;Congratulations! You have Been Promoted&lt;/h2&gt;
&lt;p&gt;OK, So, &lt;code&gt;KindSignatures&lt;/code&gt; extension lets me specify that &lt;code&gt;currency&lt;/code&gt; has kind
&lt;code&gt;Symbol&lt;/code&gt;, but how does &lt;code&gt;&amp;quot;GBP&amp;quot;&lt;/code&gt; and &lt;code&gt;&amp;quot;USD&amp;quot;&lt;/code&gt; become types of of kind &lt;code&gt;Symbol&lt;/code&gt;?&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;fiftyPence&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;fiftyPence&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; (&lt;span style=&#34;color:#ae81ff&#34;&gt;50&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;)

&lt;span style=&#34;color:#a6e22e&#34;&gt;twoDollars&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;USD&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;twoDollars&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;This is all thanks to another GHC extension we have used - &lt;em&gt;&lt;strong&gt;DataKinds&lt;/strong&gt;.&lt;/em&gt; When
this extension is enabled, the type constructors are &lt;em&gt;promoted&lt;/em&gt; to Kinds and value
constructors are promoted to type constructors.&lt;/p&gt;
&lt;p&gt;In our case, the kind &lt;code&gt;Symbol&lt;/code&gt; is already provided by GHC. All we need is for
GHC to promote and recognize &lt;code&gt;&amp;quot;GBP&amp;quot;&lt;/code&gt; as type.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;k &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;

&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;interactive&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;error&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;
    &lt;span style=&#34;color:#66d9ef&#34;&gt;Illegal&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Perhaps&lt;/span&gt; you intended to use &lt;span style=&#34;color:#66d9ef&#34;&gt;DataKinds&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;set &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;XDataKinds&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;k &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt;
&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;GBP&amp;#34;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;λ&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;k &lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;

&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;interactive&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;error&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;
    &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;•&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expected&lt;/span&gt; kind &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Symbol&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;, but &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt; has kind &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;
    &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;•&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;In&lt;/span&gt; the first argument &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;, namely &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;In&lt;/span&gt; the &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt; &lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;‘&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Money&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;blockquote&gt;
&lt;p&gt;The promoted types, &lt;code&gt;&amp;quot;GBP&amp;quot;&lt;/code&gt; and &lt;code&gt;&amp;quot;USD&amp;quot;&lt;/code&gt; in the above example, have no
inhabitants.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;Also, promoted types are prefixed with a quote (&lt;code&gt;&#39;&amp;quot;GBP&amp;quot;&lt;/code&gt; and &lt;code&gt;&#39;&amp;quot;USD&amp;quot;&lt;/code&gt;) but they
can almost always be ignored as the context of their usage makes it clear which
one we meant - the type &amp;ldquo;GBP&amp;rdquo; or the string value &amp;ldquo;GBP&amp;rdquo;.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;the-beginning&#34;&gt;The Beginning&lt;/h2&gt;
&lt;p&gt;There is much more to depended types than what we have seen here. This is to
show readers that dependent types can be useful in day-to-day programming as
well.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Distributed Systems and Scalable Databases</title>
      <link>https://www.vijayanant.com/posts/distributed-systems-and-scalable-databases/</link>
      <pubDate>Mon, 08 Oct 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/distributed-systems-and-scalable-databases/</guid>
      <description>The simplest of applications we can write and maintain are the ones that run within a single thread on a single processor. We know why we don&amp;rsquo;t do that, because there is only so much we can achieve with such a system.
The main concerns with this set up are:
 Scale : We need more resources (CPU, memory, or storage) than what is available on single server. Buying bigger server, even if available, is not efficient in terms of cost and server utilisation.</description>
      <content:encoded>&lt;p&gt;The simplest of applications we can write and maintain are the ones that run
within a single thread on a single processor. We know why we don&amp;rsquo;t do that,
because there is only so much we can achieve with such a system.&lt;/p&gt;
&lt;p&gt;The main concerns with this set up are:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;em&gt;&lt;strong&gt;Scale&lt;/strong&gt;&lt;/em&gt; : We need more resources (CPU, memory, or storage) than what is
available on single server. Buying bigger server, even if available, is not
efficient in terms of cost and server utilisation. Different functionalities
might require different combination of resources and resource characteristics.&lt;/li&gt;
&lt;li&gt;&lt;em&gt;&lt;strong&gt;Resilience&lt;/strong&gt;&lt;/em&gt; : Any software and hardware can fail/crash. Running an
application on single machine is single point of failure. We prefer to have
our application be available for users and work as expected even under cases
of hardware and/or software failures.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A Distributed System provides an alternative approach to scaling and makes our
system resilient to hardware and software failures.&lt;/p&gt;
&lt;h3 id=&#34;distributed-system&#34;&gt;Distributed System&lt;/h3&gt;
&lt;blockquote&gt;
&lt;p&gt;A distributed system is a collection of independent computers that appears to
its users as a single coherent system.&lt;/p&gt;
&lt;p&gt;&amp;ndash; &lt;em&gt;Andrew S. Tanenbaum&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;For example, amazon.com appears to us as a single computer even though many
computers are working together behind the scene.&lt;/p&gt;
&lt;p&gt;This simple definition focuses on two important factors:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;the system consists of components (computers) that are autonomous.&lt;/li&gt;
&lt;li&gt;to its users, humans or programs, the system appears as though they are
dealing with single system/computer.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;For independent component to work as a coherent system, the components must
&lt;strong&gt;collaborate&lt;/strong&gt; among themselves. Effective collaboration among components lies
at the heart of distributed system.&lt;/p&gt;
&lt;h3 id=&#34;characteristics-of-distributed-systems&#34;&gt;Characteristics of Distributed Systems&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;The computers operate concurrently&lt;/li&gt;
&lt;li&gt;The computers fail independently&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Since all the computers function concurrently, and independently, we can scale
easily by adding more computers (or remove computers when not required). Even if
one or more of those computers fail, it will not affect the entire system and
all the features of our system will be available all the time.&lt;/p&gt;
&lt;p&gt;Even though Distributed System overcome the concerns of scaling and resiliency,
complexity of such a system greatly increases. Even the simplest of application,
when distributed across computers, becomes complex. Simple things like storing
data, computing, and passing data across components becomes hard.&lt;/p&gt;
&lt;h2 id=&#34;scaling-database&#34;&gt;Scaling Database&lt;/h2&gt;
&lt;p&gt;We will see many approaches to scale data storage and the challenges that
arise because of that.&lt;/p&gt;
&lt;h3 id=&#34;single-master-storage&#34;&gt;Single Master Storage&lt;/h3&gt;
&lt;p&gt;We all are aware of this simple data storage model. The database runs on a
single server. If you wanted to scale you run the database on a much bigger
server. At some point, the single server fails to perform as best as did due to
lack of resources.&lt;/p&gt;
&lt;h3 id=&#34;read-replication&#34;&gt;Read Replication&lt;/h3&gt;
&lt;p&gt;This, in many ways, was the first approach to &lt;em&gt;scaling horizontally.&lt;/em&gt; We
realised that most of web application traffic was read and we thought of
splitting read and write requests to different servers (called nodes).&lt;/p&gt;
&lt;p&gt;The concept is simple. All writes still go to a single master and then the
writes are propagated to the followers. The read requests are handled by the
follower nodes. This allows for master to handle much more write traffic and
multiple follower nodes can handle a lot of read request and it is a matter of
adding new follower node to cater for increased read requests.&lt;/p&gt;
&lt;p&gt;Even though this seemingly simple arrangement allows us to handle more load by
distributing read and write request to different nodes, we have broken the
consistency. &lt;strong&gt;The database is no longer consistent&lt;/strong&gt; (even if the database we
are using is a relational database). When we write to master node the write has
to propagate to the follower nodes before it can be read. There is a small time
window during which the write has completed but the read operation fails. There
is, however small, a delay  for follower nodes to have the latest data. This is
&lt;em&gt;Eventually Consistent&lt;/em&gt; since the write will be propagated to followers at some
point without fail.&lt;/p&gt;
&lt;p&gt;So, we lost consistency for a while but hey!, everything else is fine now,
right? NO! This may work for a while but ultimately the master is still handling
all the write requests. At some point the master can not handle the amount of
writes it has to do. What do we do?&lt;/p&gt;
&lt;h3 id=&#34;sharding&#34;&gt;Sharding&lt;/h3&gt;
&lt;p&gt;With Sharding we split our data across nodes. Each node is called a &lt;strong&gt;shard&lt;/strong&gt;.
Each shard holds different data. We decide how the data is segregated. For
example, we can segregate our user data based on user&amp;rsquo;s name. All the data of
users with name starting with letters A to F are in shard 1 and user data with
name starting with letters from G to N are in shard 2 and similarly O to Z in
shard 3.&lt;/p&gt;
&lt;p&gt;The rules of sharding the data are very important as the database will choose
which shard to go to for reading and writing data based on the rule. Each of the
shard will have its own set of replicated followers as in read-replicated
databases.&lt;/p&gt;
&lt;p&gt;Now, we can handle as much write as we want by making the shards smaller and
smaller and also by having replicated followers for handling read traffic.&lt;/p&gt;
&lt;p&gt;We had already lost consistency by having replicated followers but now we split
our data across nodes which means we can no longer have the same data model we
had earlier. We can not, for example, read data of two users residing in
separate shards at a time!. Our joins are no longer useful as they can only work
with partial data residing in that particular shard. To overcome this, the SQL
joins have to work with all the shards and then some more to combine them all.&lt;/p&gt;
&lt;p&gt;One way to overcome this problem with joins is to &lt;strong&gt;Denormalize&lt;/strong&gt; the data. By
denormalising data we have improved read performance at the cost of write
performance. At this point we lost many of the features that our databases
provided. We no longer have consistency, joins are slower and we reduced write
performance by denormalizing data.&lt;/p&gt;
&lt;h2 id=&#34;distributed-databases&#34;&gt;Distributed Databases&lt;/h2&gt;
&lt;p&gt;From what we have seen up until now, we create some new problem every time we
have to scale beyond what our current model helps with. We now have a
sharded, replicated system that scales. What are the concerns here?
Consistency, availability and performance.&lt;/p&gt;
&lt;p&gt;We now have more than one server in the network. When a database write occurs,
we now need to decide when to consider it complete: as soon as it is persisted
on the master, or only after it is persisted on a replica (or even two or more
replicas if we want higher availability). If we decide that persisting it on the
master is enough, we risk losing data if the master fails before replicating the
data. If we decide to wait until the data is replicated, we incur latency
penalty.&lt;/p&gt;
&lt;p&gt;Thus, from a world of consistency by default, we have entered a world where
consistency is a choice. In this world, we could choose to have eventual
consistency, where the state is replicated across multiple nodes, but not every
node has a complete view of the entire state.&lt;/p&gt;
&lt;p&gt;There is still a way to make our distributed database strongly consistent. We
decide on number of replicas that need to acknowledge the success of read or
write operation. The number of replicas we decide is also called consistency
level or Quorum. For a system to be considered strongly consistent, it has to
follow the rule  &lt;code&gt;R + W &amp;gt; N&lt;/code&gt;. Here &lt;code&gt;R&lt;/code&gt; and &lt;code&gt;W&lt;/code&gt; are the consistency level of read
and write operations and &lt;code&gt;N&lt;/code&gt; is the total number of replicas.&lt;/p&gt;
&lt;h2 id=&#34;the-cap-theorem&#34;&gt;The CAP theorem&lt;/h2&gt;
&lt;p&gt;The CAP theorem was introduced by Dr. Eric Brewer in 2000. Given a distributed
system, it is impossible to guarantee the three following properties:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Consistency&lt;/strong&gt;: All nodes share the same states, that is, they all have
the same data. In an informal manner, a system is consistent if a write is
successful, all the components of the system can read the new value.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Availability&lt;/strong&gt;: The system remains operative to take care of every
client request, managing it and answering it. Furthermore, it also means that
the system is still awake even if a node fails (or crashes).&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Partition Tolerance&lt;/strong&gt;: The systems keeps attending client requests even
though it has been divided into at least two different parts, also called
partition, that cannot communicate between them.&lt;/li&gt;
&lt;/ul&gt;
&lt;blockquote&gt;
&lt;p&gt;Dr. Brewer issued a clarification stating that his original &amp;ldquo;pick two out
of three&amp;rdquo; concept was greatly simplified in order to open up a discussion and
help move it beyond ACID&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;For example, when two of the nodes cannot communicate with each other (network
reasons, lets say), there is a partition. At that point our system can choose
either to be consistent and unavailable  (fail instead of returning stale data)
or be inconsistent and available (return stale data). It cannot choose to be
both consistent and available.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Partition tolerance is a must for any distributed data store.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;h2 id=&#34;eventual-consistency-and-base-properties&#34;&gt;Eventual Consistency And BASE Properties&lt;/h2&gt;
&lt;p&gt;As it turns out many applications (or part of the application) prefer high
availability more than strong consistency. And network latency is an issue in
keeping nodes in sync for consistency bringing the system performance down.&lt;/p&gt;
&lt;p&gt;These applications settle for a highly available, eventually consistent system.
These systems offer BASE properties (as opposed to ACID)&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;__B__asically __A__vailable  &amp;ndash; High Availability&lt;/li&gt;
&lt;li&gt;__S__oft state &amp;ndash; State of the system might change even when nothing external
happens due to eventual consistency&lt;/li&gt;
&lt;li&gt;__E__ventual Consistency &amp;ndash; Eventually consistent system&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The most famous systems that appeared and took this option are the NoSQL
databases.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Quick Guide to Test-Driven Development (TDD)</title>
      <link>https://www.vijayanant.com/posts/quick-guide-to-test-driven-development-tdd/</link>
      <pubDate>Fri, 11 May 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/quick-guide-to-test-driven-development-tdd/</guid>
      <description>Test-Driven Development (TDD) is a software development approach that emphasises on tests driving the development. It means that tests play a central role in guiding the entire development process. With each new test driving the development of a small piece of functionality, the tests act as both a specification and a guide, providing clear expectations for the code&amp;rsquo;s behaviour and helping developers stay focused on delivering the required features.
The Essence TDD can be summarised by two key principles:</description>
      <content:encoded>&lt;p&gt;Test-Driven Development (TDD) is a software development approach that emphasises on tests driving the development. It means that tests play a central role in guiding the entire development process. With each new test driving the development of a small piece of functionality, the tests act as both a specification and a guide, providing clear expectations for the code&amp;rsquo;s behaviour and helping developers stay focused on delivering the required features.&lt;/p&gt;
&lt;h2 id=&#34;the-essence&#34;&gt;The Essence&lt;/h2&gt;
&lt;p&gt;TDD can be summarised by two key principles:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Red&lt;/strong&gt;: Write a little test that doesn&amp;rsquo;t work, perhaps doesn&amp;rsquo;t even compile at first.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Green&lt;/strong&gt;: Make the test work quickly, committing whatever sins necessary in the process.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Refactor&lt;/strong&gt;: Eliminate all the duplication created in just getting the test to work.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;what-is-needed&#34;&gt;What is Needed&lt;/h2&gt;
&lt;p&gt;Before diving into TDD, it&amp;rsquo;s crucial to have the following prerequisites in place:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The ability to write concrete, deterministic, automated tests.&lt;/li&gt;
&lt;li&gt;A development environment that provides rapid response to small code changes.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;the-rhythm-of-tdd&#34;&gt;The Rhythm of TDD&lt;/h2&gt;
&lt;p&gt;To successfully practice TDD, follow this iterative rhythm:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Add a Test&lt;/strong&gt;: Begin by adding a new test that describes the desired behaviour or functionality.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Run All Tests&lt;/strong&gt;: Execute all existing tests, including the new one, and observe the new test fail as expected.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Make a Change&lt;/strong&gt;: Implement the minimum code necessary to make the failing test pass.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Run All Tests&lt;/strong&gt;: Execute the test suite again, ensuring that all tests, including the newly added one, pass.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Refactor&lt;/strong&gt;: Once all tests are passing, refactor the code to improve its structure, remove duplication, and enhance overall quality. During this stage, keep running the tests to ensure that all changes maintain the system&amp;rsquo;s correctness.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;best-practices-for-tdd&#34;&gt;Best Practices for TDD&lt;/h2&gt;
&lt;p&gt;To make the most of TDD, consider the following best practices:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Write clear and focused tests that cover specific behaviours.&lt;/li&gt;
&lt;li&gt;Aim for high test coverage to ensure comprehensive validation.&lt;/li&gt;
&lt;li&gt;Utilise test doubles (mocks, stubs) to isolate dependencies.&lt;/li&gt;
&lt;li&gt;Use descriptive test names that reflect the intended behaviour being tested.&lt;/li&gt;
&lt;li&gt;Keep tests independent of each other to avoid cascading failures.&lt;/li&gt;
&lt;li&gt;Continuously refactor tests to maintain clarity and readability.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;tdd-tools-and-frameworks&#34;&gt;TDD Tools and Frameworks&lt;/h2&gt;
&lt;p&gt;There are several tools and frameworks that can enhance your TDD workflow, such as:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Testing frameworks (e.g., JUnit, NUnit, pytest) for organising and executing tests.&lt;/li&gt;
&lt;li&gt;Assertion libraries (e.g., assertj, Chai, Hamcrest) for expressive assertions.&lt;/li&gt;
&lt;li&gt;Test runners and continuous integration tools (e.g., Jenkins, Travis CI) for automating test execution and reporting.&lt;/li&gt;
&lt;li&gt;Code coverage tools (e.g., JaCoCo, Istanbul, coverage.py) for tracking test coverage metrics.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;tdd-in-agile-development&#34;&gt;TDD in Agile Development&lt;/h2&gt;
&lt;p&gt;TDD aligns closely with Agile development methodologies. By practicing TDD in an Agile context, teams can benefit from:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Iterative development cycles with continuous feedback.&lt;/li&gt;
&lt;li&gt;Early identification of defects and issues through automated testing.&lt;/li&gt;
&lt;li&gt;Collaborative and customer-focused development practices.&lt;/li&gt;
&lt;li&gt;Improved estimations and project management through predictable code behaviour.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;Test-Driven Development is not just a testing technique; it is a development approach that brings discipline, confidence, and clarity to the software development process. By following the TDD principles, employing best practices, and leveraging appropriate tools, developers can build robust, maintainable, and high-quality software that meets the needs of users and stakeholders.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Basic Lambda Calculus</title>
      <link>https://www.vijayanant.com/posts/basic-lambda-calculus/</link>
      <pubDate>Sun, 25 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/basic-lambda-calculus/</guid>
      <description>Lambda calculus, introduced by Alonzo Church in the 1930s, is a formal system that serves as a foundation for studying computation. Unlike machine models, such as the Turing Machine, lambda calculus operates on the principles of function definition and application as the fundamental operations of computation.
One of the key distinctions between lambda calculus and machine models is the absence of a clear separation between programs and data in lambda calculus.</description>
      <content:encoded>&lt;p&gt;Lambda calculus, introduced by Alonzo Church in the 1930s, is a formal system that serves as a foundation for studying computation. Unlike machine models, such as the Turing Machine, lambda calculus operates on the principles of function definition and application as the fundamental operations of computation.&lt;/p&gt;
&lt;p&gt;One of the key distinctions between lambda calculus and machine models is the absence of a clear separation between programs and data in lambda calculus. Instead, lambda calculus treats computation as a process of symbolic transformation using variables and functions. This unique characteristic makes lambda calculus a &amp;ldquo;higher-order&amp;rdquo; system, allowing for powerful abstraction and manipulation of functions.&lt;/p&gt;
&lt;p&gt;Unlike machine models, which are inherently imperative, lambda calculus is rooted in mathematical concepts and emphasises symbolic transformation rules. It is not concerned with specific machine implementations, but rather focuses on the fundamental principles of computation.&lt;/p&gt;
&lt;p&gt;By delving into lambda calculus, one gains insights into functional programming paradigms, formal reasoning, and the theoretical underpinnings of computation itself. It provides a framework for studying computation from a more abstract and theoretical standpoint, exploring the power of function abstraction and application in solving computational problems.&lt;/p&gt;
&lt;p&gt;Overall, lambda calculus is an influential and foundational concept in computer science that has paved the way for functional programming languages and deepened our understanding of computation beyond traditional machine-based models.&lt;/p&gt;
&lt;h2 id=&#34;notation-rules-and-building-blocks&#34;&gt;Notation, Rules, And Building Blocks&lt;/h2&gt;
&lt;p&gt;Lambda calculus can be considered both a formal system and a notation. It doesn&amp;rsquo;t have a traditional grammar or syntax like programming languages do, but it has a set of rules that define its structure and how expressions are constructed. The basic elements of lambda calculus include variables, lambda abstractions, and function applications.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Variables&lt;/strong&gt;: Variables are used to represent inputs and outputs of functions. They can be any symbol or name chosen by the programmer. For example, &lt;code&gt;x&lt;/code&gt;, &lt;code&gt;y&lt;/code&gt;, &lt;code&gt;z&lt;/code&gt; are common variable names.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Lambda Abstractions&lt;/strong&gt;: Lambda abstractions define functions in lambda calculus. They consist of the &lt;code&gt;λ&lt;/code&gt; symbol (lambda), followed by a variable, a dot (&lt;code&gt;.&lt;/code&gt;), and an expression. The expression represents the body of the function. For example, &lt;code&gt;λx.x&lt;/code&gt; represents a function that takes an input &lt;code&gt;x&lt;/code&gt; and returns &lt;code&gt;x&lt;/code&gt; itself.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Function Applications&lt;/strong&gt;: Function applications are used to apply a function to an argument. It involves writing the function followed by the argument. For example, &lt;code&gt;(λx.x) y&lt;/code&gt; applies the function &lt;code&gt;λx.x&lt;/code&gt; to the argument &lt;code&gt;y&lt;/code&gt;.&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;nesting-and-currying&#34;&gt;Nesting and Currying&lt;/h2&gt;
&lt;p&gt;Lambda calculus expressions can be further combined and nested to create more complex functions. Multiple arguments can be represented using nested lambda abstractions or by currying, a technique where a function with multiple arguments is transformed into a sequence of functions, each taking one argument.&lt;/p&gt;
&lt;p&gt;Suppose we have a function that takes two arguments, &lt;code&gt;add&lt;/code&gt;, and we want to represent it as a sequence of functions, each taking one argument. We can do this using nested lambda abstractions.&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;add = λx.λy.(x + y)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;This represents a function that takes one argument &lt;code&gt;x&lt;/code&gt; and returns another function that takes the second argument &lt;code&gt;y&lt;/code&gt; and performs the addition. We can then apply add to an argument as follows: &lt;code&gt;(add 2) 3&lt;/code&gt;, which yields the result &lt;code&gt;5&lt;/code&gt;. Here, &lt;code&gt;add 2&lt;/code&gt; returns a function that takes &lt;code&gt;3&lt;/code&gt; as an argument and performs the addition.&lt;/p&gt;
&lt;p&gt;Let&amp;rsquo;s consider another function that takes three arguments, &lt;code&gt;multiply&lt;/code&gt;, and we want to transform it into a sequence of functions, each taking one argument.&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;multiply = λx.λy.λz.(x * y * z)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Here, the function multiply takes three arguments &lt;code&gt;x&lt;/code&gt;, &lt;code&gt;y&lt;/code&gt;, and &lt;code&gt;z&lt;/code&gt;, and multiplies them together. By applying currying, we can create a sequence of functions, each taking one argument: &lt;code&gt;mult = (multiply 2)&lt;/code&gt;, which gives us a function that takes one argument &lt;code&gt;x&lt;/code&gt; and returns another function: &lt;code&gt;mult = λx.(λy.(λz.(x * y * z)))&lt;/code&gt;. We can then apply the remaining arguments like &lt;code&gt;(mult 3) 4&lt;/code&gt;, which yields the result &lt;code&gt;24&lt;/code&gt;. Here, &lt;code&gt;mult 3&lt;/code&gt; returns a function that takes &lt;code&gt;4&lt;/code&gt; as an argument and performs the multiplication.&lt;/p&gt;
&lt;p&gt;The syntax of lambda calculus is deliberately minimalistic, focusing on the essentials of function definition and application. It provides a foundation for reasoning about functions and computation in a purely symbolic and mathematical manner.&lt;/p&gt;
&lt;p&gt;It&amp;rsquo;s important to note that while lambda calculus has a simple syntax, its power lies in its ability to express complex computations through function composition, recursion, and other constructs built on top of its core principles.&lt;/p&gt;
&lt;h2 id=&#34;evaluation-rules&#34;&gt;Evaluation Rules&lt;/h2&gt;
&lt;p&gt;In lambda calculus, variables can be categorised as either bound variables or free variables. Understanding the distinction between these two types of variables is crucial in understanding the scoping and substitution rules in lambda calculus.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Bound variables&lt;/strong&gt; are variables that are locally defined within the scope of a lambda abstraction. They are bound by the lambda abstraction and can only be accessed or referenced within that specific scope. Bound variables are typically represented as the arguments of lambda abstractions.&lt;/p&gt;
&lt;p&gt;For example, consider the lambda abstraction: &lt;code&gt;λx.(x y)&lt;/code&gt;. Here, the variable &lt;code&gt;x&lt;/code&gt; is a bound variable because it is bound by the lambda abstraction &lt;code&gt;λx.&lt;/code&gt;. It can only be used within the scope of this abstraction.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Free variables&lt;/strong&gt; are variables that occur within an expression but are not bound by any surrounding lambda abstractions. They are not locally defined and can be referenced from outside the scope in which they appear. Free variables can be thought of as variables that are &lt;em&gt;&amp;ldquo;free&amp;rdquo;&lt;/em&gt; to take on different values or be substituted with other expressions.&lt;/p&gt;
&lt;p&gt;For example, consider the expression: &lt;code&gt;(λx.(x y)) z&lt;/code&gt;. In this expression, the variable &lt;code&gt;y&lt;/code&gt; is a free variable because it is not bound by any surrounding lambda abstraction. It is used within the body of the lambda abstraction &lt;code&gt;λx.(x y)&lt;/code&gt;, but it is not defined or bound by it. The variable &lt;code&gt;z&lt;/code&gt;, on the other hand, is a bound variable as it is the argument of the outermost lambda abstraction &lt;code&gt;(λx.(x y))&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;beta-reduction&#34;&gt;Beta Reduction:&lt;/h3&gt;
&lt;p&gt;The beta reduction rule allows us to apply a lambda abstraction to an argument, resulting in the substitution of the argument in the function body. The general form of beta reduction is:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;(λx.E) M ⟶ E[x := M]
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Here, &lt;code&gt;(λx.E)&lt;/code&gt; represents a lambda abstraction, &lt;code&gt;M&lt;/code&gt; represents an argument, and &lt;code&gt;E[x := M]&lt;/code&gt; represents the expression &lt;code&gt;E&lt;/code&gt; with all occurrences of variable &lt;code&gt;x&lt;/code&gt; replaced by &lt;code&gt;M&lt;/code&gt;. The arrow (&lt;code&gt;⟶&lt;/code&gt;) indicates the reduction or simplification step.&lt;/p&gt;
&lt;p&gt;Example:
Let&amp;rsquo;s consider an example to illustrate beta reduction. Suppose we have the following lambda abstraction:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;(λx.x) 5
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;To evaluate this expression, we apply the argument &lt;code&gt;5&lt;/code&gt; to the function body by substituting &lt;code&gt;x&lt;/code&gt; with &lt;code&gt;5&lt;/code&gt;:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;(λx.x) 5 ⟶ x[x := 5]`
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The resulting expression is simply &lt;code&gt;5&lt;/code&gt; since the variable &lt;code&gt;x&lt;/code&gt; is replaced by &lt;code&gt;5&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;eta-conversion&#34;&gt;Eta Conversion:&lt;/h3&gt;
&lt;p&gt;Another important evaluation rule in lambda calculus is eta conversion. It allows us to convert between equivalent lambda abstractions. The general form of eta conversion is:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;λx.(E x) ⟶ E (if x does not occur free in E)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;This rule states that if we have a lambda abstraction that applies its argument to another expression, and the variable &lt;code&gt;x&lt;/code&gt; does not occur &lt;em&gt;free&lt;/em&gt; in that expression, we can simplify it by removing the application and using the expression directly.&lt;/p&gt;
&lt;p&gt;Example:
Consider the following lambda abstraction:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;λx.((λy.y) x)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Since &lt;code&gt;x&lt;/code&gt; does not occur &lt;em&gt;free&lt;/em&gt; in &lt;code&gt;(λy.y)&lt;/code&gt;, we can simplify it using eta conversion:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;λx.((λy.y) x) ⟶ λx.(λy.y)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The resulting expression is &lt;code&gt;λx.(λy.y)&lt;/code&gt;, where the unnecessary application has been removed.&lt;/p&gt;
&lt;p&gt;These are the basic evaluation rules in lambda calculus. Beta reduction allows us to apply arguments to lambda abstractions, and eta conversion allows us to simplify lambda abstractions when certain conditions are met. These rules govern how lambda expressions are evaluated and simplified in lambda calculus.&lt;/p&gt;
&lt;h2 id=&#34;church-encoding&#34;&gt;Church Encoding&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Church_encoding&#34;&gt;Church encoding&lt;/a&gt; is a technique used in lambda calculus to represent various data types and operations as lambda expressions. It allows us to define and manipulate values within the confines of lambda calculus.&lt;/p&gt;
&lt;h3 id=&#34;church-numerals&#34;&gt;Church Numerals&lt;/h3&gt;
&lt;p&gt;Church numerals are a way of encoding natural numbers in lambda calculus. Each Church numeral represents a specific natural number using nested lambda abstractions. The Church numeral for zero (0) is defined as &lt;code&gt;λf.λx.x&lt;/code&gt;, and the Church numeral for any positive number &lt;code&gt;n&lt;/code&gt; is defined as &lt;code&gt;λf.λx.(f^n x)&lt;/code&gt;, where &lt;code&gt;f^n&lt;/code&gt; represents repeated function application n times.&lt;/p&gt;
&lt;p&gt;For example:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Church numeral for zero (0): &lt;code&gt;λf.λx.x&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Church numeral for one (1): &lt;code&gt;λf.λx.(f x)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Church numeral for two (2): &lt;code&gt;λf.λx.(f (f x))&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;Church numeral for three (3): &lt;code&gt;λf.λx.(f (f (f x)))&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Using Church numerals, we can define arithmetic operations such as addition, multiplication, and predecessor functions purely in terms of lambda expressions.&lt;/p&gt;
&lt;h3 id=&#34;church-booleans&#34;&gt;Church Booleans&lt;/h3&gt;
&lt;p&gt;Church booleans are another example of Church encoding. They represent the concept of &lt;code&gt;true&lt;/code&gt; and &lt;code&gt;false&lt;/code&gt; within lambda calculus. Church boolean &lt;code&gt;true&lt;/code&gt; is defined as &lt;code&gt;λx.λy.x&lt;/code&gt;, and Church boolean &lt;code&gt;false&lt;/code&gt; is defined as &lt;code&gt;λx.λy.y&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Using Church booleans, we can define logical operations like AND, OR, and NOT as lambda expressions.&lt;/p&gt;
&lt;h3 id=&#34;church-pairs&#34;&gt;Church Pairs&lt;/h3&gt;
&lt;p&gt;Church pairs are used to encode ordered pairs within lambda calculus. A Church pair is defined as a lambda expression that takes two arguments and applies them to a function. For example, a Church pair can be defined as &lt;code&gt;λx.λy.λf.(f x y)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;By using Church pairs, we can define operations such as projection to retrieve the elements of a pair and even create more complex data structures.&lt;/p&gt;
&lt;p&gt;Church encoding allows us to represent various data types, operations, and even control flow constructs purely using lambda expressions. It demonstrates the expressive power of lambda calculus and its ability to encode fundamental concepts within a functional programming paradigm.&lt;/p&gt;
&lt;h2 id=&#34;fixed-point-combinators&#34;&gt;Fixed-point combinators&lt;/h2&gt;
&lt;p&gt;Fixed-point combinators are important constructs in lambda calculus that allow the definition of recursive functions. They provide a way to express self-referential computations within the framework of lambda calculus, where direct recursion is not allowed.&lt;/p&gt;
&lt;p&gt;In lambda calculus, direct self-reference or recursion is not possible due to the absence of named functions. Every function is defined in terms of anonymous lambda abstractions, making it challenging to define functions that refer to themselves. Fixed-point combinators offer a workaround for this limitation by providing a mechanism to express recursive computations.&lt;/p&gt;
&lt;h3 id=&#34;y-combinator&#34;&gt;Y Combinator&lt;/h3&gt;
&lt;p&gt;The most well-known fixed-point combinator is the Y combinator. It is named after the mathematician Haskell Curry, and it allows the definition of recursive functions in lambda calculus.&lt;/p&gt;
&lt;p&gt;The Y combinator is defined as follows:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;Y = λf.(λx.f (x x)) (λx.f (x x))
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Here, &lt;code&gt;f&lt;/code&gt; represents the function we want to define recursively. By applying the Y combinator to &lt;code&gt;f&lt;/code&gt;, we can create a self-referential computation.&lt;/p&gt;
&lt;p&gt;To understand how the Y combinator works, let&amp;rsquo;s consider an example where we want to define a factorial function using the Y combinator:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;factorial = Y (λf.λn.if (n == 0) then 1 else n * f (n - 1))
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;Here, the lambda abstraction &lt;code&gt;(λf.λn.if (n == 0) then 1 else n * f (n - 1))&lt;/code&gt; represents the factorial function definition, where &lt;code&gt;f&lt;/code&gt; is the recursive call. By applying the Y combinator to this function definition, we create the recursive computation.&lt;/p&gt;
&lt;p&gt;Apart from the Y combinator, there are other fixed-point combinators that can be used in lambda calculus, such as the Z combinator and the U combinator. Each of these combinators has different properties and can be used to express recursion in different ways.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Outward Counterclockwise Spiral Matrix Traversal - Haskell</title>
      <link>https://www.vijayanant.com/posts/outward-counterclockwise-spiral-matrix-traversal-haskell/</link>
      <pubDate>Mon, 12 Feb 2018 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/outward-counterclockwise-spiral-matrix-traversal-haskell/</guid>
      <description>Problem Write a function that accepts four arguments. The first two arguments are the size of the grid (rows X columns), filled with ascending integers from left to right, top to bottom, starting from 1. The next two arguments are the starting positions, the row r and column c.
Return an array of integers obtained by spiraling outward anti-clockwise from the r and c, starting upward.
More details here
My attempt in Haskell.</description>
      <content:encoded>&lt;h2 id=&#34;problem&#34;&gt;Problem&lt;/h2&gt;
&lt;p&gt;Write a function that accepts four arguments. The first two arguments are the
size of the grid (rows X columns), filled with ascending integers from left to
right, top to bottom, starting from 1. The next two arguments are the starting
positions, the row &lt;code&gt;r&lt;/code&gt; and column &lt;code&gt;c&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Return an array of integers obtained by spiraling outward anti-clockwise from
the &lt;code&gt;r&lt;/code&gt; and &lt;code&gt;c&lt;/code&gt;, starting upward.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;http://us2.campaign-archive1.com/?u=cadc6c448cd083a0aeed7f864&amp;amp;id=a6856ac71e&amp;amp;e=7cfe3ee063&#34;&gt;More details
here&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;My attempt in Haskell.&lt;/p&gt;
&lt;script type=&#34;application/javascript&#34; src=&#34;https://gist.github.com/vijayanant/d1508706dc727b8b27d38495377c28dc.js?file=spiral.hs&#34;&gt;&lt;/script&gt;

</content:encoded>
    </item>
    
    <item>
      <title>Notes on Sets, Relations, and Functions</title>
      <link>https://www.vijayanant.com/posts/notes-on-sets-relations-and-functions/</link>
      <pubDate>Sat, 04 Nov 2017 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/notes-on-sets-relations-and-functions/</guid>
      <description>Standard notation for sets  curly braces for listing the elements of a set explicitly ({. . .}) showing how to construct one set from another by “comprehension” ({x ∈ S | . . .}) ∅ for the empty set, and S \ T for the set difference of S and T (the set of elements of S that are not also elements of T ) The size of a set S is written |S| The powerset of S, i.</description>
      <content:encoded>&lt;h3 id=&#34;standard-notation-for-sets&#34;&gt;Standard notation for sets&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;curly braces for listing the elements of a set explicitly (&lt;code&gt;{. . .}&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;showing how to construct one set from another by “comprehension” (&lt;code&gt;{x ∈ S | . . .}&lt;/code&gt;)&lt;/li&gt;
&lt;li&gt;&lt;code&gt;∅&lt;/code&gt; for the empty set, and &lt;code&gt;S \ T&lt;/code&gt; for the set difference of &lt;code&gt;S&lt;/code&gt; and &lt;code&gt;T&lt;/code&gt; (the set of elements of &lt;code&gt;S&lt;/code&gt; that are not also elements of &lt;code&gt;T&lt;/code&gt; )&lt;/li&gt;
&lt;li&gt;The &lt;em&gt;size&lt;/em&gt; of a set &lt;code&gt;S&lt;/code&gt; is written &lt;code&gt;|S|&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;The &lt;em&gt;powerset&lt;/em&gt; of &lt;code&gt;S&lt;/code&gt;, i.e., the set of all the subsets of S, is written &lt;code&gt;P(S)&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;countable-set&#34;&gt;Countable Set&lt;/h3&gt;
&lt;p&gt;The set &lt;code&gt;{0, 1, 2, 3, 4, 5, . . .}&lt;/code&gt; of natural numbers is denoted by the symbol &lt;code&gt;N&lt;/code&gt;. A set is said to be &lt;em&gt;countable&lt;/em&gt; if its elements can be placed in one-to-one correspondence with the natural numbers.&lt;/p&gt;
&lt;h3 id=&#34;n-place-relation&#34;&gt;n-place relation&lt;/h3&gt;
&lt;p&gt;An n-place relation on a collection of sets S1, S2, . . . , Sn is a set &lt;code&gt;R ⊆ S1 × S2 ×...× Sn&lt;/code&gt; of tuples of elements from &lt;code&gt;S1&lt;/code&gt; through &lt;code&gt;Sn&lt;/code&gt;. We say that the elements &lt;code&gt;s1 ∈ S1&lt;/code&gt; through &lt;code&gt;sn ∈ Sn&lt;/code&gt; are related by &lt;code&gt;R&lt;/code&gt; if &lt;code&gt;(s1,...,sn)&lt;/code&gt; is an element of &lt;code&gt;R&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;one-place-relation&#34;&gt;one-place relation&lt;/h3&gt;
&lt;p&gt;A one-place relation on a set &lt;code&gt;S&lt;/code&gt; is called a predicate on &lt;code&gt;S.&lt;/code&gt; We say that &lt;code&gt;P&lt;/code&gt; is true of an element &lt;code&gt;s ∈ S&lt;/code&gt; if &lt;code&gt;s ∈ P&lt;/code&gt;. To emphasize this intuition, we often write &lt;code&gt;P(s)&lt;/code&gt; instead of &lt;code&gt;s ∈ P&lt;/code&gt;, regarding &lt;code&gt;P&lt;/code&gt; as a function mapping elements of &lt;code&gt;S&lt;/code&gt; to truth values.&lt;/p&gt;
&lt;h3 id=&#34;two-place-relation&#34;&gt;two-place relation&lt;/h3&gt;
&lt;p&gt;A two-place relation &lt;code&gt;R&lt;/code&gt; on sets &lt;code&gt;S&lt;/code&gt; and &lt;code&gt;T&lt;/code&gt; is called a binary relation. We often write &lt;code&gt;s R t&lt;/code&gt; instead of &lt;code&gt;(s,t) ∈ R&lt;/code&gt;. When &lt;code&gt;S&lt;/code&gt; and &lt;code&gt;T&lt;/code&gt; are the same set &lt;code&gt;U&lt;/code&gt;, we say that &lt;code&gt;R&lt;/code&gt; is a binary relation on &lt;code&gt;U&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;mixfix-syntax&#34;&gt;MixFix syntax&lt;/h3&gt;
&lt;p&gt;For readability, three or more place relations are often written using a &amp;ldquo;mixfix&amp;rdquo; concrete syntax, where the elements in the relation are separated by a sequence of symbols that jointly constitute the name of the relation. For example, we write &lt;code&gt;Γ ⊢ s:T&lt;/code&gt; to mean the triple &lt;code&gt;(Γ, s, T)&lt;/code&gt;&lt;/p&gt;
&lt;h3 id=&#34;domain--co-domain&#34;&gt;Domain &amp;amp; Co-domain&lt;/h3&gt;
&lt;p&gt;The domain of a relation &lt;code&gt;R&lt;/code&gt; on sets &lt;code&gt;S&lt;/code&gt; and &lt;code&gt;T&lt;/code&gt;, written &lt;code&gt;dom(R),&lt;/code&gt; is the set of elements &lt;code&gt;s ∈ S&lt;/code&gt; such that &lt;code&gt;(s,t) ∈ R&lt;/code&gt; for some &lt;code&gt;t&lt;/code&gt;. The codomain or range of &lt;code&gt;R&lt;/code&gt;, written &lt;code&gt;range(R)&lt;/code&gt;, is the set of elements &lt;code&gt;t ∈ T&lt;/code&gt; such that &lt;code&gt;(s,t) ∈ R&lt;/code&gt; for some &lt;code&gt;s&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;relation&#34;&gt;Relation&lt;/h3&gt;
&lt;p&gt;A relation &lt;code&gt;R&lt;/code&gt; on sets &lt;code&gt;S&lt;/code&gt; and &lt;code&gt;T&lt;/code&gt; is called a partial function from &lt;code&gt;S&lt;/code&gt; to &lt;code&gt;T&lt;/code&gt; if, whenever &lt;code&gt;(s,t1) ∈ R&lt;/code&gt; and &lt;code&gt;(s,t2) ∈ R&lt;/code&gt;, we have &lt;code&gt;t1 = t2&lt;/code&gt;. If, in addition, &lt;code&gt;dom(R) = S&lt;/code&gt;, then &lt;code&gt;R&lt;/code&gt; is called a total function (or just function) from &lt;code&gt;S&lt;/code&gt; to &lt;code&gt;T&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;partial-function&#34;&gt;Partial Function&lt;/h3&gt;
&lt;p&gt;A partial function &lt;code&gt;R&lt;/code&gt; from &lt;code&gt;S&lt;/code&gt; to &lt;code&gt;T&lt;/code&gt; is said to be defined on an argument &lt;code&gt;s ∈ S&lt;/code&gt; if &lt;code&gt;s ∈ dom(R)&lt;/code&gt;, and undefined otherwise. We write &lt;code&gt;f(x) ↑&lt;/code&gt;, or &lt;code&gt;f (x) =↑&lt;/code&gt;, to mean &amp;ldquo;f is undefined on x,&amp;rdquo; and &lt;code&gt;f (x)↓&lt;/code&gt; to mean &amp;ldquo;f is defined on x.&amp;rdquo;&lt;/p&gt;
&lt;h3 id=&#34;predicate&#34;&gt;Predicate&lt;/h3&gt;
&lt;p&gt;Suppose &lt;code&gt;R&lt;/code&gt; is a binary relation on a set &lt;code&gt;S&lt;/code&gt; and &lt;code&gt;P&lt;/code&gt; is a predicate on &lt;code&gt;S&lt;/code&gt;. We say that &lt;code&gt;P&lt;/code&gt; is preserved by &lt;code&gt;R&lt;/code&gt; if whenever we have &lt;code&gt;s R s&#39;&lt;/code&gt; and &lt;code&gt;P(s)&lt;/code&gt;, we also have &lt;code&gt;P(s&#39;)&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id=&#34;ordered-sets&#34;&gt;Ordered Sets&lt;/h2&gt;
&lt;h3 id=&#34;reflexive-relation&#34;&gt;Reflexive Relation&lt;/h3&gt;
&lt;p&gt;A binary relation R on a set S is reflexive if R relates every element of S to itself—that is, s R s (or (s,s) ∈ R) for all s ∈ S.&lt;/p&gt;
&lt;h3 id=&#34;symmetric-relation&#34;&gt;Symmetric Relation&lt;/h3&gt;
&lt;p&gt;A binary relation R is symmetric if s R t implies t R s, for all s and t in S.&lt;/p&gt;
&lt;h3 id=&#34;transitive-relation&#34;&gt;Transitive Relation&lt;/h3&gt;
&lt;p&gt;A binary relation R is transitive if s R t and t R u together imply s R u. R is antisymmetric if s R t and t R s together imply that s = t.&lt;/p&gt;
&lt;h3 id=&#34;preorder&#34;&gt;Preorder&lt;/h3&gt;
&lt;p&gt;A reflexive and transitive relation R on a set S is called a preorder on S.&lt;/p&gt;
&lt;h3 id=&#34;partial-order&#34;&gt;Partial Order&lt;/h3&gt;
&lt;p&gt;A preorder (on a set S) that is also antisymmetric is called a partial order on S.&lt;/p&gt;
&lt;h3 id=&#34;total-order&#34;&gt;Total Order&lt;/h3&gt;
&lt;p&gt;A partial order ≤ is called a total order if it also has the property that, for each s and t in S, either s ≤ t or t ≤ s.&lt;/p&gt;
&lt;h3 id=&#34;join-and-meet&#34;&gt;Join and Meet&lt;/h3&gt;
&lt;p&gt;Suppose that ≤ is a partial order on a set S and s and t are elements of S. An element j ∈ S is said to be a join (or &lt;strong&gt;least upper bound&lt;/strong&gt;) of s and t if&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;s ≤ j and t ≤ j, and&lt;/li&gt;
&lt;li&gt;for any element k ∈ S with s ≤ k and t ≤ k, we have j ≤ k.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Similarly, an element m ∈ S is said to be a meet (or &lt;strong&gt;greatest lower bound&lt;/strong&gt;) of s and t if&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;m ≤ s and m ≤ t, and&lt;/li&gt;
&lt;li&gt;for any element n ∈ S with n ≤ s and n ≤ t, we have n ≤ m.&lt;/li&gt;
&lt;/ol&gt;
&lt;h3 id=&#34;equivalence&#34;&gt;Equivalence&lt;/h3&gt;
&lt;p&gt;A reflexive, transitive, and symmetric relation on a set S is called an equivalence on S.&lt;/p&gt;
&lt;h3 id=&#34;reflexive-closure&#34;&gt;Reflexive Closure&lt;/h3&gt;
&lt;p&gt;Suppose R is a binary relation on a set S. The reflexive closure of R is the smallest reflexive relation R′ that contains R. (“Smallest” in the sense that if R′′ is some other reflexive relation that contains all the pairs in R, then we have R′ ⊆ R′′.)&lt;/p&gt;
&lt;h3 id=&#34;transitive-closure&#34;&gt;Transitive Closure&lt;/h3&gt;
&lt;p&gt;Similarly, the transitive closure of R is the smallest transitive relation R′ that contains R. The transitive closure of R is often written R+. The reflexive and transitive closure of R is the smallest reflexive and transitive relation that contains R. It is often written R∗.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>TensorFlow Basics</title>
      <link>https://www.vijayanant.com/posts/tensorflow-basics/</link>
      <pubDate>Mon, 02 Oct 2017 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/tensorflow-basics/</guid>
      <description>TensorFlow is Google&amp;rsquo;s open source library for numerical computation. All computations are represented as Data Flow Graphs. The Nodes in the graph represent operations and Edges represent the data-communication between nodes.
Basics Every computation is a graph. That is, we first create a graph that represent our computation. Then we run/evaluate that graph. The evaluation always happen within a Session
import tensorflow as tf x = tf.random_uniform([10]) print(x) What do you think the above code prints?</description>
      <content:encoded>&lt;p&gt;TensorFlow is Google&amp;rsquo;s open source library for numerical computation. All computations are represented as &lt;strong&gt;Data Flow Graphs&lt;/strong&gt;. The Nodes in the graph represent operations and Edges represent the data-communication between nodes.&lt;/p&gt;
&lt;h2 id=&#34;basics&#34;&gt;Basics&lt;/h2&gt;
&lt;p&gt;Every computation is a graph. That is, we first create a graph that represent our computation. Then we run/evaluate that graph. The evaluation always happen within a &lt;strong&gt;Session&lt;/strong&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; tensorflow &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; tf
x &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;random_uniform([&lt;span style=&#34;color:#ae81ff&#34;&gt;10&lt;/span&gt;])
print(x)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;What do you think the above code prints?&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Tensor(&amp;quot;random_uniform:0&amp;quot;, shape=(10,), dtype=float32)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;x&lt;/code&gt; is a Tensor. Remember that everytihing in tensorflow is graph made of nodes and edges. The call to &lt;code&gt;tf.random_uniform()&lt;/code&gt; returns a &lt;code&gt;Tensor&lt;/code&gt;.&lt;/p&gt;
&lt;h3 id=&#34;tensor&#34;&gt;Tensor&lt;/h3&gt;
&lt;p&gt;A tensor is what is passed between nodes (edge). It represents the (input and) output of an Operation (node). A tensor does not hold the values of the operation&amp;rsquo;s output, but instead provides a means of computing those values in a Session.&lt;/p&gt;
&lt;p&gt;In the above example, &lt;code&gt;tf.random_uniform()&lt;/code&gt; is an Operation and it returns a Tensor.&lt;/p&gt;
&lt;p&gt;Take another look at the output of previous example -&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Tensor(&amp;quot;random_uniform:0&amp;quot;, shape=(10,), dtype=float32)&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;it tells us that x is a Tensor, the opration name is random_uniform (:0 says its the output), the shape of the tensor (a list of 10 elements) and data type of the elements in the list(float32).&lt;/p&gt;
&lt;p&gt;You can get information about the tensor using many of the functions and attribute values available.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;shape &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; x&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;get_shape()&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;as_list()
ty &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; x&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;dtype
name &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; x&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;name
op_name &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; x&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;op&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;name
print([name, op_name, ty, shape])
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;&lt;code&gt;[&#39;random_uniform:0&#39;, &#39;random_uniform&#39;, tf.float32, [10]]&lt;/code&gt;&lt;/p&gt;
&lt;p&gt;So, how do we get the actual result?&lt;/p&gt;
&lt;h3 id=&#34;sessions-and-graphs&#34;&gt;Sessions and Graphs&lt;/h3&gt;
&lt;p&gt;Remember we mentioned earlier that every computation is represented as a graph? By default, every operation is added to a default graph. And a Session is where the operations in the graph are run.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;g &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;get_default_graph()
session &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Session(graph&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;g)

result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; session&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;run(x)

print(result)
session&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;close()
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The result -&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;[0.23983908 0.30026257 0.21374762 0.18318117 0.8556453  0.25169706
 0.8703637  0.69733584 0.9137391  0.20477629]
&lt;/code&gt;&lt;/pre&gt;&lt;h3 id=&#34;operations&#34;&gt;Operations&lt;/h3&gt;
&lt;p&gt;Operations are the nodes in the graph that consume and/or produce Tensors.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;[op&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;name &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; op &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; g&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;get_operations()]
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;[&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform/shape&amp;#39;&lt;/span&gt;,
 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform/min&amp;#39;&lt;/span&gt;,
 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform/max&amp;#39;&lt;/span&gt;,
 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform/RandomUniform&amp;#39;&lt;/span&gt;,
 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform/sub&amp;#39;&lt;/span&gt;,
 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform/mul&amp;#39;&lt;/span&gt;,
 &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;random_uniform&amp;#39;&lt;/span&gt;]
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;variables&#34;&gt;Variables&lt;/h3&gt;
&lt;p&gt;Variables are stateful nodes which output their current value. State is retained across multiple executions of a graph. A variable holds a  value, which can be a Tensor of any type and shape. The type and shape of the variable are fixed at initialization time. The value can be changed using one of the assign methods.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; tensorflow &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; tf

mat &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; [ [&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;2&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;3&lt;/span&gt;], [&lt;span style=&#34;color:#ae81ff&#34;&gt;4&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;5&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;6&lt;/span&gt;], [&lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;8&lt;/span&gt;,&lt;span style=&#34;color:#ae81ff&#34;&gt;9&lt;/span&gt;] ]
trans &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;transpose(mat)

x &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Variable(mat)
y &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;matmul(mat, trans)

x&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;assign(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;add(y,&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;))
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h3 id=&#34;placeholders&#34;&gt;Placeholders&lt;/h3&gt;
&lt;p&gt;Placeholders are nodes whose value is fed in at execution time.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; tensorflow &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; tf

x &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;placeholder(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;float32, shape&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;(&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;))
y &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;matmul(x, x)

&lt;span style=&#34;color:#66d9ef&#34;&gt;with&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Session() &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; sess:
  rand_array &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; np&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;random&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;rand(&lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;1024&lt;/span&gt;)
  print(sess&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;run(y, feed_dict&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;{x: rand_array}))  &lt;span style=&#34;color:#75715e&#34;&gt;# Will succeed.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;putting-it-all-together&#34;&gt;Putting It All Together&lt;/h2&gt;
&lt;p&gt;We have so far learned what tensorFlow is about and got basic intuition towards Tensors, Graphs, Operations and Sessions. We have also learned about how to use Variables and Placeholders. Now, we will put all that togetther.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;First, build a graph using variables and placeholders.&lt;/li&gt;
&lt;li&gt;Then, deploy the graph onto a session, which is the execution environment&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-python&#34; data-lang=&#34;python&#34;&gt;&lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; numpy &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; np 
&lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; tensorflow &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; tf

b &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Variable(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;zeros((&lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;,)))
W &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Variable(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;random_uniform((&lt;span style=&#34;color:#ae81ff&#34;&gt;784&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;),&lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;))

x &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;placeholder(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;float32, (&lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;784&lt;/span&gt;))

&lt;span style=&#34;color:#75715e&#34;&gt;# h = ReLu(Wx + b)&lt;/span&gt;
h &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;nn&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;relu(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;matmul(x, W) &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; b)

sess &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Session()
sess&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;run(tf&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;initialize_all_variables())
sess&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;run(h, {x: np&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;random&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;random_sample((&lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;784&lt;/span&gt;))})
 
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;If you are not already familiar with NN and activation functions, don&amp;rsquo;t worry about the ReLU (&lt;code&gt;tf.nn.relu()&lt;/code&gt;). Just know that TensorFlow provides a very rich set of tools to work with machine learning.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Thinking in Imperative, Object Oriented and Functional way</title>
      <link>https://www.vijayanant.com/posts/thinking-in-imperative-object-oriented-and-functional-way/</link>
      <pubDate>Fri, 15 Sep 2017 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/thinking-in-imperative-object-oriented-and-functional-way/</guid>
      <description>Complexity is the root cause of majority of software problems. Unreliable softwares are known to be notoriously complex. A complex system is hard to understand and reason about. The harder a system is to understand the more likely we are to introduce more complexity. Complex code base is not only harder to test but testing is that much less effective.
Programming Paradigms Different programming styles tries to deal with the complexity in their own way.</description>
      <content:encoded>&lt;p&gt;Complexity is the root cause of majority of software problems. Unreliable
softwares are known to be notoriously complex. A complex system is hard to
understand and reason about. The harder a system is to understand the more
likely we are to introduce more complexity.  Complex code base is not only
harder to test but testing is that much less effective.&lt;/p&gt;
&lt;h2 id=&#34;programming-paradigms&#34;&gt;Programming Paradigms&lt;/h2&gt;
&lt;p&gt;Different programming styles tries to deal with the complexity in their own way.
The following sections discusses some common paradigms in general purpose
programming.&lt;/p&gt;
&lt;p&gt;The examples given are representative of the paradigm and are simple. They are
not representitives of solutions to handling complexity. Complexities that arise
due to  state update and control flow are usually visible in fairly large code
base.&lt;/p&gt;
&lt;h2 id=&#34;the-imperative-style&#34;&gt;The Imperative Style&lt;/h2&gt;
&lt;p&gt;In &lt;a href=&#34;https://en.wikipedia.org/wiki/Imperative_programming&#34;&gt;imperative
programming&lt;/a&gt;, the programs
consists of an explicit sequence of instructions/commands that update shared
state. Control flow is explicit: commands detail how the computation takes
place, step by step. Each step affects the global state of the system.&lt;/p&gt;
&lt;p&gt;Since each step can essentially updates the (global, shared) state, any part of
the program can update the state. It is up to the programmer to keep track of
how and where the state is being updated and tailor the control flow such that
the only desired updates happen and in a perticular order. As the number
possible program state increases so does the number of places the state is
updated. It becomes harder to keep the program in consistent state. It will soon
become a complex cogwheel system with too many moving parts.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-C&#34; data-lang=&#34;C&#34;&gt;result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; []
i &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;
start:
  numEmployees &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; length(employees)
  &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; i &lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;=&lt;/span&gt; numEmployees &lt;span style=&#34;color:#66d9ef&#34;&gt;goto&lt;/span&gt; finished
  e &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; employees[i]
  rating &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; e.rating
  &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; rating &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;goto&lt;/span&gt; nextOne
  upperCaseName &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; toUpper(e.name)
  addToList(result, upperCaseName)
nextOne:
  i &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; i &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;
  &lt;span style=&#34;color:#66d9ef&#34;&gt;goto&lt;/span&gt; start
finished:
  &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; sort(result)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Use of procedures and structured programming (sometimes considered a separate
paradigm) is a way to contain complexity.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-C&#34; data-lang=&#34;C&#34;&gt;result &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; [];
&lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; (i &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;; i &lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt; length(employees); i&lt;span style=&#34;color:#f92672&#34;&gt;++&lt;/span&gt;) {
  e &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; employees[i];
  &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt;(e.rating &lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;) {
    addToList(result,toUpper(e.name));
  }
}
&lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; sort(result);
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;the-object-oriented-style&#34;&gt;The Object Oriented Style&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Object-oriented_programming&#34;&gt;Object Oriented
Programming&lt;/a&gt; is based
on passing messages between objects. Objects respond to messages by performing
appropriate operations. These operations are generally called methods.&lt;/p&gt;
&lt;p&gt;By encapsulating data and operations that can be performed on that data, into a
single entity (object), we have (in  a way) segregated moving parts of the
system in to smaller groups. There are still moving parts, a lot of them, but
they are grouped in a way which allows programmer to handle each group (class of
objects)  in isolation.&lt;/p&gt;
&lt;p&gt;In pure OO style, the control structures like the conditionals and loops become
messages themselves.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Smalltalk&#34; data-lang=&#34;Smalltalk&#34;&gt;result &lt;span style=&#34;color:#f92672&#34;&gt;:=&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;List&lt;/span&gt; new.
employees &lt;span style=&#34;color:#a6e22e&#34;&gt;each:&lt;/span&gt; [&lt;span style=&#34;color:#f92672&#34;&gt;:&lt;/span&gt;e &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt;
  e &lt;span style=&#34;color:#a6e22e&#34;&gt;rating&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;greaterThan:&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt; ifTrue: [result &lt;span style=&#34;color:#a6e22e&#34;&gt;add&lt;/span&gt; (e &lt;span style=&#34;color:#a6e22e&#34;&gt;name&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;upper&lt;/span&gt;)]]
&lt;span style=&#34;color:#a6e22e&#34;&gt;result&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;sort&lt;/span&gt;.
&lt;span style=&#34;color:#f92672&#34;&gt;^&lt;/span&gt;result
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Notice that, even though we can now deal with state updates in isolation,
objects need to collaborate among themselves to be useful. That happens by the
way of message passing. As the number of objects (classes of objects) increases
the communication between them also increases and needs to be dealt with
carefully.&lt;/p&gt;
&lt;h2 id=&#34;the-functional-style&#34;&gt;The Functional Style&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://en.wikipedia.org/wiki/Functional_programming&#34;&gt;Functional Programming&lt;/a&gt;
is based on the mathematical concept of a function. In mathematics there is no
notion of updating a variable/state. Functional programming, thus, removes the
whole &amp;lsquo;update the shared state&amp;rsquo; business. Functions are the building blocks in
FP. Functions take arguments and compute a result based on the inputs provided.
Control flow is expressed by combining functions (&lt;a href=&#34;https://en.wikipedia.org/wiki/Function_composition&#34;&gt;function
composition&lt;/a&gt;).&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;sort&lt;/span&gt; ( map (toUpperCase &lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt; name) ( filter (&lt;span style=&#34;color:#a6e22e&#34;&gt;\&lt;/span&gt;e &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; rating e &lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;) employees))
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;p&gt;In essence, programming paradigms stem from different concepts about how the
world works. They represent different opinions about how to best model the world
while we are writing programs.&lt;/p&gt;
&lt;p&gt;The imperative models are based on how computers works. We think in terms of
variables that hold values and procedures that manipulate the values held in
those variable.&lt;/p&gt;
&lt;p&gt;The object-oriented paradigm models everything as an object. These objects can
then interact with each other and thereby update their internal state when
something in the system changes. This corresponds to how we often conceptualize
the world.&lt;/p&gt;
&lt;p&gt;The functional programming paradigm takes a different approach. The behavior of
the system is modelled using pure functions and these are strictly separated
from the actual data within the system, which is modelled with immutable values.
This is based on the mathematical perspective that a value itself cannot change
and all changes in the system are actually the application of a function.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>OO(h!) Principles</title>
      <link>https://www.vijayanant.com/posts/ooh-principles/</link>
      <pubDate>Sun, 23 Oct 2016 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/ooh-principles/</guid>
      <description>There is a good chance that you all are aware of the SOLID principles. There are many more principles for us to consider and adhere to while developing OO software.
SOLID These are the Principles of Object Oriented Class Design popularly known as the SOLID Principles.
 The Single Responsibility Principle [SRP] The Open/Closed Principle [OCP] The Liskov Substitution Principle [LSP] The Interface Segregation Principle [ISP] The Dependency Inversion Principle [DIP]  The next two set of principles, are related to packaging.</description>
      <content:encoded>&lt;p&gt;There is a good chance that you all are aware of the SOLID principles. There are many more principles for us to consider and adhere to while developing OO software.&lt;/p&gt;
&lt;h2 id=&#34;solid&#34;&gt;SOLID&lt;/h2&gt;
&lt;p&gt;These are the &lt;strong&gt;Principles of Object Oriented Class Design&lt;/strong&gt; popularly known as the &lt;strong&gt;SOLID Principles&lt;/strong&gt;.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The &lt;strong&gt;S&lt;/strong&gt;ingle Responsibility Principle [SRP]&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;O&lt;/strong&gt;pen/Closed Principle [OCP]&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;L&lt;/strong&gt;iskov Substitution Principle [LSP]&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;I&lt;/strong&gt;nterface Segregation Principle [ISP]&lt;/li&gt;
&lt;li&gt;The &lt;strong&gt;D&lt;/strong&gt;ependency Inversion Principle [DIP]&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;The next two set of principles, are related to &lt;em&gt;packaging&lt;/em&gt;. Package here refers to a &lt;em&gt;deployable component&lt;/em&gt;, or simply something you would &amp;lsquo;&lt;em&gt;release&lt;/em&gt;&amp;rsquo; for others to use - like a jar file. These are the &lt;strong&gt;Principles of Package Architecture&lt;/strong&gt;.&lt;/p&gt;
&lt;h2 id=&#34;package-cohesion-principles&#34;&gt;Package Cohesion Principles&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The Release Reuse Equivalency Principle [REP]&lt;/li&gt;
&lt;li&gt;The Common Closure Principle [CCP]&lt;/li&gt;
&lt;li&gt;The Common Reuse Principle [CRP]&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;package-coupling-principles&#34;&gt;Package Coupling Principles&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The Acyclic Dependencies Principle [ADP]&lt;/li&gt;
&lt;li&gt;The Stable Dependencies Principle [SDP]&lt;/li&gt;
&lt;li&gt;The Stable Abstractions Principle [SAP]&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;bertrand-meyers-principles&#34;&gt;Bertrand Meyer&amp;rsquo;s Principles&lt;/h2&gt;
&lt;p&gt;Note that some of the principles listed above are also originally described by
Mayer.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;The Linguistic Modular Units principle&lt;/li&gt;
&lt;li&gt;The Self-Documentation principle&lt;/li&gt;
&lt;li&gt;The Uniform Access principle&lt;/li&gt;
&lt;li&gt;The Open-Closed principle&lt;/li&gt;
&lt;li&gt;The Single Choice principle&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;grasp&#34;&gt;GRASP&lt;/h2&gt;
&lt;p&gt;__G__eneral __R__esponsibility __A__ssignment __S__oftware __P__rinciples&lt;/p&gt;
&lt;p&gt;Guidelines for assigning responsibility to classes and objects in object-oriented design. Helps us in deciding which responsibility should be assigned to which object/class. Identify the objects and responsibilities from the problem domain, and also identify how objects interact with each other.&lt;/p&gt;
&lt;p&gt;GRASP are more than base principles. These techniques have not been invented to create new ways of working, but to better document and standardize old, tried-and-tested programming principles in object-oriented design.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Creator&lt;/li&gt;
&lt;li&gt;Information Expert&lt;/li&gt;
&lt;li&gt;Low Coupling&lt;/li&gt;
&lt;li&gt;High Cohesion&lt;/li&gt;
&lt;li&gt;Controller&lt;/li&gt;
&lt;li&gt;Indirection&lt;/li&gt;
&lt;li&gt;Polymorphism&lt;/li&gt;
&lt;li&gt;Protected Variations&lt;/li&gt;
&lt;li&gt;Pure Fabrication&lt;/li&gt;
&lt;/ul&gt;
</content:encoded>
    </item>
    
    <item>
      <title>GADTs To Eliminate Runtime Checks</title>
      <link>https://www.vijayanant.com/posts/gadts-to-eliminate-runtime-checks/</link>
      <pubDate>Sat, 15 Oct 2016 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/gadts-to-eliminate-runtime-checks/</guid>
      <description>Generalized Algebraic Data Types (GADTs) generalizes ordinary Algebraic Data Types(ADTs) by permitting value constructors to return specific types. GADTs are used for ensuring program correctness and in generic programming. This article is specific to Haskell programming language. In Haskell GADTs are implemented as a language extension. The article describes these use cases with small programs.
Introduction Type system help programmers ensure that the software they write behave correctly. They detect errors and also serve as documentation.</description>
      <content:encoded>&lt;p&gt;&lt;em&gt;Generalized Algebraic Data Types (GADTs)&lt;/em&gt; generalizes ordinary &lt;em&gt;Algebraic Data
Types(ADTs)&lt;/em&gt; by permitting value constructors to return specific types. GADTs are used
for ensuring program correctness and in generic programming. This article is
specific to Haskell programming language. In Haskell GADTs are implemented as
a language extension. The article describes these use cases with small programs.&lt;/p&gt;
&lt;h1 id=&#34;introduction&#34;&gt;Introduction&lt;/h1&gt;
&lt;p&gt;Type system help programmers ensure that the software they write behave
correctly. They detect errors and also serve as documentation. A good type
system allow abstracting domain specific concepts. Haskell’s much appreciated
ADTs though powerful, is still lacking in few aspects. GADTs fill that gap.&lt;/p&gt;
&lt;p&gt;This article explains GADTs with simple examples.&lt;/p&gt;
&lt;h2 id=&#34;algebraic-data-types-adts&#34;&gt;Algebraic Data Types (ADTs)&lt;/h2&gt;
&lt;p&gt;ADTs are composite types, i.e., types formed by combining other types. Depending
on how the types are combined, we can have either a &lt;em&gt;sum&lt;/em&gt; type or a &lt;em&gt;product&lt;/em&gt; type.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Point&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Pt&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Integer&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Boolean&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Bool&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;In the example above &lt;code&gt;Point&lt;/code&gt; and &lt;code&gt;Expr&lt;/code&gt; are called &lt;em&gt;type constructors&lt;/em&gt; and &lt;code&gt;Pt&lt;/code&gt;,
&lt;code&gt;Number&lt;/code&gt;, and &lt;code&gt;Boolean&lt;/code&gt; are called &lt;em&gt;value constructors&lt;/em&gt;. If a type has more than
one value constructor, they are called alternatives: one can use any of these
alternatives to create a value of that type.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;10&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;let&lt;/span&gt; b &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Boolean&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t a
&lt;span style=&#34;color:#a6e22e&#34;&gt;a&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t b
&lt;span style=&#34;color:#a6e22e&#34;&gt;b&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Notice that the type of both &lt;code&gt;a&lt;/code&gt; and &lt;code&gt;b&lt;/code&gt; is &lt;code&gt;Expr.&lt;/code&gt; This is because of the type of the
value constructors.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t &lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt;
&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Integer&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t &lt;span style=&#34;color:#66d9ef&#34;&gt;Boolean&lt;/span&gt;
&lt;span style=&#34;color:#66d9ef&#34;&gt;Boolean&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Bool&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;To showcase how this complicates code, let us extend our type a bit and also add
a expression evaluator.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
          &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;
          &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;
          &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;If&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt;

&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Value&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;IntVal&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;|&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;BoolVal&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Bool&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Value&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; i) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;IntVal&lt;/span&gt; i
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; e) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; eval e &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
        &lt;span style=&#34;color:#66d9ef&#34;&gt;IntVal&lt;/span&gt; i &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;IntVal&lt;/span&gt; (i&lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; e) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; eval e &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
        &lt;span style=&#34;color:#66d9ef&#34;&gt;IntVal&lt;/span&gt; i &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;BoolVal&lt;/span&gt; (i&lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;)
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;If&lt;/span&gt; b e1 e2) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;case&lt;/span&gt; eval b &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt;
        &lt;span style=&#34;color:#66d9ef&#34;&gt;BoolVal&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt;  &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; eval e1
        &lt;span style=&#34;color:#66d9ef&#34;&gt;BoolVal&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;False&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; eval e2
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;If you notice carefully, this allows for some invalid expressions to type check
successfully.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;expr1&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)          &lt;span style=&#34;color:#75715e&#34;&gt;-- valid and type checks&lt;/span&gt;
&lt;span style=&#34;color:#a6e22e&#34;&gt;expr2&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)) &lt;span style=&#34;color:#75715e&#34;&gt;-- invalid but type checks&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Also, notice how our &lt;code&gt;eval&lt;/code&gt; function is &lt;em&gt;partially&lt;/em&gt; implemented. We do not know
what to evaluate a expression &lt;code&gt;Succ (IsZero (Number 1))&lt;/code&gt; to. We could allow the
function to indicate error by using a &lt;code&gt;Maybe&lt;/code&gt; or &lt;code&gt;Either&lt;/code&gt; type, but that
complicates the &lt;code&gt;eval&lt;/code&gt; function further as we recursively call &lt;code&gt;eval&lt;/code&gt;. Try it
out for fun.&lt;/p&gt;
&lt;h2 id=&#34;generalised-adts&#34;&gt;Generalised ADTs&lt;/h2&gt;
&lt;p&gt;The idea behind GADTs is to allow arbitrary return types for value constructors.
They &lt;em&gt;generalize&lt;/em&gt; ordinary data types. GADTs are provided in GHC as a language
extension. We can enable this feature using the &lt;code&gt;LANGUAGE&lt;/code&gt; pragma. It provides a
new syntax for defining data types. We specify type for each value constructor.
We can now redefine our &lt;code&gt;Expr&lt;/code&gt; type like below:&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#75715e&#34;&gt;{-# LANGUAGE GADTs #-}&lt;/span&gt;

&lt;span style=&#34;color:#66d9ef&#34;&gt;data&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; a &lt;span style=&#34;color:#66d9ef&#34;&gt;where&lt;/span&gt;
  &lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
  &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt;   &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
  &lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Bool&lt;/span&gt;
  &lt;span style=&#34;color:#66d9ef&#34;&gt;If&lt;/span&gt;     &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;ExprBool&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Expra&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Expra&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;Expra&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Notice that return type for value constructor can differ. This allows our
program to be more strict. The value constructor &lt;code&gt;Succ&lt;/code&gt;, for example, expects a
&lt;code&gt;Expr Int.&lt;/code&gt; The compiler can now reject code if you provide &lt;code&gt;Expr Bool&lt;/code&gt; or anything
else.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;10&lt;/span&gt;)
&lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;10&lt;/span&gt;) &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;

&lt;span style=&#34;color:#a6e22e&#34;&gt;ghci&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;t &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;))
&lt;span style=&#34;color:#f92672&#34;&gt;&amp;lt;&lt;/span&gt;interactive&lt;span style=&#34;color:#f92672&#34;&gt;&amp;gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;7&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;error&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt;
     &lt;span style=&#34;color:#66d9ef&#34;&gt;Couldn&lt;/span&gt;&lt;span style=&#34;color:#960050;background-color:#1e0010&#34;&gt;’&lt;/span&gt;t match &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Bool&lt;/span&gt; with &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
      &lt;span style=&#34;color:#66d9ef&#34;&gt;Expected&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Int&lt;/span&gt;
        &lt;span style=&#34;color:#66d9ef&#34;&gt;Actual&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;type&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Bool&lt;/span&gt;
     &lt;span style=&#34;color:#66d9ef&#34;&gt;In&lt;/span&gt; the first argument &lt;span style=&#34;color:#66d9ef&#34;&gt;of&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt;, namely (&lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;))
      &lt;span style=&#34;color:#66d9ef&#34;&gt;In&lt;/span&gt; the expression&lt;span style=&#34;color:#66d9ef&#34;&gt;:&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt;))
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Now, with the refined &lt;code&gt;Expr&lt;/code&gt; type, the evaluation of expression become simple. The
expression evaluator need not worry about cases where the type do not match
(ill-typed expression we saw earlier). The new evaluator is easy to write and
read.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Haskell&#34; data-lang=&#34;Haskell&#34;&gt;&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;::&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;Expr&lt;/span&gt; a &lt;span style=&#34;color:#f92672&#34;&gt;-&amp;gt;&lt;/span&gt; a
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Number&lt;/span&gt; i) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; i
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;Succ&lt;/span&gt; e) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; eval e
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;IsZero&lt;/span&gt; e) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;0&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;==&lt;/span&gt; eval e
&lt;span style=&#34;color:#a6e22e&#34;&gt;eval&lt;/span&gt; (&lt;span style=&#34;color:#66d9ef&#34;&gt;If&lt;/span&gt; b e1 e2) &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; eval b &lt;span style=&#34;color:#66d9ef&#34;&gt;then&lt;/span&gt; eval e1 &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt; eval e2
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;This version of &lt;code&gt;eval&lt;/code&gt; is complete unlike the previously implemented one. If we
are evaluating an expression, the expression is guaranteed to be valid and no
failure cases are possible. Compile time guarantee is always better than a
runtime check.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>A Detour Called Monads</title>
      <link>https://www.vijayanant.com/posts/a-detour-called-monads/</link>
      <pubDate>Mon, 15 Aug 2016 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/a-detour-called-monads/</guid>
      <description>When learning Haskell, all of us are faced with this monad monster. I too have spent many days and night fighting it - hoping that it will grant me all the wisdom if I survive long enough. I have come to believe that the community as whole has created this monstor. And many of us have taken this detour to master the art of monstor slaying instead of going on ahead - just to realise later that the detour was unnesessory.</description>
      <content:encoded>&lt;p&gt;When learning Haskell, all of us are faced with this monad monster. I too have
spent many days and night fighting it -  hoping that it will grant me all the
wisdom if I survive long enough. I have come to believe that the community as
whole has created this monstor. And many of us have taken this detour to master
the art of monstor slaying instead of going on ahead - just to realise later
that the detour was unnesessory. Pocket knife is all that was needed.&lt;/p&gt;
&lt;p&gt;Stop Scaring the newcomers. We don&amp;rsquo;t call it List Monad everytime we use it. We
are OK to call it just List. But everytime we need state why do we call it State
Monad? When I need to do i/o I will use IO. The fact that it is a monad is not
relevant at that point.&lt;/p&gt;
&lt;p&gt;Monads don&amp;rsquo;t do IO, monads don&amp;rsquo;t manage State, Monads don&amp;rsquo;t handle Exception.
Monads don&amp;rsquo;t do anything. The types IO, State etc. do. Understand the types.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Decisions</title>
      <link>https://www.vijayanant.com/posts/decisions/</link>
      <pubDate>Mon, 15 Aug 2016 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/decisions/</guid>
      <description>We all make decisions. We should make decisions to be happy.
To go to college, to drop out, to get a job, to freelance, to take over family business, to start your own, to take a break from your job, to get married, to visit friends, to avoid talking to some, to go shopping, to buy online, to go jogging, to sleep more, to make peace, to go to war. All decisions are made to be happy.</description>
      <content:encoded>&lt;p&gt;We all make decisions. We should make decisions to be happy.&lt;/p&gt;
&lt;p&gt;To go to college, to drop out, to get a job, to freelance, to take over family
business, to start your own, to take a break from your job, to get married, to
visit friends, to avoid talking to some, to go shopping, to buy online, to go
jogging, to sleep more, to make peace, to go to war. All decisions are made to
be happy.&lt;/p&gt;
&lt;p&gt;Some times you end up less happy. Don&amp;rsquo;t fret! All you need is to make another
decision. A better one using all the knowledge you gained in previous decisions.&lt;/p&gt;
&lt;p&gt;It is not that hard.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Duplication Vs Abstraction</title>
      <link>https://www.vijayanant.com/posts/duplication-vs-abstraction/</link>
      <pubDate>Tue, 05 Jul 2016 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/duplication-vs-abstraction/</guid>
      <description>When you see code duplication and can&amp;rsquo;t think of an abstraction to put that piece of code in, it is wise to keep the code separate. At least until you figure out the right abstraction.</description>
      <content:encoded>&lt;p&gt;When you see code duplication and can&amp;rsquo;t think of an abstraction to put that
piece of code in, it is wise to keep the code separate. At least until you
figure out the right abstraction.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Pair Programming - What? Why? And How?</title>
      <link>https://www.vijayanant.com/posts/pair-programming-what-why-and-how/</link>
      <pubDate>Sat, 31 Jan 2015 12:31:30 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/pair-programming-what-why-and-how/</guid>
      <description>What? Simply put, pair programming is two programmers with a single computer working together to solve a problem!
Why?  To produce better code To learn more from your peers To learn and practice objectively evaluating possible solutions To collaborate with better programmers  How?  The Driver is responsible to coding (owns the keyboard) The Navigator is responsible for reviewing the driver’s work 30 min Rule: Role changes every 20-30min (at a logical break point) Take control of the worl.</description>
      <content:encoded>&lt;h3 id=&#34;what&#34;&gt;What?&lt;/h3&gt;
&lt;p&gt;Simply put, pair programming is two programmers with a single computer working
together to solve a problem!&lt;/p&gt;
&lt;h3 id=&#34;why&#34;&gt;Why?&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;To produce better code&lt;/li&gt;
&lt;li&gt;To learn more from your peers&lt;/li&gt;
&lt;li&gt;To learn and practice objectively evaluating possible solutions&lt;/li&gt;
&lt;li&gt;To collaborate with better programmers&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;how&#34;&gt;How?&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;The Driver&lt;/strong&gt; is responsible to coding (owns the keyboard)&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The Navigator&lt;/strong&gt; is responsible for reviewing the driver’s work&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;30 min Rule&lt;/strong&gt;: Role changes every 20-30min (at a logical break point)&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Take control of the worl.. err.. keyboar&lt;/strong&gt; - you drive when you know what to do&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;common-sense&#34;&gt;Common Sense&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Respect your peer’s time&lt;/li&gt;
&lt;li&gt;Collective ownership - Be a team player&lt;/li&gt;
&lt;li&gt;Communication - Talk to you peer (Speak your mind)&lt;/li&gt;
&lt;li&gt;Let-go/grab the keyboard when required&lt;/li&gt;
&lt;li&gt;Let go of your ego, be humble&lt;/li&gt;
&lt;li&gt;Enjoy coding&lt;/li&gt;
&lt;/ul&gt;
</content:encoded>
    </item>
    
    <item>
      <title>10 Vim Plugins That Made My Vim Easy </title>
      <link>https://www.vijayanant.com/posts/10-vim-plugins-that-made-my-vim-easy/</link>
      <pubDate>Sun, 04 Jan 2015 09:18:06 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/10-vim-plugins-that-made-my-vim-easy/</guid>
      <description>Few days back I posted the below pic online and some of my friends wanted to know how I got there. I am no vim expert and there are myriad of other (possibly better) ways of doing things. So I will just list the plugins I have used in my setup.
Note that the side panes (NERDTree on the left and Tagbar on the right) auto-collapse. They magically appear when you summon them and hide themselves when the task is done.</description>
      <content:encoded>&lt;p&gt;Few days back I posted the below pic online and some of my friends wanted to know how I got there. I am no vim expert and there are myriad of other (possibly better) ways of doing things. So I will just list the plugins I have used in my setup.&lt;/p&gt;
&lt;p&gt;&lt;img src=&#34;https://www.vijayanant.com/my_vim_setup.png&#34; alt=&#34;my_vim_setup&#34;&gt;&lt;/p&gt;
&lt;p&gt;Note that the side panes (NERDTree on the left and Tagbar on the right) auto-collapse. They magically appear when you summon them and hide themselves when the task is done.&lt;/p&gt;
&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Sl&lt;/th&gt;
&lt;th&gt;Plugin Name&lt;/th&gt;
&lt;th&gt;Description&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/scrooloose/nerdcommenter&#34;&gt; NERDTree &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Amazing file system explorer. It presents the filesystem to you in the form of a tree which you manipulate with the keyboard and/or mouse. It also allows you to perform simple filesystem operations.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/kien/ctrlp.vim&#34;&gt; ctrlp &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;It provides an intuitive and fast mechanism to load files from the file system (with regex and fuzzy find), from open buffers, and from recently used files.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/tpope/vim-surround&#34;&gt; Surround &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Surround.vim is all about “surroundings”: parentheses, brackets, quotes, XML tags, and more.  The plugin provides mappings to easily delete, change and add such surroundings in pairs.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/scrooloose/nerdcommenter&#34;&gt; NERDCommenter &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Allows you to wrangle your code comments, regardless of filetype.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/scrooloose/syntastic&#34;&gt; Syntastic &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Awesome syntax checking plugin that runs buffers through external syntax checkers as they are saved and opened. If syntax errors are detected, the user is notified and is happy because they didn’t have to compile their code or execute their script to find them.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/Shougo/neocomplcache.vim&#34;&gt; neocomplcache &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;An amazing autocomplete plugin with additional support for snippets. It can complete simultaneously from the dictionary, buffer, omnicomplete and snippets. This is the one true plugin that brings Vim autocomplete on par with the best editors.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/tpope/vim-fugitive&#34;&gt; Fugitive &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Fugitive adds git support to git directories in vim.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/majutsushi/tagbar&#34;&gt; Tagbar &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Another cool plugin that provides an easy way to browse the tags of the current file and get an overview of its structure. It does this by creating a sidebar that displays the ctags-generated tags of the current file, ordered by their scope.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/klen/python-mode&#34;&gt; PyMode &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;A must have plugin for Python devs. This plugin contains all you need to develop python applications in Vim.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;&lt;a href=&#34;https://github.com/Valloric/YouCompleteMe&#34;&gt; YouCompleteMe &lt;/a&gt;&lt;/td&gt;
&lt;td&gt;YouCompleteMe is a fast, as-you-type, fuzzy-search code completion engine for Vim. It has several completion engines: an identifier-based engine that works with every programming language, a semantic, Clang-based engine that provides native semantic code completion for C/C++/Objective-C/Objective-C++ (“the C-family languages”), a Jedi-based completion engine for Python, an OmniSharp-based completion engine for C# and an omnifunc-based completer that uses data from Vim’s omnicomplete system to provide semantic completions for many other languages (Ruby, PHP etc.).&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;If you know of other good plugins or have some comments please feel free to reach out on twitter or send me an email. Happy coding.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Unscramble - A Word Puzzle</title>
      <link>https://www.vijayanant.com/posts/unscramble-a-word-puzzle/</link>
      <pubDate>Sat, 22 Nov 2014 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/unscramble-a-word-puzzle/</guid>
      <description>How It All Started All of this started when we (myself and my friend Raghu) were solving a word puzzle that appeared on daily newspaper. The puzzle itself is very simple. There are few english alphabets in a circle and a bold one in the centre. The challenge is to come up with as many words as possible using the letters. All the English words we come up with must contain the letter in the centre.</description>
      <content:encoded>&lt;h2 id=&#34;how-it-all-started&#34;&gt;How It All Started&lt;/h2&gt;
&lt;p&gt;All of this started when we (myself and my friend &lt;a href=&#34;https://twitter.com/raghu_ugare&#34; title=&#34; Raghu Ugare on twitter&#34;&gt;Raghu&lt;/a&gt;)
were solving a word puzzle that appeared on daily newspaper. The puzzle
itself is very simple. There are few english alphabets in a circle and a bold
one in the centre. The challenge is to come up with as many words as possible
using the letters. All the English words we come up with must contain the letter
in the centre.&lt;/p&gt;
&lt;p&gt;Raghu always came up with more words than I ever did. But I could only lose so
many times! One afternoon I came up with this small python script that did the
job. My initial solution was pretty simple - check every word in the dictionary
and see if we could construct this word from given letters. Even though this was
crude, it did work.&lt;/p&gt;
&lt;p&gt;As there were only 6-7 letters and my simple dictionary had far fewer words
(when compared to a standard dictionary which I used later), I got results
almost instantly.&lt;/p&gt;
&lt;p&gt;Here is what I came up with -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;def&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;findPossibleWords&lt;/span&gt;(keyAlphabet, alphabetList, dict):
    &lt;span style=&#34;color:#66d9ef&#34;&gt;with&lt;/span&gt; open(dict) &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; f:
        lines &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; f&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;read()&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;splitlines()
    wordlist&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;[]
    &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; word &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; lines:
        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; keyAlphabet &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; word &lt;span style=&#34;color:#f92672&#34;&gt;and&lt;/span&gt; toolsLib&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;containsOnlyFrom(word, alphabetList):
        wordlist&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;append(word)
    &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; wordlist
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;And here is how I check if a string is formed only from the given list of letters -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;def&lt;/span&gt;  &lt;span style=&#34;color:#a6e22e&#34;&gt;containsOnlyFrom&lt;/span&gt;(mystr, charset):
    &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; c &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; mystr:
        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; c &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; charset:
            &lt;span style=&#34;color:#75715e&#34;&gt;#remove c from list&lt;/span&gt;
            charset&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;charset&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;replace(c, &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;)
        &lt;span style=&#34;color:#66d9ef&#34;&gt;else&lt;/span&gt;:
            &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;False&lt;/span&gt;
    &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; &lt;span style=&#34;color:#66d9ef&#34;&gt;True&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;This is not the best solution if you are looking in a proper dictionary and the
input has a lot many letters. It can easily grow upto few minutes to return all
possible words.&lt;/p&gt;
&lt;p&gt;Until Raghu comes up with a quicker/better solution and beats me again, this
will be enough :)&lt;/p&gt;
&lt;h2 id=&#34;a-failed-attempt&#34;&gt;A Failed Attempt&lt;/h2&gt;
&lt;p&gt;I had forgotten about all this until I came across some web sites that offered
many features like that one. They called it &lt;em&gt;unscrambling.&lt;/em&gt; Some of them
&lt;a href=&#34;https://wordunscrambler.me&#34;&gt;here&lt;/a&gt; and &lt;a href=&#34;https://word.tips/unscramble-word-finder/&#34;&gt;here&lt;/a&gt;. Even though none of them solved the
same puzzle, they were doing it a lot quicker. I tried some long strings to
convince myself that they had done something cleverly.&lt;/p&gt;
&lt;p&gt;So this time around, I thought of using some dictionary library that might speed
up the whole thing. And a standard dictionary increased the chances of getting
all possible matches. A little bit of googling and I found
&lt;a href=&#34;ihttps://pypi.org/project/pyenchant/&#34;&gt;PyEnchant&lt;/a&gt; library. PyEnchant is a spellchecking library for
Python, based on the excellent &lt;a href=&#34;http://www.abisource.com/projects/enchant/&#34;&gt;Enchant&lt;/a&gt; library.&lt;/p&gt;
&lt;p&gt;All I have to do is search for a word in the dictionary and check again if the
&amp;lsquo;key&amp;rsquo; character is in that word. Simple huh!.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;dict&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;enchant&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;Dict(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;en_UK&amp;#34;&lt;/span&gt;)
&lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; dict&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;check(word) &lt;span style=&#34;color:#f92672&#34;&gt;and&lt;/span&gt; keyAlphabet &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; word:
    possible_words&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;add(word)
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;But, what words do I check? I need to have candidate strings to verify their
presence in the dictionary.  That is what I did. Words are just some
arrangements (&lt;code&gt;permutations&lt;/code&gt;) of letters. If I could find all permutations of
the given letters, I have candidate words to check in the dictionary!&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;word_perms &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; (&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;join(j) &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; k &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; range(&lt;span style=&#34;color:#ae81ff&#34;&gt;4&lt;/span&gt;, len(alphabetList) &lt;span style=&#34;color:#f92672&#34;&gt;+&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1&lt;/span&gt;) &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; j &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; itertools&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;permutations(alphabetList, k))
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;This snippet generates a list of strings, with four or more letters in each,
made up of only given set of alphabets.&lt;/p&gt;
&lt;p&gt;This approach too has one serious drawback. Permutations. A string of length &lt;code&gt;n&lt;/code&gt;
has &lt;code&gt;factorial(n)&lt;/code&gt; permutations!.&lt;/p&gt;
&lt;p&gt;Even though this new script did better than the previous one, couldn&amp;rsquo;t cope up
with input having more than ten (10) letters.  But, as we always do, for the fun
of it, turned it into a &lt;a href=&#34;http://flask.pocoo.org&#34;&gt;flask&lt;/a&gt; based web API. Plan was to deploy
onto &lt;a href=&#34;https://www.heroku.com/&#34;&gt;heroku&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;I couldn&amp;rsquo;t deploy it onto Heroku as Heroku doesn&amp;rsquo;t directly support the
&lt;a href=&#34;http://www.abisource.com/projects/enchant/&#34;&gt;Enchant&lt;/a&gt; C library and &lt;a href=&#34;https://devcenter.heroku.com/articles/buildpacks&#34;&gt;heroku-buildpack&lt;/a&gt;
approach seemed too much for this.&lt;/p&gt;
&lt;p&gt;You can still have a look at all the code &lt;a href=&#34;https://github.com/vijayanant/spellathon&#34;&gt;here&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;I am currently working on a better data structure/algorithm that helps me here.
I am aiming at linear construction time and sub-linear (logarithmic?) retrieval
time. Wish me luck.&lt;/p&gt;
&lt;p&gt;And come here again to see where it took me.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title>Performance Analysis In Python</title>
      <link>https://www.vijayanant.com/posts/performance-analysis-in-python/</link>
      <pubDate>Sun, 02 Nov 2014 20:05:36 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/performance-analysis-in-python/</guid>
      <description>My recent escapade with Python taught me many things. One of which is to &amp;ldquo;start doing something that interests you. And each such daring act will teach you many more things.&amp;rdquo;
This time I set out to finding ways of analysing the performance of an application - specifically Python applications. And as always I wasn&amp;rsquo;t disappointed with the results. Why Python? I just happened to be playing around with Python at the time (what I really mean is I was learning Python!</description>
      <content:encoded>&lt;p&gt;My recent escapade with &lt;a href=&#34;https://www.python.org&#34;&gt;Python&lt;/a&gt; taught me many things. One of which is to &amp;ldquo;&lt;strong&gt;start doing something that interests you. And each such daring act will teach you many more things&lt;/strong&gt;.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;This time I set out to finding ways of analysing the performance of an application - specifically Python applications.  And as always I wasn&amp;rsquo;t disappointed with the results. Why Python? I just happened to be playing around with Python at the time (what I really mean is I was learning Python! ).&lt;/p&gt;
&lt;h2 id=&#34;performance-analysis&#34;&gt;Performance Analysis&lt;/h2&gt;
&lt;p&gt;Let us start by trying to understand what is performance and how do we analyse it.&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;&lt;strong&gt;Performance&lt;/strong&gt; is a measure of &lt;em&gt;how fast&lt;/em&gt; the application (or each component of the application) is running and &lt;em&gt;how little memory&lt;/em&gt; it uses&lt;/li&gt;
&lt;li&gt;Performance &lt;strong&gt;analysis&lt;/strong&gt; is finding where are the speed &lt;em&gt;bottlenecks&lt;/em&gt; and where is the &lt;em&gt;memory leaking&lt;/em&gt;&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;In this article we will restrict ourselves to measuring and analysing the performance. Improving performance is a different topic altogether. Hopefully, I will have something to write about it someday.  Depending on the need of the hour, you can choose any one or a combination of the tools and techniques explained here.&lt;/p&gt;
&lt;h2 id=&#34;good-old-time&#34;&gt;Good old &amp;lsquo;time&amp;rsquo;&lt;/h2&gt;
&lt;p&gt;I use a Mac, but I am pretty sure, the &lt;code&gt;time&lt;/code&gt; utility came from Unix ancestry.&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;$ time python slowprogram.py
python slowprogram.py  3.81s user 0.04s system 97% cpu 3.927 total
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The sum of user and system time gives you a measure of how much time your program took (excluding time taken for I/O).&lt;/p&gt;
&lt;p&gt;This doesn&amp;rsquo;t help much. Though this tells you that the application is taking more time than it should be taking (how do you know?), it doesn&amp;rsquo;t tell you where so that you can go look.&lt;/p&gt;
&lt;h2 id=&#34;python-timer-class---context-manager&#34;&gt;Python Timer Class - Context Manager&lt;/h2&gt;
&lt;p&gt;Corey Goldberg, in his blog &lt;a href=&#34;http://coreygoldberg.blogspot.in/2012/06/python-timer-class-context-manager-for.html&#34;&gt;here&lt;/a&gt;, has given a tiny timer class that can be used to time any block of code.&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;&lt;span style=&#34;color:#f92672&#34;&gt;from&lt;/span&gt; timeit &lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; default_timer
&lt;span style=&#34;color:#66d9ef&#34;&gt;class&lt;/span&gt; &lt;span style=&#34;color:#a6e22e&#34;&gt;Timer&lt;/span&gt;(object):
    &lt;span style=&#34;color:#66d9ef&#34;&gt;def&lt;/span&gt; __init__(self, verbose&lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt;&lt;span style=&#34;color:#66d9ef&#34;&gt;False&lt;/span&gt;):
        self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;verbose &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; verbose
        self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;timer &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; default_timer
        
    &lt;span style=&#34;color:#66d9ef&#34;&gt;def&lt;/span&gt; __enter__(self):
        self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;start &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;timer()
        &lt;span style=&#34;color:#66d9ef&#34;&gt;return&lt;/span&gt; self
        
    &lt;span style=&#34;color:#66d9ef&#34;&gt;def&lt;/span&gt; __exit__(self, &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt;args):
        end &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;timer()
        self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;elapsed_secs &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; end &lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt; self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;start
        self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;elapsed &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;elapsed_secs &lt;span style=&#34;color:#f92672&#34;&gt;*&lt;/span&gt; &lt;span style=&#34;color:#ae81ff&#34;&gt;1000&lt;/span&gt;  &lt;span style=&#34;color:#75715e&#34;&gt;# millisecs&lt;/span&gt;
        &lt;span style=&#34;color:#66d9ef&#34;&gt;if&lt;/span&gt; self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;verbose:
            print &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;elapsed time: &lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;%f&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt; ms&amp;#39;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; self&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;elapsed
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;With this class in hand all you need to do is to enclose any code within the &lt;code&gt;with&lt;/code&gt; block -&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;&lt;span style=&#34;color:#f92672&#34;&gt;from&lt;/span&gt; timer &lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; Timer
&lt;span style=&#34;color:#f92672&#34;&gt;from&lt;/span&gt; sorting &lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; Sort
&lt;span style=&#34;color:#f92672&#34;&gt;import&lt;/span&gt; random

random_items &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; [random&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;randint(&lt;span style=&#34;color:#f92672&#34;&gt;-&lt;/span&gt;&lt;span style=&#34;color:#ae81ff&#34;&gt;50&lt;/span&gt;, &lt;span style=&#34;color:#ae81ff&#34;&gt;100&lt;/span&gt;) &lt;span style=&#34;color:#66d9ef&#34;&gt;for&lt;/span&gt; c &lt;span style=&#34;color:#f92672&#34;&gt;in&lt;/span&gt; range(&lt;span style=&#34;color:#ae81ff&#34;&gt;5000&lt;/span&gt;)]
sort &lt;span style=&#34;color:#f92672&#34;&gt;=&lt;/span&gt; Sort()

&lt;span style=&#34;color:#66d9ef&#34;&gt;with&lt;/span&gt; Timer() &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; t:
    sort&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;bubble_sort(random_items)
print &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;=&amp;gt; elapsed bubble_sort: &lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;%s&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt; s&amp;#34;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; t&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;elapsed

&lt;span style=&#34;color:#66d9ef&#34;&gt;with&lt;/span&gt; Timer() &lt;span style=&#34;color:#66d9ef&#34;&gt;as&lt;/span&gt; t:
    sort&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;insertion_sort(random_items)
print &lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#34;=&amp;gt; elapsed insertion_sort: &lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt;%s&lt;/span&gt;&lt;span style=&#34;color:#e6db74&#34;&gt; s&amp;#34;&lt;/span&gt; &lt;span style=&#34;color:#f92672&#34;&gt;%&lt;/span&gt; t&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;elapsed
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;Here is a sample output :&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;$ python UsingTimer.py
=&amp;gt; elapsed bubble_sort: 4177.52599716 s
=&amp;gt; elapsed insertion_sort: 1.23190879822 s
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The advantage with this approach is obvious. You can enclose any suspicious piece of code inside the &lt;code&gt;with&lt;/code&gt; block and see if that block of code is taking too long to complete.  You would first start with enclosing a bigger chunk and keep on reducing the size to pin-point the problematic part.&lt;/p&gt;
&lt;h2 id=&#34;profiling&#34;&gt;Profiling&lt;/h2&gt;
&lt;p&gt;A &lt;a href=&#34;http://en.wikipedia.org/wiki/Profiling_(computer_programming)&#34;&gt;profile&lt;/a&gt; is a set of statistics that describes how often and for how long various parts of the program get executed. The &lt;code&gt;time&lt;/code&gt; utility described above is also a profiler - a simple one whose stats output is not very detailed.&lt;/p&gt;
&lt;p&gt;The Python standard library provides three different implementations of the same profiling interface. The documentation is available &lt;a href=&#34;https://docs.python.org/2/library/profile.html&#34;&gt;here&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;simple-approach&#34;&gt;Simple approach&lt;/h3&gt;
&lt;p&gt;Simple way to profile a script is to invoke the cProfile when running a script:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;$ python -m cProfile UsingTimer.py
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;This prints the stats onto standard out.&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;=&amp;gt; elapsed bubble_sort: 4173.29096794 s
=&amp;gt; elapsed insertion_sort: 2.54702568054 s
         25073 function calls in 4.231 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.006    0.006    4.231    4.231 UsingTimer.py:1(&amp;lt;module&amp;gt;)
    1    0.000    0.000    0.000    0.000 __future__.py:48(&amp;lt;module&amp;gt;)
    1    0.000    0.000    0.000    0.000 __future__.py:74(_Feature)
    7    0.000    0.000    0.000    0.000 __future__.py:75(__init__)
    1    0.017    0.017    0.017    0.017 hashlib.py:55(&amp;lt;module&amp;gt;)
    6    0.000    0.000    0.000    0.000 hashlib.py:94(__get_openssl_constructor)
    1    0.002    0.002    0.002    0.002 heapq.py:31(&amp;lt;module&amp;gt;)
    1    0.000    0.000    0.001    0.001 random.py:100(seed)
 5000    0.011    0.000    0.011    0.000 random.py:175(randrange)
 5000    0.003    0.000    0.014    0.000 random.py:238(randint)
    1    0.008    0.008    0.026    0.026 random.py:40(&amp;lt;module&amp;gt;)
    1    0.000    0.000    0.000    0.000 random.py:655(WichmannHill)
    1    0.000    0.000    0.000    0.000 random.py:72(Random)
    1    0.000    0.000    0.000    0.000 random.py:805(SystemRandom)
    1    0.000    0.000    0.001    0.001 random.py:91(__init__)
    1    0.001    0.001    0.003    0.003 sorting.py:1(&amp;lt;module&amp;gt;)
    1    0.002    0.002    0.003    0.003 sorting.py:11(insertion_sort)
    1    0.000    0.000    0.000    0.000 sorting.py:3(Sort)
    1    4.084    4.084    4.173    4.173 sorting.py:4(bubble_sort)
    1    0.000    0.000    0.000    0.000 timeit.py:105(Timer)
    1    0.005    0.005    0.005    0.005 timeit.py:53(&amp;lt;module&amp;gt;)
    1    0.001    0.001    0.006    0.006 timer.py:1(&amp;lt;module&amp;gt;)
    2    0.000    0.000    0.000    0.000 timer.py:12(__exit__)
    1    0.000    0.000    0.000    0.000 timer.py:3(Timer)
    2    0.000    0.000    0.000    0.000 timer.py:4(__init__)
    2    0.000    0.000    0.000    0.000 timer.py:8(__enter__)
    1    0.000    0.000    0.000    0.000 {_hashlib.openssl_md5}
    1    0.000    0.000    0.000    0.000 {_hashlib.openssl_sha1}
    1    0.000    0.000    0.000    0.000 {_hashlib.openssl_sha224}
    1    0.000    0.000    0.000    0.000 {_hashlib.openssl_sha256}
    1    0.000    0.000    0.000    0.000 {_hashlib.openssl_sha384}
    1    0.000    0.000    0.000    0.000 {_hashlib.openssl_sha512}
    1    0.000    0.000    0.000    0.000 {binascii.hexlify}
    1    0.001    0.001    0.001    0.001 {function seed at 0x109498d70}
    6    0.000    0.000    0.000    0.000 {getattr}
    6    0.000    0.000    0.000    0.000 {globals}
 5002    0.001    0.000    0.001    0.000 {len}
    1    0.000    0.000    0.000    0.000 {math.exp}
    2    0.000    0.000    0.000    0.000 {math.log}
    1    0.000    0.000    0.000    0.000 {math.sqrt}
    1    0.000    0.000    0.000    0.000 {method &#39;disable&#39; of &#39;_lsprof.Profiler&#39; objects}
 5000    0.001    0.000    0.001    0.000 {method &#39;random&#39; of &#39;_random.Random&#39; objects}
    1    0.000    0.000    0.000    0.000 {posix.urandom}
 5003    0.089    0.000    0.089    0.000 {range}
    4    0.000    0.000    0.000    0.000 {time.time}
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;From this we can figure out which module and function is heavily used and try to either improve that function or take other design decisions to reduce the number of calls to that function.&lt;/p&gt;
&lt;p&gt;In the above example, clearly, bubble sort is taking too much time. See for yourself:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    4.084    4.084    4.173    4.173 sorting.py:4(bubble_sort)
&lt;/code&gt;&lt;/pre&gt;&lt;h3 id=&#34;profiling-a-single-statement&#34;&gt;Profiling a single statement&lt;/h3&gt;
&lt;p&gt;Sometimes it is not a good idea or not required/possible to profile an entire script. In those scenarios you can profile individual statements:&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; style=&#34;color:#f8f8f2;background-color:#272822;-moz-tab-size:4;-o-tab-size:4;tab-size:4&#34;&gt;&lt;code class=&#34;language-Python&#34; data-lang=&#34;Python&#34;&gt;cProfile&lt;span style=&#34;color:#f92672&#34;&gt;.&lt;/span&gt;run(&lt;span style=&#34;color:#e6db74&#34;&gt;&amp;#39;sort.bubble_sort(random_items)&amp;#39;&lt;/span&gt;)   
&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;The stats, as before, are printed on to standard out.&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;$ python cprofile_simple.py
     10005 function calls in 3.732 seconds

Ordered by: standard name

ncalls  tottime  percall  cumtime  percall filename:lineno(function)
    1    0.000    0.000    3.732    3.732 &amp;lt;string&amp;gt;:1(&amp;lt;module&amp;gt;)
    1    3.653    3.653    3.732    3.732 sorting.py:4(bubble_sort)
 5001    0.001    0.000    0.001    0.000 {len}
    1    0.000    0.000    0.000    0.000 {method &#39;disable&#39; of &#39;_lsprof.Profiler&#39; objects}
 5001    0.079    0.000    0.079    0.000 {range} 	
&lt;/code&gt;&lt;/pre&gt;&lt;h2 id=&#34;profiling-memory-usage&#34;&gt;Profiling Memory Usage&lt;/h2&gt;
&lt;p&gt;Till now we only concerned ourselves with how long it takes to complete a task, whether it be a statement, a function call or an entire script. Now we will see how to profile memory usage of a python script.&lt;/p&gt;
&lt;p&gt;I will show you a few examples of memory profiling using the &lt;code&gt;memory_profiler&lt;/code&gt;  package.&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;$ pip install -U memory_profiler
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;&lt;code&gt;memory_profiler&lt;/code&gt; requires that you decorate your function of interest with an &lt;code&gt;@profile&lt;/code&gt; decorator:&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;$ python memprofile_sample.py
Filename: memprofile_sample.py

Line   Mem usage    Increment   Line Contents
10      8.7 MiB      0.0 MiB   @profile
11                             def test():
12      9.2 MiB      0.4 MiB       sort.bubble_sort(random_items)
13      9.2 MiB      0.0 MiB       sort.insertion_sort(random_items)
14      9.3 MiB      0.2 MiB       sort.quick_sort(random_items)
15      9.4 MiB      0.0 MiB       sort.heap_sort(random_items)
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;The first column represents the line number of the code that has been profiled, the second column (Mem usage) shows the memory usage of the Python interpreter after that line has been executed. The third column (Increment) represents the difference in memory of the current line with respect to the last one. The last column (Line Contents) prints the code that has been profiled.&lt;/p&gt;
&lt;h2 id=&#34;memory-leak&#34;&gt;Memory Leak&lt;/h2&gt;
&lt;p&gt;Python uses &lt;a href=&#34;http://en.wikipedia.org/wiki/Reference_counting&#34;&gt;reference counting&lt;/a&gt; to keep track of objects in use. What this means is each of the objects that the application creates holds a numeric count. This count represents the number of references to an object at any given time. The count is incremented every time a new reference to the object is created and decremented when a reference is deleted. This way,  when the ref-count of an object becomes zero, the Python interpreter knows that the object is no longer required and can be destroyed, thus reclaiming the memory used by that object.&lt;/p&gt;
&lt;p&gt;If Python automatically handles deleting unwanted objects &lt;strong&gt;&lt;em&gt;how does the memory leak?&lt;/em&gt;&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;The only way for the Python interpreter to know that an object is unwanted is by looking at the number of references the object has. If the developer of the script is not careful in removing those unwanted references, there is no way for Python to destroy the object and reclaim memory. So, basically, it is a human fault (No surprises there!).&lt;/p&gt;
&lt;p&gt;How do I know if my application is leaking memory? Well, intuitively, if the memory usage of the application grows over time but the amount of data it holds remains the same, there is memory leak.&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;All the code used in this article is available &lt;a href=&#34;https://github.com/vijayanant/pyperf&#34;&gt;here&lt;/a&gt;&lt;/p&gt;
&lt;/blockquote&gt;
</content:encoded>
    </item>
    
    <item>
      <title></title>
      <link>https://www.vijayanant.com/posts/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/</guid>
      <description>A Comprehensive Guide to Microservices Components Microservices architecture has gained significant popularity in recent years due to its ability to create scalable and resilient applications. This architectural style involves breaking down complex applications into smaller, independent services that communicate with each other through well-defined APIs. In this blog post, we will explore the key components of microservices architecture, provide examples of their implementation, and discuss advanced concepts to deepen your understanding.</description>
      <content:encoded>&lt;h1 id=&#34;a-comprehensive-guide-to-microservices-components&#34;&gt;A Comprehensive Guide to Microservices Components&lt;/h1&gt;
&lt;p&gt;Microservices architecture has gained significant popularity in recent years due to its ability to create scalable and resilient applications. This architectural style involves breaking down complex applications into smaller, independent services that communicate with each other through well-defined APIs. In this blog post, we will explore the key components of microservices architecture, provide examples of their implementation, and discuss advanced concepts to deepen your understanding.&lt;/p&gt;
&lt;p&gt;Before delving into the components, let&amp;rsquo;s briefly understand what microservices are. Microservices are small, loosely coupled services that focus on a specific business capability. Each microservice can be developed, deployed, and scaled independently, allowing for faster development cycles and greater flexibility. These services communicate with each other using lightweight protocols, typically over HTTP/REST or message queues.&lt;/p&gt;
&lt;p&gt;##Key Components of Microservices Architecture:&lt;/p&gt;
&lt;h3 id=&#34;service-registry-and-discovery&#34;&gt;Service Registry and Discovery:&lt;/h3&gt;
&lt;p&gt;In a microservices architecture, services need a way to locate and communicate with each other. This is where service registry and discovery come into play. Service registry acts as a central repository where services register their network location and metadata. Service discovery allows services to locate other services dynamically, making it easier to handle dynamic IP addresses and scaling scenarios.&lt;/p&gt;
&lt;h3 id=&#34;api-gateway&#34;&gt;API Gateway:&lt;/h3&gt;
&lt;p&gt;An API gateway acts as the entry point for client applications to interact with the microservices. It provides a single, unified interface through which clients can access multiple services. The API gateway handles tasks like authentication, authorization, request routing, rate limiting, and caching. It simplifies client-side complexity by abstracting the underlying microservices architecture.&lt;/p&gt;
&lt;h3 id=&#34;service-mesh&#34;&gt;Service Mesh:&lt;/h3&gt;
&lt;p&gt;A service mesh provides a dedicated infrastructure layer for handling service-to-service communication within a microservices architecture. It handles cross-cutting concerns like service discovery, load balancing, encryption, traffic management, and observability. By offloading these responsibilities from individual services, a service mesh simplifies development and improves resilience.&lt;/p&gt;
&lt;h3 id=&#34;event-driven-architecture&#34;&gt;Event-Driven Architecture:&lt;/h3&gt;
&lt;p&gt;Event-driven architecture (EDA) enables asynchronous communication between microservices by decoupling them through events. Events represent significant changes or actions within the system and can be published, consumed, and reacted to by different services. EDA promotes loose coupling, scalability, and fault tolerance, allowing services to react to events in real-time and propagate changes efficiently.&lt;/p&gt;
&lt;h3 id=&#34;message-brokers&#34;&gt;Message Brokers:&lt;/h3&gt;
&lt;p&gt;Message brokers facilitate asynchronous communication by acting as intermediaries between services. They enable the publishing and consumption of messages, ensuring reliable delivery and supporting various messaging patterns like publish-subscribe and point-to-point. Popular message brokers such as Apache Kafka and RabbitMQ provide the backbone for event-driven architectures in microservices.&lt;/p&gt;
&lt;h3 id=&#34;database-per-service&#34;&gt;Database Per Service:&lt;/h3&gt;
&lt;p&gt;In a microservices architecture, each service has its dedicated database. This approach, known as database per service, promotes loose coupling and allows services to have their independent data models and storage technologies. It provides better isolation, scalability, and flexibility for managing data within individual services.&lt;/p&gt;
&lt;h3 id=&#34;containerization-and-orchestration&#34;&gt;Containerization and Orchestration:&lt;/h3&gt;
&lt;p&gt;Containerization, using technologies like Docker, allows packaging microservices and their dependencies into lightweight, portable units. Container orchestration platforms, such as Kubernetes, automate the deployment, scaling, and management of containers across a cluster of machines. They provide features like service discovery, load balancing, and fault tolerance, ensuring efficient and resilient operation of microservices.&lt;/p&gt;
&lt;h3 id=&#34;monitoring-and-observability&#34;&gt;Monitoring and Observability:&lt;/h3&gt;
&lt;p&gt;Monitoring and observability are essential for maintaining the health and performance of microservices. Monitoring involves collecting metrics, logs, and traces to understand the system&amp;rsquo;s behavior. Observability goes a step further by providing insights into the internal states and interactions of services. Tools like Prometheus, Grafana, and Jaeger enable monitoring and observability in microservices architectures.&lt;/p&gt;
&lt;h2 id=&#34;microservices-components-in-action&#34;&gt;Microservices Components in Action:&lt;/h2&gt;
&lt;h3 id=&#34;41-netflixs-eureka-as-a-service-registry&#34;&gt;4.1. Netflix&amp;rsquo;s Eureka as a Service Registry:&lt;/h3&gt;
&lt;p&gt;Netflix&amp;rsquo;s Eureka is a popular service registry that allows services to register and discover each other dynamically. It provides a resilient and highly available solution for managing service metadata, enabling seamless communication between microservices.&lt;/p&gt;
&lt;h3 id=&#34;42-amazon-api-gateway-for-api-management&#34;&gt;4.2. Amazon API Gateway for API Management:&lt;/h3&gt;
&lt;p&gt;Amazon API Gateway simplifies API management by providing a fully managed service for creating, deploying, and securing APIs. It acts as an API gateway, allowing clients to access multiple microservices through a unified interface. It also supports features like authentication, caching, and request throttling.&lt;/p&gt;
&lt;h3 id=&#34;43-istio-as-a-service-mesh-solution&#34;&gt;4.3. Istio as a Service Mesh Solution:&lt;/h3&gt;
&lt;p&gt;Istio is an open-source service mesh that provides a comprehensive set of tools for managing microservices communication. It handles traffic routing, load balancing, service discovery, and security features like encryption and access control. Istio enhances observability by collecting telemetry data and providing powerful monitoring capabilities.&lt;/p&gt;
&lt;h3 id=&#34;44-kafka-as-a-message-broker&#34;&gt;4.4. Kafka as a Message Broker:&lt;/h3&gt;
&lt;p&gt;Apache Kafka is a distributed streaming platform that excels at handling high-throughput, fault-tolerant message streams. It acts as a reliable message broker for building event-driven architectures in microservices. Kafka enables services to publish and consume messages efficiently, ensuring reliable and scalable communication.&lt;/p&gt;
&lt;h3 id=&#34;45-mongodb-as-a-nosql-database&#34;&gt;4.5. MongoDB as a NoSQL Database:&lt;/h3&gt;
&lt;p&gt;MongoDB is a popular NoSQL database that supports flexible schemas and horizontal scalability. It fits well in microservices architectures, where each service can have its dedicated database. MongoDB provides high performance, document-based storage for microservices, facilitating agility and scalability.&lt;/p&gt;
&lt;h3 id=&#34;46-kubernetes-for-container-orchestration&#34;&gt;4.6. Kubernetes for Container Orchestration:&lt;/h3&gt;
&lt;p&gt;Kubernetes has emerged as the de facto standard for container orchestration. It automates the deployment, scaling, and management of containerized microservices across clusters of machines. Kubernetes provides powerful features like service discovery, load balancing, and self-healing, ensuring high availability and fault tolerance.&lt;/p&gt;
&lt;h3 id=&#34;47-prometheus-and-grafana-for-monitoring&#34;&gt;4.7. Prometheus and Grafana for Monitoring:&lt;/h3&gt;
&lt;p&gt;Prometheus is an open-source monitoring and alerting toolkit that collects metrics from various services and systems. Grafana is a visualization tool that works seamlessly with Prometheus, allowing users to create interactive dashboards and gain insights into the system&amp;rsquo;s behavior. Together, they provide powerful monitoring capabilities for microservices architectures.&lt;/p&gt;
&lt;h2 id=&#34;advanced-concepts-in-microservices-components&#34;&gt;Advanced Concepts in Microservices Components:&lt;/h2&gt;
&lt;h3 id=&#34;51-service-mesh-data-plane-and-control-plane&#34;&gt;5.1. Service Mesh Data Plane and Control Plane:&lt;/h3&gt;
&lt;p&gt;Service mesh architecture consists of a data plane and a control plane. The data plane handles the actual traffic between services, while the control plane manages and configures the data plane. This separation allows for flexibility and extensibility, enabling advanced features like traffic splitting, circuit breaking, and fault injection.&lt;/p&gt;
&lt;h3 id=&#34;52-asynchronous-communication-with-event-driven-architecture&#34;&gt;5.2. Asynchronous Communication with Event-Driven Architecture:&lt;/h3&gt;
&lt;p&gt;Event-driven architecture promotes asynchronous communication between services. By leveraging messaging patterns and event-driven frameworks, microservices can process events in parallel, scale independently, and react to changes in real-time. This approach is particularly beneficial in scenarios where services need to handle high traffic and maintain responsiveness.&lt;/p&gt;
&lt;h3 id=&#34;53-polyglot-persistence-with-multiple-databases&#34;&gt;5.3. Polyglot Persistence with Multiple Databases:&lt;/h3&gt;
&lt;p&gt;Microservices architecture allows each service to choose its own database technology based on specific requirements. This concept, known as polyglot persistence, enables services to leverage the strengths of different databases such as relational, document-oriented, or graph databases. However, it also introduces challenges in managing data consistency and integration.&lt;/p&gt;
&lt;h3 id=&#34;54-advanced-container-orchestration-with-service-mesh&#34;&gt;5.4. Advanced Container Orchestration with Service Mesh:&lt;/h3&gt;
&lt;p&gt;Combining container orchestration platforms like Kubernetes with service mesh solutions like Istio can unlock advanced features. Service mesh enhances Kubernetes capabilities by providing additional service-to-service communication features, observability, and security. This combination enables fine-grained control and management of microservices deployments.&lt;/p&gt;
&lt;h3 id=&#34;55-distributed-tracing-and-observability&#34;&gt;5.5. Distributed Tracing and Observability:&lt;/h3&gt;
&lt;p&gt;Distributed tracing helps in understanding how requests flow through microservices and identifying bottlenecks or performance issues. By capturing and correlating traces across services, developers and operators gain insights into end-to-end latency, service dependencies, and overall system behavior. Tools like Jaeger and Zipkin facilitate distributed tracing in microservices architectures.&lt;/p&gt;
&lt;p&gt;Microservices architecture offers a scalable and resilient approach to building complex applications. Understanding the key components, such as service registry and discovery, API gateways, service mesh, event-driven architecture, message brokers, database per service, containerization and orchestration, and monitoring and observability, is essential for successfully designing and implementing microservices. By combining these components effectively, organizations can achieve agility, scalability, and fault tolerance in their software systems.&lt;/p&gt;
&lt;h2 id=&#34;references&#34;&gt;References:&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Martin Fowler. (2014). &lt;a href=&#34;https://martinfowler.com/articles/microservices.html&#34;&gt;Microservices&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Sam Newman. (2015). Building Microservices: Designing Fine-Grained Systems. O&amp;rsquo;Reilly Media.&lt;/li&gt;
&lt;li&gt;Chris Richardson. (2016). Microservices Patterns: With Examples in Java. Manning Publications.&lt;/li&gt;
&lt;li&gt;Netflix OSS. &lt;a href=&#34;https://github.com/Netflix/eureka&#34;&gt;Eureka&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Istio &lt;a href=&#34;https://istio.io/&#34;&gt;Service Mesh for Microservices&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Apache Kafka. &lt;a href=&#34;https://kafka.apache.org/&#34;&gt;Apache Kafka&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;MongoDB. &lt;a href=&#34;https://www.mongodb.com/&#34;&gt;MongoDB&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Kubernetes. &lt;a href=&#34;https://kubernetes.io/&#34;&gt;Kubernetes&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Prometheus. &lt;a href=&#34;https://prometheus.io/&#34;&gt;Prometheus&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Grafana. &lt;a href=&#34;https://grafana.com/&#34;&gt;Grafana&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;Jaeger. &lt;a href=&#34;https://www.jaegertracing.io/&#34;&gt;Jaeger&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</content:encoded>
    </item>
    
    <item>
      <title></title>
      <link>https://www.vijayanant.com/posts/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/</guid>
      <description>Chapter 1: Introduction to Microservices 1.1 What are Microservices? Microservices, is an architectural style that structures an application as a collection of small, loosely coupled services. Each service is designed to perform a specific business capability and can be developed, deployed, and scaled independently. These services communicate with each other through well-defined APIs, often using lightweight protocols such as HTTP or message queues.
The main idea behind microservices is to break down a complex application into a set of smaller, autonomous services that can be developed and deployed independently.</description>
      <content:encoded>&lt;h1 id=&#34;chapter-1-introduction-to-microservices&#34;&gt;Chapter 1: Introduction to Microservices&lt;/h1&gt;
&lt;h2 id=&#34;11-what-are-microservices&#34;&gt;1.1 What are Microservices?&lt;/h2&gt;
&lt;p&gt;Microservices, is an architectural style that structures an application as a collection of small, loosely coupled services. Each service is designed to perform a specific business capability and can be developed, deployed, and scaled independently. These services communicate with each other through well-defined APIs, often using lightweight protocols such as HTTP or message queues.&lt;/p&gt;
&lt;p&gt;The main idea behind microservices is to break down a complex application into a set of smaller, autonomous services that can be developed and deployed independently. Each service focuses on a specific business domain or functionality and is responsible for its own data storage, business logic, and user interface. This decentralized approach allows for greater flexibility, scalability, and maintainability compared to traditional monolithic architectures.&lt;/p&gt;
&lt;p&gt;Microservices promote the principles of single responsibility and separation of concerns. Each microservice is responsible for a specific business capability and can be developed by a small, cross-functional team. This allows for better agility and faster development cycles, as each team can work independently without being blocked by dependencies on other teams.&lt;/p&gt;
&lt;p&gt;By decomposing an application into microservices, organizations can achieve better scalability and resilience. Since each service can be independently scaled based on its specific workload, it allows for efficient resource utilization and better performance. Additionally, in the event of a failure or issue with one service, it does not impact the entire application, as other services can continue to function independently.&lt;/p&gt;
&lt;p&gt;Microservices also enable technology diversity and the use of different programming languages, frameworks, and data storage technologies within a single application. This allows teams to choose the best tools for each specific service based on its requirements, rather than being constrained by a monolithic architecture.&lt;/p&gt;
&lt;p&gt;In summary, microservices are an architectural style that emphasizes the decomposition of complex applications into smaller, autonomous services. These services are independently developed, deployed, and scaled, promoting flexibility, scalability, and maintainability. The next sections of this chapter will further explore the benefits of microservices architecture and compare it with monolithic architecture.&lt;/p&gt;
&lt;h2 id=&#34;12-benefits-of-microservices-architecture&#34;&gt;1.2 Benefits of Microservices Architecture&lt;/h2&gt;
&lt;p&gt;Microservices architecture offers several advantages over traditional monolithic architecture. In this section, we will explore the key benefits that make microservices a compelling choice for building software systems.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Modularity and Scalability&lt;/strong&gt;: Microservices promote modularity by breaking down a complex application into smaller, independent services. Each service focuses on a specific business capability, making it easier to understand, develop, test, and maintain. This modularity allows for independent scaling of services based on their specific workload, resulting in better resource utilisation and improved performance.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Flexibility in Technology Stack&lt;/strong&gt;: With microservices, different services within an application can use different technologies, programming languages, and frameworks based on their individual requirements. This flexibility enables teams to choose the best tools for each service, taking advantage of the latest advancements and leveraging the expertise of the development team.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Improved Fault Isolation&lt;/strong&gt;: In a monolithic architecture, a failure in one component can potentially bring down the entire application. In contrast, microservices architecture isolates failures to specific services, allowing other services to continue functioning. This fault isolation improves the overall resilience of the system and reduces the impact of failures.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Continuous Deployment and Delivery&lt;/strong&gt;: Microservices architecture aligns well with continuous integration and continuous deployment (CI/CD) practices. Each microservice can be developed, tested, and deployed independently, enabling faster iteration and shorter release cycles. This agility is crucial for organisations that require frequent updates and quick response to changing business needs.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Team Autonomy and Scalability&lt;/strong&gt;: Microservices architecture promotes team autonomy, as each service can be developed and maintained by a dedicated team. This autonomy allows teams to work independently, make technology choices, and iterate quickly. Additionally, as the system grows, new services can be added without affecting existing ones, enabling the organisation to scale development efforts.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Resilience and Fault Tolerance&lt;/strong&gt;: Microservices architecture inherently supports fault tolerance and resilience. By distributing functionality across multiple services, the failure of one service does not bring down the entire system. Services can be designed to handle failures gracefully, implement retries, and recover independently, ensuring the overall system remains available and responsive.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Improved Maintainability&lt;/strong&gt;: With the smaller and more focused scope of microservices, maintaining and evolving the system becomes more manageable. Changes can be made to a specific service without impacting others, reducing the risk of unintended consequences. Additionally, smaller codebases and well-defined service boundaries make it easier to understand and debug issues, leading to improved maintainability.&lt;/p&gt;
&lt;p&gt;In summary, microservices architecture offers numerous benefits, including modularity, scalability, flexibility in technology stack, improved fault isolation, continuous deployment and delivery, team autonomy, resilience, and improved maintainability. These advantages make microservices a compelling choice for building complex software systems.&lt;/p&gt;
&lt;h2 id=&#34;13-comparing-with-monolithic-architecture&#34;&gt;1.3 Comparing with Monolithic Architecture&lt;/h2&gt;
&lt;p&gt;Monolithic architecture has been the traditional approach to building software systems for many years. In this section, we will compare microservices architecture with monolithic architecture, highlighting the key differences between the two.&lt;/p&gt;
&lt;h3 id=&#34;131-monolithic-architecture&#34;&gt;1.3.1 Monolithic Architecture:&lt;/h3&gt;
&lt;p&gt;Monolithic architecture refers to an application design where all the components of the system are bundled together and deployed as a single unit. In this approach, the entire application is built as a single codebase, with all functionality and modules combined together.&lt;/p&gt;
&lt;h4 id=&#34;key-characteristics-of-monolithic-architecture&#34;&gt;Key Characteristics of Monolithic Architecture:&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;Tight Coupling&lt;/strong&gt;: In a monolithic architecture, components tend to be tightly coupled, meaning they depend on each other&amp;rsquo;s functionality. A change in one module may require modifications in other modules, making it challenging to make isolated changes.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Scalability Challenges&lt;/strong&gt;: Scaling a monolithic application can be complex. Since the entire application is deployed as a single unit, scaling requires replicating the entire application, even if only certain components require additional resources.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Technology Limitations&lt;/strong&gt;: Monolithic applications often require the use of a single technology stack and programming language throughout the entire system. This limitation can restrict the flexibility to adopt new technologies or frameworks that may be better suited for specific functionalities.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Limited Development Independence&lt;/strong&gt;: In a monolithic architecture, multiple teams working on different modules of the application may face coordination challenges. Changes made by one team may impact the work of others, leading to dependencies and coordination overhead.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Deployment Complexity&lt;/strong&gt;: Deploying updates to a monolithic application can be complex and time-consuming. Since all modules are tightly coupled, any change to the application requires redeployment of the entire system, even if only a small portion of the code has been modified.&lt;/p&gt;
&lt;h3 id=&#34;132-microservices-architecture&#34;&gt;1.3.2 Microservices Architecture:&lt;/h3&gt;
&lt;p&gt;Microservices architecture, on the other hand, is an architectural style where an application is built as a collection of small, loosely coupled services. Each service represents a specific business capability and can be developed, deployed, and scaled independently.&lt;/p&gt;
&lt;h4 id=&#34;key-characteristics-of-microservices-architecture&#34;&gt;Key Characteristics of Microservices Architecture:&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;Loose Coupling&lt;/strong&gt;: Microservices architecture promotes loose coupling between services. Each service can have its own codebase, data storage, and independent development lifecycle. This loose coupling allows for better isolation of changes and enables independent scaling of services.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Scalability and Resilience&lt;/strong&gt;: Microservices architecture offers better scalability compared to monolithic architecture. Services can be scaled individually based on their specific workload, allowing efficient resource utilisation. Additionally, failures in one service do not affect the entire system, enhancing fault tolerance and resilience.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Technology Flexibility&lt;/strong&gt;: Microservices architecture allows for the use of different technologies, programming languages, and frameworks within the same application. Each service can choose the technology stack that best suits its requirements, enabling teams to leverage the most appropriate tools for each component.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Independent Development and Deployment&lt;/strong&gt;: With microservices, development teams can work independently on different services. Each team can choose its own development pace, technology stack, and release cycles. Services can be deployed and updated independently, facilitating faster time-to-market and agility.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Scalable Team Organisation&lt;/strong&gt;: Microservices architecture aligns well with the organisation of development teams. Each service can be owned and maintained by a dedicated team, promoting autonomy and enabling faster decision-making. This allows organisations to align their development efforts with business capabilities.&lt;/p&gt;
&lt;h2 id=&#34;14-design-principles-and-considerations&#34;&gt;1.4: Design Principles and Considerations&lt;/h2&gt;
&lt;p&gt;Microservices architecture is driven by a set of design principles and design considerations that help shape the structure and behaviour of the system. In this section, we will explore some of the key design principles and considerations that are fundamental to building microservices-based applications.&lt;/p&gt;
&lt;h3 id=&#34;141-single-responsibility-principle-srp&#34;&gt;1.4.1 Single Responsibility Principle (SRP)&lt;/h3&gt;
&lt;p&gt;Each microservice should have a single responsibility or purpose. This principle promotes modular and loosely coupled services that are focused on specific business capabilities. By keeping services small and focused, it becomes easier to understand, develop, and maintain them individually.&lt;/p&gt;
&lt;h3 id=&#34;142-loose-coupling&#34;&gt;1.4.2 Loose Coupling&lt;/h3&gt;
&lt;p&gt;Loose coupling is a critical aspect of microservices architecture. It refers to the level of dependency between services. Services in a microservices architecture should be loosely coupled, meaning that they have minimal direct dependencies on each other. Loose coupling enables independent development, deployment, and scaling of services, as well as better resilience and fault isolation.&lt;/p&gt;
&lt;h3 id=&#34;143-autonomous-services&#34;&gt;1.4.3 Autonomous Services&lt;/h3&gt;
&lt;p&gt;Autonomy is a key characteristic of microservices. Each service within the architecture should be autonomous, meaning it can operate independently and make its own decisions. Autonomous services have their own data storage, business logic, and can be developed and deployed independently. This autonomy enables teams to work independently and make decisions that align with their specific service&amp;rsquo;s requirements.&lt;/p&gt;
&lt;h3 id=&#34;144-scalability-and-resilience&#34;&gt;1.4.4 Scalability and Resilience&lt;/h3&gt;
&lt;p&gt;Scalability and resilience are crucial considerations in microservices architecture. The architecture should support the ability to scale individual services based on their specific workload and resource demands. By designing services to be independently scalable, the system can efficiently utilize resources and handle varying levels of traffic. Additionally, the architecture should be resilient, allowing for fault tolerance and graceful degradation when failures occur in one or more services.&lt;/p&gt;
&lt;p&gt;These design principles form the foundation of microservices architecture and guide the development and implementation of individual services within the system. By adhering to these principles, organizations can create modular, scalable, and resilient systems that align with the goals of microservices architecture.&lt;/p&gt;
</content:encoded>
    </item>
    
    <item>
      <title></title>
      <link>https://www.vijayanant.com/posts/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/</guid>
      <description>Chapter 10: Microservices and Domain-Driven Design (DDD) 10.1 Introduction to Domain-Driven Design (DDD) In the world of software development, Domain-Driven Design (DDD) has gained significant recognition as an approach that brings a deeper understanding of the problem domain and improves the design of software systems. When combined with microservices architecture, DDD can provide a powerful framework for developing scalable and maintainable applications.
DDD emphasises the importance of aligning software design with the domain it serves.</description>
      <content:encoded>&lt;h1 id=&#34;chapter-10-microservices-and-domain-driven-design-ddd&#34;&gt;Chapter 10: Microservices and Domain-Driven Design (DDD)&lt;/h1&gt;
&lt;h2 id=&#34;101-introduction-to-domain-driven-design-ddd&#34;&gt;10.1 Introduction to Domain-Driven Design (DDD)&lt;/h2&gt;
&lt;p&gt;In the world of software development, Domain-Driven Design (DDD) has gained significant recognition as an approach that brings a deeper understanding of the problem domain and improves the design of software systems. When combined with microservices architecture, DDD can provide a powerful framework for developing scalable and maintainable applications.&lt;/p&gt;
&lt;p&gt;DDD emphasises the importance of aligning software design with the domain it serves. The &amp;ldquo;domain&amp;rdquo; refers to the specific area or industry in which the software solution operates. For example, in an e-commerce system, the domain would encompass concepts like products, orders, customers, and inventory. By understanding the domain, its intricacies, and the language used by domain experts, developers can create software that accurately represents the problem being solved.&lt;/p&gt;
&lt;p&gt;The need for domain understanding is crucial in software development. Without a deep understanding of the domain, developers may risk creating solutions that do not meet the actual business requirements. By investing time and effort in comprehending the domain, developers can build software systems that truly align with the needs of the business.&lt;/p&gt;
&lt;p&gt;To facilitate effective collaboration and communication between domain experts and developers, DDD introduces the concept of a &lt;strong&gt;&amp;ldquo;ubiquitous language.&amp;quot;&lt;/strong&gt; The ubiquitous language establishes a shared vocabulary that accurately represents the concepts, behaviours, and rules within the domain. This language acts as a bridge between technical and business domains, enabling effective communication and eliminating misunderstandings. For example, in the e-commerce domain, terms like &amp;ldquo;product catalog,&amp;rdquo; &amp;ldquo;shopping cart,&amp;rdquo; and &amp;ldquo;checkout process&amp;rdquo; would be part of the ubiquitous language, used consistently by both domain experts and developers.&lt;/p&gt;
&lt;p&gt;In DDD, &lt;strong&gt;bounded contexts&lt;/strong&gt; are used to manage complexity within a microservices architecture. A bounded context represents a distinct area within the domain where a specific model and set of concepts apply. Each bounded context has its own boundaries, models, and language, allowing teams to focus on specific aspects of the domain without becoming overwhelmed by its entire complexity. For instance, in an e-commerce system, bounded contexts could include &amp;ldquo;inventory management&amp;rdquo;, &amp;ldquo;order processing&amp;rdquo;, and &amp;ldquo;customer management&amp;rdquo;. Each of these bounded contexts may have different models and rules specific to their area of responsibility.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Aggregates&lt;/strong&gt; are another important concept in DDD. They are cohesive units of domain objects that are treated as a single entity. Aggregates encapsulate related objects and enforce consistency and transactional boundaries. For example, in an e-commerce system, an order aggregate might encapsulate order items, shipping information, and payment details. Aggregates allow developers to reason about and manipulate groups of objects as a single unit, ensuring data integrity and encapsulating complex business rules.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Domain events&lt;/strong&gt; represent significant moments or transactions within the domain. They capture important changes or occurrences and hold relevant information about the event. Domain events can be used to communicate and coordinate between microservices within a microservices architecture. For instance, in the e-commerce domain, events like &amp;ldquo;order placed&amp;rdquo;, &amp;ldquo;payment processed&amp;rdquo;, or &amp;ldquo;product inventory updated&amp;rdquo;, can be captured as domain events, enabling loosely coupled communication and eventual consistency between microservices.&lt;/p&gt;
&lt;p&gt;By combining DDD with microservices architecture, organisations can achieve several benefits. For instance, by accurately modelling the domain using DDD principles, software solutions can better align with business requirements. Additionally, the bounded contexts and aggregates provided by DDD allow for independent development and deployment of microservices, leading to maintainable and evolvable architectures. Moreover, the ubiquitous language fosters collaboration and shared understanding between domain experts and developers, improving the overall quality of the software solution.&lt;/p&gt;
&lt;p&gt;In this section, we have explored the fundamental concepts and principles of Domain-Driven Design (DDD) and its relevance to microservices architecture. By understanding the domain, establishing a ubiquitous language, defining bounded contexts, utilising aggregates, and leveraging domain events, developers can build software systems that accurately represent the problem domain and meet the needs of the business. Throughout this chapter, we will dive deeper into these concepts and provide more examples to enhance understanding.&lt;/p&gt;
&lt;p&gt;##10.2 Defining Service Boundaries using Bounded Contexts&lt;/p&gt;
&lt;p&gt;In microservices architecture, defining service boundaries is crucial to ensure modularity, scalability, and maintainability. Bounded contexts play a vital role in identifying these boundaries and aligning services with specific areas of the problem domain. Let&amp;rsquo;s explore how bounded contexts can be used to define service boundaries effectively.&lt;/p&gt;
&lt;h3 id=&#34;1021-understanding-bounded-contexts&#34;&gt;10.2.1 Understanding Bounded Contexts&lt;/h3&gt;
&lt;p&gt;Bounded contexts represent distinct areas within the problem domain where specific models, rules, and concepts apply. Each bounded context focuses on a specific business capability or subdomain and encapsulates related functionality. By defining bounded contexts, you can establish clear boundaries between services, allowing them to be developed, deployed, and scaled independently.&lt;/p&gt;
&lt;p&gt;When identifying bounded contexts, consider factors such as business capabilities, data ownership, and team organisation. Each bounded context should have a clear responsibility and encapsulate a specific part of the domain. By defining bounded contexts, you ensure that each service has a well-defined scope and purpose.&lt;/p&gt;
&lt;p&gt;To illustrate this, let&amp;rsquo;s consider a real estate management system. This system handles various aspects of property management, including listing properties, managing tenant information, and processing rental payments. Within this system, we can identify two bounded contexts:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Property Management&lt;/strong&gt;: This bounded context focuses on the functionalities related to property listing, management, and maintenance. It includes models and rules specific to properties, such as property details, location, amenities, and maintenance schedules. The ubiquitous language within this bounded context may include terms like property, listing, maintenance request, etc.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Tenant Management&lt;/strong&gt;: This bounded context deals with tenant-related functionalities, such as tenant registration, lease agreements, and rental payments. It includes models and rules specific to tenants, such as tenant information, lease terms, payment schedules, and late fee calculations. The ubiquitous language within this bounded context may include terms like tenant, lease agreement, rental payment, etc.&lt;/p&gt;
&lt;p&gt;Within each bounded context, the models, rules, and concepts are defined and structured to address the specific requirements of that area of the problem domain. The ubiquitous language used within a bounded context helps create a shared understanding among team members and stakeholders, reducing misunderstandings and enabling effective communication.&lt;/p&gt;
&lt;p&gt;It is important to note that bounded contexts are not necessarily aligned with technical or organisational boundaries. They are determined based on the problem domain and the business needs. Different parts of the system may have different bounded contexts, and each bounded context may correspond to one or more microservices.&lt;/p&gt;
&lt;h3 id=&#34;1022-establishing-service-boundaries&#34;&gt;10.2.2 Establishing Service Boundaries&lt;/h3&gt;
&lt;p&gt;Once you have identified the bounded contexts, you can use them as a starting point for defining service boundaries. Each bounded context typically corresponds to one or more microservices, which encapsulate the logic and data related to that specific context.&lt;/p&gt;
&lt;p&gt;When establishing service boundaries, it is essential to maintain high cohesion and loose coupling between services. Each microservice should have a clear responsibility and expose a well-defined API for communication. By keeping services decoupled, you minimise dependencies and enable independent development and deployment.&lt;/p&gt;
&lt;p&gt;To establish service boundaries effectively, consider the following:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Identify the core capabilities and business functions within each bounded context.&lt;/li&gt;
&lt;li&gt;Determine the data required and managed by each bounded context.&lt;/li&gt;
&lt;li&gt;Analyse the dependencies and interactions between different parts of the domain to identify potential service boundaries.&lt;/li&gt;
&lt;li&gt;Consider scalability and performance requirements when defining service boundaries.&lt;/li&gt;
&lt;li&gt;Ensure that the services are granular enough to handle changes and updates independently.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;By defining service boundaries based on bounded contexts, you create a modular and scalable architecture that aligns with the problem domain.&lt;/p&gt;
&lt;p&gt;Following our previous example, to establish service boundaries within the identified bounded contexts, we can further decompose the system into microservices:&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Customer Management Microservices&lt;/strong&gt;: This bounded context can be divided into microservices such as user registration, authentication, and profile management. Each microservice focuses on specific customer-related functionality and exposes an API for communication.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Inventory Management Microservices&lt;/strong&gt;: This bounded context can be divided into microservices like product catalog, stock management, and pricing. Each microservice manages a specific aspect of inventory-related functionality.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Order Fulfillment Microservices&lt;/strong&gt;: This bounded context can be divided into microservices like order management, payment processing, and shipping. Each microservice handles a distinct part of the order fulfilment process.&lt;/p&gt;
&lt;p&gt;By establishing clear service boundaries, we ensure that each microservice has well-defined responsibilities and can be developed and maintained independently.&lt;/p&gt;
&lt;h3 id=&#34;1023-collaborative-design-and-iterative-refinement&#34;&gt;10.2.3 Collaborative Design and Iterative Refinement&lt;/h3&gt;
&lt;p&gt;Defining service boundaries using bounded contexts is an iterative process that requires collaboration between domain experts and development teams. Through techniques like event storming and collaborative modeling, you can gain a deeper understanding of the domain and refine the service boundaries over time.&lt;/p&gt;
&lt;p&gt;As you collaborate and refine the service boundaries, consider feedback from domain experts and adjust the boundaries to better reflect the business needs. This iterative approach allows you to continuously improve the alignment between services and the problem domain.&lt;/p&gt;
&lt;p&gt;Remember that service boundaries are not set in stone and may evolve as the business requirements change. Regularly reassess the boundaries to ensure they still align with the evolving needs of the domain.&lt;/p&gt;
&lt;p&gt;In this section, we have explored the process of defining service boundaries using bounded contexts. By identifying distinct areas within the domain, establishing clear responsibilities, and fostering collaboration, you can create well-defined service boundaries that support modularity and scalability in your microservices architecture.&lt;/p&gt;
&lt;p&gt;Next, we will dive into designing cohesive aggregates within each bounded context and their significance in microservices architecture.&lt;/p&gt;
&lt;h2 id=&#34;103-aggregates-and-aggregate-design&#34;&gt;10.3 Aggregates and Aggregate Design&lt;/h2&gt;
&lt;p&gt;Aggregates serve as cohesive units that encapsulate related entities and value objects within a bounded context. They play a crucial role in managing data consistency, enforcing business rules, and defining transactional boundaries. By treating aggregates as individual units, we can design microservices that focus on specific aspects of the domain.&lt;/p&gt;
&lt;p&gt;To design effective aggregates, it is essential to analyse the domain model and identify cohesive groups of related entities. By determining which entities should be part of an aggregate, we can ensure data consistency and enforce business rules within its boundaries. This helps maintain a clear separation of concerns and allows for independent development and modification of aggregates.&lt;/p&gt;
&lt;p&gt;In the domain of Order Management, we can consider an aggregate called Order, which encapsulates the Customer, Order, and LineItem entities. The Order aggregate represents a cohesive unit of functionality within the Order Management system.&lt;/p&gt;
&lt;p&gt;The Order aggregate acts as a single unit of consistency and transactional boundary. Any changes made to the Customer, Order, or LineItem objects within the Order aggregate are managed together.&lt;/p&gt;
&lt;h3 id=&#34;1031-defining-aggregate-boundaries&#34;&gt;10.3.1 Defining Aggregate Boundaries:&lt;/h3&gt;
&lt;p&gt;Analyse the domain model and identify cohesive groups of related entities.
Determine which entities should be part of an aggregate to ensure data consistency and business rules enforcement.
By defining clear boundaries for aggregates, we can encapsulate related entities and ensure their integrity within the aggregate.
Benefits of Aggregate Design:&lt;/p&gt;
&lt;p&gt;Modularity and Scalability: Aggregates help design modular and scalable services by encapsulating related entities.
Consistency and Transactional Boundaries: Aggregates provide a clear transactional boundary, ensuring data consistency within the aggregate.
Isolation and Independence: Aggregates can be developed and modified independently, allowing teams to work autonomously on different parts of the system.
By considering aggregates as cohesive units within a microservices context, we can achieve better separation of concerns, improved scalability, and increased maintainability of our microservices architecture.&lt;/p&gt;
&lt;h2 id=&#34;104-applying-domain-driven-design-patterns&#34;&gt;10.4 Applying Domain-Driven Design Patterns&lt;/h2&gt;
&lt;p&gt;DDD offers a set of patterns and principles that can greatly enhance the design and implementation of microservices. By understanding and applying these patterns, we can create more maintainable, scalable, and cohesive microservices architectures. In this section, we will explore some common DDD patterns and discuss their relevance and application within a microservices context.&lt;/p&gt;
&lt;h3 id=&#34;value-objects&#34;&gt;Value Objects&lt;/h3&gt;
&lt;p&gt;Value Objects are immutable objects within the domain. They encapsulate data and behaviour related to a specific concept and are characterised by their equality based on their attribute values rather than identity. In a microservices architecture, Value Objects can be used to model domain-specific concepts and ensure consistency and integrity across different microservices. For example, in an e-commerce system, a Price Value Object can encapsulate currency and amount, providing methods for performing monetary calculations.&lt;/p&gt;
&lt;p&gt;### Entities&lt;/p&gt;
&lt;p&gt;Entities represent objects with unique identities and a lifecycle within the domain. They have mutable state and are identified by their attributes, relationships, and behaviour. In a microservices architecture, Entities can be used to model business entities such as customers, orders, or products. Each microservice can have its own set of Entities representing the specific domain it serves. For example, an Order Entity can have attributes like order number, customer, and order items, along with methods for updating its state.&lt;/p&gt;
&lt;h3 id=&#34;domain-services&#34;&gt;Domain Services&lt;/h3&gt;
&lt;p&gt;Domain Services encapsulate complex business logic and operations that don&amp;rsquo;t naturally fit within an Entity or Value Object. They represent behaviours and operations that are domain-specific and contribute to the overall business process. In a microservices architecture, Domain Services can be implemented within individual microservices to handle domain-specific operations. For example, a PaymentService can encapsulate the logic for processing payments, interacting with external payment gateways, and ensuring transactional consistency within the microservice.&lt;/p&gt;
&lt;h3 id=&#34;repository-pattern&#34;&gt;Repository Pattern&lt;/h3&gt;
&lt;p&gt;The Repository pattern provides an abstraction for accessing and persisting Aggregates or Entities. It decouples the domain model from the underlying persistence technology and provides a clean interface for data access. In a microservices architecture, each microservice can have its own repositories responsible for persisting and retrieving data within its bounded context. The Repository pattern helps in managing the persistence layer and ensures that the microservice is not tightly coupled to a specific data storage technology.&lt;/p&gt;
&lt;p&gt;By leveraging these DDD patterns, we can design and implement aggregates within a microservices architecture that aligns with the principles of DDD and enhances modularity, maintainability, and scalability.&lt;/p&gt;
&lt;h2 id=&#34;105-event-driven-architecture-eda-and-ddd&#34;&gt;10.5 Event-Driven Architecture (EDA) and DDD&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The relationship between event-driven architecture and DDD&lt;/li&gt;
&lt;li&gt;Leveraging events for communication and eventual consistency between microservices&lt;/li&gt;
&lt;li&gt;Event sourcing and event-driven workflows within a DDD context&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;106-testing-strategies-for-ddd-based-microservices&#34;&gt;10.6 Testing Strategies for DDD-Based Microservices&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Approaches to unit testing domain models and aggregates&lt;/li&gt;
&lt;li&gt;Integration testing within bounded contexts&lt;/li&gt;
&lt;li&gt;Using contract testing to ensure compatibility between microservices&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;107-evolving-ddd-based-microservices&#34;&gt;10.7 Evolving DDD-Based Microservices&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Refactoring and adapting the domain model over time&lt;/li&gt;
&lt;li&gt;Versioning and backward compatibility in DDD-based microservices&lt;/li&gt;
&lt;li&gt;Handling domain events and schema evolution within microservices&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;108-real-world-examples-of-ddd-based-microservices&#34;&gt;10.8 Real-World Examples of DDD-Based Microservices&lt;/h2&gt;
&lt;p&gt;-Case studies of organizations that have successfully implemented DDD in microservices&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Analyzing the benefits and challenges faced in these real-world scenarios&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;109-challenges-and-considerations-for-microservices-with-ddd&#34;&gt;10.9 Challenges and Considerations for Microservices with DDD&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Discussing the complexities and trade-offs of combining microservices and DDD&lt;/li&gt;
&lt;li&gt;Addressing challenges related to team organization, communication, and coordination&lt;/li&gt;
&lt;li&gt;Managing dependencies and interactions between microservices&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;1010-conclusion&#34;&gt;10.10 Conclusion&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Recap of the key concepts covered in the chapter&lt;/li&gt;
&lt;li&gt;Summarizing the benefits and considerations of integrating DDD with microservices&lt;/li&gt;
&lt;li&gt;Providing guidance and recommendations for successfully implementing DDD in a microservices architecture&lt;/li&gt;
&lt;/ul&gt;
</content:encoded>
    </item>
    
    <item>
      <title></title>
      <link>https://www.vijayanant.com/posts/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/</guid>
      <description>Chapter 2: Microservices Components In microservices architecture, components play a crucial role in designing and building scalable, maintainable, and loosely coupled systems. Components are the building blocks that encapsulate specific functionalities and services within a microservices ecosystem. They enable modular development, deployment, and management of individual services, promoting flexibility and agility in the overall system.
Microservices components can be seen as independent, self-contained modules responsible for handling specific business capabilities or technical functionalities.</description>
      <content:encoded>&lt;h1 id=&#34;chapter-2-microservices-components&#34;&gt;Chapter 2: Microservices Components&lt;/h1&gt;
&lt;p&gt;In microservices architecture, components play a crucial role in designing and building scalable, maintainable, and loosely coupled systems. Components are the building blocks that encapsulate specific functionalities and services within a microservices ecosystem. They enable modular development, deployment, and management of individual services, promoting flexibility and agility in the overall system.&lt;/p&gt;
&lt;p&gt;Microservices components can be seen as independent, self-contained modules responsible for handling specific business capabilities or technical functionalities. Each component focuses on a single responsibility, following the Single Responsibility Principle (SRP), which states that a component should have only one reason to change.&lt;/p&gt;
&lt;p&gt;These components can range from simple services that handle a specific domain functionality to more complex infrastructure-related components responsible for communication, discovery, orchestration, and security. Some common examples of microservices components include service instances, API gateways, message brokers, databases, caching layers, and monitoring systems.&lt;/p&gt;
&lt;p&gt;Microservices components play a vital role in enabling the benefits of microservices architecture. Here are a few key aspects where components contribute:&lt;/p&gt;
&lt;h2 id=&#34;21-service-discovery&#34;&gt;2.1 Service Discovery&lt;/h2&gt;
&lt;p&gt;Traditionally, services are typically deployed in fixed infrastructure or virtual machines with predefined IP addresses and ports. Service consumers are configured with the known addresses of service providers, which are often hardcoded or specified in configuration files. Any changes in the network or service locations require manual updates to the configurations, making it inflexible and error-prone. Also, scaling of services or adding new services involves updating the configuration of all service consumers, which can be cumbersome, time-consuming, and error-prone in large-scale deployments.&lt;/p&gt;
&lt;p&gt;In a microservices architecture, where services are distributed and dynamic, the ability to discover and communicate with services becomes crucial. Service discovery is the process of dynamically locating and connecting to services within the system. In this section, we will explore the concept of service discovery and its importance in microservices.&lt;/p&gt;
&lt;h3 id=&#34;211-what-is-service-discovery&#34;&gt;2.1.1 What is Service Discovery?&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Service discovery defined: Service discovery is the mechanism by which services can automatically register themselves and discover other services in the system.&lt;/li&gt;
&lt;li&gt;Traditional vs. dynamic service discovery: Contrasting traditional static service discovery approaches with dynamic service discovery in microservices.&lt;/li&gt;
&lt;li&gt;Benefits of service discovery: Exploring the advantages of using service discovery in a microservices environment, such as scalability, fault tolerance, and simplified service interactions.&lt;/li&gt;
&lt;/ul&gt;
&lt;hr&gt;
&lt;p&gt;Service discovery is a mechanism that enables services to dynamically register themselves and discover other services in the system. It allows services to adapt to the dynamic nature of a microservices environment by autonomously publishing their availability and location.&lt;/p&gt;
&lt;p&gt;In a traditional system, service endpoints are typically configured statically. Each service is aware of the specific endpoints it needs to communicate with, and these configurations are set during deployment. However, in a microservices architecture, where services may scale independently, move between different instances, or have dynamic addresses, static configurations become impractical.&lt;/p&gt;
&lt;p&gt;Service discovery solves this problem by providing a dynamic and automated way for services to locate and interact with each other. Services register themselves with a service registry upon startup, providing information about their network location, metadata, and other relevant details. This registry acts as a central repository of service information.&lt;/p&gt;
&lt;p&gt;When a service needs to communicate with another service, it queries the service registry to obtain the necessary information. This allows services to adapt to changes in the system, such as the addition or removal of instances, without requiring manual reconfiguration.&lt;/p&gt;
&lt;p&gt;For example, the product catalog service may need to communicate with the inventory service to check stock availability. With service discovery, the product catalog service can dynamically discover the location of the inventory service by querying the service registry. This eliminates the need for manual configuration and allows the system to adapt to changes in inventory service instances.&lt;/p&gt;
&lt;p&gt;Service discovery mechanisms can vary depending on the specific implementation. Some common approaches include DNS-based service discovery, where services are assigned domain names that map to their network addresses, and client-side discovery, where services directly communicate with the service registry to obtain information about other services.&lt;/p&gt;
&lt;h3 id=&#34;212-service-registry&#34;&gt;2.1.2 Service Registry&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Service registry overview: Understanding the role of a service registry as a central component in service discovery.&lt;/li&gt;
&lt;li&gt;Service registration: Explaining how services register themselves with the service registry upon startup.&lt;/li&gt;
&lt;li&gt;Service metadata: Discussing the use of metadata in service registration to provide additional information about services.&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;213-service-discovery-mechanisms&#34;&gt;2.1.3 Service Discovery Mechanisms&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Client-side discovery: Explaining the client-side service discovery approach, where the client is responsible for locating services.&lt;/li&gt;
&lt;li&gt;Server-side discovery: Discussing the server-side service discovery approach, where a dedicated component handles service discovery on behalf of clients.&lt;/li&gt;
&lt;li&gt;Hybrid approach: Highlighting the possibility of combining client-side and server-side discovery for enhanced flexibility.&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;214-service-discovery-patterns&#34;&gt;2.1.4 Service Discovery Patterns&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;DNS-based service discovery: Introducing DNS-based service discovery and how it leverages DNS mechanisms for service lookup.&lt;/li&gt;
&lt;li&gt;Service registry with load balancing: Exploring the use of load balancing algorithms in conjunction with service registries to distribute client requests.&lt;/li&gt;
&lt;li&gt;Proxy-based service discovery: Discussing the proxy-based approach where a service proxy handles service discovery and routing.&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;215-integration-with-container-orchestration-platforms&#34;&gt;2.1.5 Integration with Container Orchestration Platforms&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Service discovery in container environments: Addressing the challenges and considerations of service discovery within container orchestration platforms like Kubernetes.&lt;/li&gt;
&lt;li&gt;Integration with platform features: Exploring how service discovery can be integrated with platform features such as Kubernetes Services.&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;216-service-discovery-best-practices&#34;&gt;2.1.6 Service Discovery Best Practices&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Designing resilient service discovery: Discussing strategies for designing service discovery mechanisms that are resilient to failures and network partitions.&lt;/li&gt;
&lt;li&gt;Service naming conventions: Highlighting the importance of consistent and meaningful service naming conventions for effective service discovery.&lt;/li&gt;
&lt;li&gt;Monitoring and health checks: Exploring the use of health checks to ensure the availability and reliability of services in the service registry.&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id=&#34;217-conclusion&#34;&gt;2.1.7 Conclusion&lt;/h3&gt;
&lt;p&gt;Service discovery plays a vital role in enabling the dynamic and scalable nature of microservices architecture. In this section, we have explored the concept of service discovery, various service discovery mechanisms, patterns, and best practices. With a solid understanding of service discovery, you are now equipped to design and implement efficient service discovery solutions in your microservices environment.&lt;/p&gt;
&lt;h2 id=&#34;api-gateway&#34;&gt;API Gateway&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Introduction to the API gateway pattern&lt;/li&gt;
&lt;li&gt;Benefits of using an API gateway in microservices architecture&lt;/li&gt;
&lt;li&gt;Key features and functionalities of an API gateway&lt;/li&gt;
&lt;li&gt;Implementing an API gateway in your microservices ecosystem&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;message-brokers&#34;&gt;Message Brokers&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The role of message brokers in enabling asynchronous communication between microservices&lt;/li&gt;
&lt;li&gt;Popular message broker technologies (e.g., RabbitMQ, Apache Kafka)&lt;/li&gt;
&lt;li&gt;Implementing message-based communication patterns in microservices&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;service-orchestration-vs-choreography&#34;&gt;Service Orchestration vs. Choreography&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Understanding the two approaches for managing the flow of microservices interactions&lt;/li&gt;
&lt;li&gt;Comparing service orchestration and choreography patterns&lt;/li&gt;
&lt;li&gt;Choosing the appropriate approach based on your application&amp;rsquo;s requirements&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;containerization-and-orchestration&#34;&gt;Containerization and Orchestration&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Introduction to containerization and its benefits for microservices&lt;/li&gt;
&lt;li&gt;Using Docker for packaging and deploying microservices&lt;/li&gt;
&lt;li&gt;Orchestration with Kubernetes for managing containers at scale&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;infrastructure-as-code&#34;&gt;Infrastructure as Code&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Leveraging infrastructure as code (IaC) principles for managing microservices infrastructure&lt;/li&gt;
&lt;li&gt;Tools and frameworks for provisioning and managing infrastructure&lt;/li&gt;
&lt;li&gt;Benefits of using IaC in a microservices environment&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;monitoring-and-observability&#34;&gt;Monitoring and Observability&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;The importance of monitoring and observability in microservices&lt;/li&gt;
&lt;li&gt;Monitoring key metrics and performance indicators&lt;/li&gt;
&lt;li&gt;Leveraging distributed tracing and log aggregation for better visibility&lt;/li&gt;
&lt;li&gt;Introduction to monitoring tools like Prometheus and Grafana&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;security-and-authentication&#34;&gt;Security and Authentication&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Securing microservices through authentication and authorization mechanisms&lt;/li&gt;
&lt;li&gt;Implementing OAuth and JWT for API security&lt;/li&gt;
&lt;li&gt;Best practices for service-to-service authentication and authorization&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;testing-and-deployment-strategies&#34;&gt;Testing and Deployment Strategies&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Approaches to testing microservices, including unit testing and integration testing&lt;/li&gt;
&lt;li&gt;Contract testing for ensuring compatibility between microservices&lt;/li&gt;
&lt;li&gt;Continuous integration and continuous deployment (CI/CD) practices for efficient deployment&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;challenges-and-considerations-for-microservices-components&#34;&gt;Challenges and Considerations for Microservices Components&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Discussing common challenges and considerations when working with microservices components&lt;/li&gt;
&lt;li&gt;Managing component dependencies and versioning&lt;/li&gt;
&lt;li&gt;Dealing with failure and maintaining system resilience&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;conclusion&#34;&gt;Conclusion&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;Recap of key concepts covered in the chapter&lt;/li&gt;
&lt;li&gt;Summary of the importance of microservices components in building scalable and resilient systems&lt;/li&gt;
&lt;/ul&gt;
</content:encoded>
    </item>
    
    <item>
      <title></title>
      <link>https://www.vijayanant.com/posts/</link>
      <pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
      
      <guid>https://www.vijayanant.com/posts/</guid>
      <description>Microservices   Introduction
 What are microservices? Benefits of microservices architecture Comparison with monolithic architecture    Design Principles
 Single Responsibility Principle (SRP) Loose Coupling Autonomous Services Scalability and Resilience    Architectural Components
 Service Discovery API Gateway Message Brokers Service Orchestration vs. Choreography Containerisation and Orchestration (Docker, Kubernetes)    Communication and Protocols
 RESTful APIs Message-based Communication (e.g., RabbitMQ, Apache Kafka) Event-Driven Architecture (EDA) Service-to-Service Communication Patterns    Data Management</description>
      <content:encoded>&lt;h1 id=&#34;microservices&#34;&gt;Microservices&lt;/h1&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Introduction&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;What are microservices?&lt;/li&gt;
&lt;li&gt;Benefits of microservices architecture&lt;/li&gt;
&lt;li&gt;Comparison with monolithic architecture&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Design Principles&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Single Responsibility Principle (SRP)&lt;/li&gt;
&lt;li&gt;Loose Coupling&lt;/li&gt;
&lt;li&gt;Autonomous Services&lt;/li&gt;
&lt;li&gt;Scalability and Resilience&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Architectural Components&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Service Discovery&lt;/li&gt;
&lt;li&gt;API Gateway&lt;/li&gt;
&lt;li&gt;Message Brokers&lt;/li&gt;
&lt;li&gt;Service Orchestration vs. Choreography&lt;/li&gt;
&lt;li&gt;Containerisation and Orchestration (Docker, Kubernetes)&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Communication and Protocols&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;RESTful APIs&lt;/li&gt;
&lt;li&gt;Message-based Communication (e.g., RabbitMQ, Apache Kafka)&lt;/li&gt;
&lt;li&gt;Event-Driven Architecture (EDA)&lt;/li&gt;
&lt;li&gt;Service-to-Service Communication Patterns&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Data Management&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Database per Service vs. Shared Database
-Database Integration Patterns (Sagas, Event Sourcing, CQRS)&lt;/li&gt;
&lt;li&gt;Data Consistency and Eventual Consistency&lt;/li&gt;
&lt;li&gt;Data Replication and Synchronisation&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Security and Authentication&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;API Security (OAuth, JWT)&lt;/li&gt;
&lt;li&gt;Service-to-Service Authentication&lt;/li&gt;
&lt;li&gt;Authorisation and Access Control&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Testing and Deployment&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Unit Testing vs. Integration Testing&lt;/li&gt;
&lt;li&gt;Contract Testing&lt;/li&gt;
&lt;li&gt;Continuous Integration and Continuous Deployment (CI/CD)&lt;/li&gt;
&lt;li&gt;Blue-Green Deployment and Canary Releases&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Monitoring and Observability&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Distributed Tracing&lt;/li&gt;
&lt;li&gt;Log Aggregation&lt;/li&gt;
&lt;li&gt;Metrics and Monitoring Tools (Prometheus, Grafana)&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Challenges and Trade-Offs&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Service Dependency Management&lt;/li&gt;
&lt;li&gt;Distributed System Complexity&lt;/li&gt;
&lt;li&gt;Operational Overhead&lt;/li&gt;
&lt;li&gt;Team Organisation and Communication&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Microservices and Domain-Driven Design (DDD)&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Defining service boundaries&lt;/li&gt;
&lt;li&gt;Aggregate design&lt;/li&gt;
&lt;li&gt;Bounded contexts&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Microservices and DevOps&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Continuous integration and delivery
-Infrastructure as code&lt;/li&gt;
&lt;li&gt;Monitoring and alerting in a microservices environment&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;API Versioning and Evolution&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Strategies for API versioning&lt;/li&gt;
&lt;li&gt;Managing backward compatibility&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Service Meshes
- Introduction to service meshes
- Service-to-service communication with service meshes
- Observability and security with service meshes&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Circuit Breaker Pattern&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Understanding the circuit-breaker pattern&lt;/li&gt;
&lt;li&gt;Implementing circuit-breakers in microservices architecture&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Case Studies and Real-World Examples&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Netflix&lt;/li&gt;
&lt;li&gt;Uber&lt;/li&gt;
&lt;li&gt;Amazon&lt;/li&gt;
&lt;li&gt;Spotify&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Future Trends and Considerations&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Serverless Computing&lt;/li&gt;
&lt;li&gt;GraphQL and Microservices&lt;/li&gt;
&lt;li&gt;Edge Computing&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Conclusion&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Recap of key concepts&lt;/li&gt;
&lt;li&gt;Final thoughts and recommendations&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ol&gt;
</content:encoded>
    </item>
    
  </channel>
</rss>