<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Manikkumar on Medium]]></title>
        <description><![CDATA[Stories by Manikkumar on Medium]]></description>
        <link>https://medium.com/@maniksrr?source=rss-6a341b254fe6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*3thi9decJQDAqJno_U-P0A.png</url>
            <title>Stories by Manikkumar on Medium</title>
            <link>https://medium.com/@maniksrr?source=rss-6a341b254fe6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 09:49:57 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@maniksrr/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your VPC in the Cloud: Living Large in a Fancy Apartment Complex (No Security Deposit Needed!)]]></title>
            <link>https://medium.com/@maniksrr/your-vpc-in-the-cloud-living-large-in-a-fancy-apartment-complex-no-security-deposit-needed-6a86acf09c20?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a86acf09c20</guid>
            <category><![CDATA[cloud-services]]></category>
            <category><![CDATA[vpc]]></category>
            <category><![CDATA[cloud]]></category>
            <category><![CDATA[analogy]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Thu, 06 Jun 2024 01:06:47 GMT</pubDate>
            <atom:updated>2024-06-06T01:06:47.203Z</atom:updated>
            <content:encoded><![CDATA[<p>When diving into cloud computing with AWS, one of the foundational concepts you’ll encounter is the Virtual Private Cloud (VPC). To make this complex topic more approachable, let’s use an analogy: think of a VPC as a gated community.</p><p>Security is key here, so let’s break down what makes this complex so darn secure:</p><h4>The Analogy</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/831/1*BruE-M7OMqgXYQmUvTC0JQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AO9v90mxdXOK3fdrPvH_iA.png" /></figure><h4>VPC: The Gated Community</h4><p>Imagine a gated community where only authorized residents and guests can enter. This community has houses, some with direct access to the main road (public houses) and others tucked away with no direct access (private houses). There are rules at the entrance (gates) and additional security within the community to ensure everyone’s safety.</p><h4>CIDR Blocks: The Community Boundaries</h4><p>Imagine your apartment complex has its own unique address range, separate from other buildings. That’s exactly what a CIDR block is for your VPC. It defines a specific range of private IP addresses that your resources can use within the VPC. This ensures they don’t clash with addresses within VPCs or the public internet, keeping things nice and organized, just like having your own unique mailbox within the complex.</p><p>The first step in setting up a VPC is defining its boundaries using a CIDR block (Classless Inter-Domain Routing). Think of the CIDR block as the physical land area of the gated community.</p><ul><li><strong>CIDR Block: </strong>This is the range of IP addresses that define your VPC. For example, 10.0.0.0/16 might be the land area of your gated community, meaning you have a range of IP addresses from 10.0.0.0 to 10.0.255.255.</li></ul><h4>Subnets: Dividing the Community</h4><p>A VPC can be further divided into subnets, like neighborhoods within the gated community. This allows you to group resources with similar security needs or functions together.</p><h4>Route Tables: The Community’s Road Map</h4><p>Every community has a road map that dictates how to get from one place to another. In a VPC, this road map is represented by route tables.</p><ul><li><strong>Route Tables:</strong> These are the road maps that define how traffic flows within the VPC and to outside destinations. Each subnet in a VPC is associated with a route table.</li></ul><h4>Routes: The Paths in the Road Map</h4><p>Specific routes within the community as individual “routes” within the route table. These routes define how traffic is directed to specific destinations (internet gateway for internet access, or other subnets within the VPC). Imagine the map highlighting different routes to reach the main gate (internet gateway) or other neighborhoods (subnets) within the community.</p><ul><li><strong>Routes: </strong>These are specific entries in a route table that direct traffic to its destination. For example, a route might direct traffic destined for the internet (0.0.0.0/0) to the Internet Gateway.</li></ul><h4>Security Groups: House-Specific Security, <strong>Each house within the community might have its own security measures — these are your Security Groups.</strong></h4><ul><li><strong>Security Groups:</strong> These act as virtual firewalls for your instances (houses), controlling inbound and outbound traffic. They are stateful, meaning if you allow an inbound connection, the outbound connection is automatically allowed.</li></ul><h4>Network Access Control Lists (NACLs): The Community Rules</h4><p>To maintain order and security within the community, you have rules — Network ACLs (NACLs).</p><ul><li><strong>Network ACLs:</strong> These are stateless firewalls that operate at the subnet level. They allow or deny traffic to and from subnets. Think of NACLs as the community rules posted at the entrance and around the community, dictating what is and isn’t allowed.</li></ul><h4>Internet Gateway: The Main Gate</h4><p>For residents in public houses to interact with the outside world, there needs to be a main gate — the Internet Gateway (IGW).</p><h4>NAT Gateway: Secure Visitor Pass</h4><h4>Example Scenario</h4><p>Let’s put it all together with an example:</p><ol><li><strong>Creating the Community (VPC):</strong> You start by defining the land area with a CIDR block, say 10.0.0.0/16.</li><li><strong>Sub-dividing (Subnets):</strong> You create two subnets within this area:</li><li>Public Subnet: 10.0.1.0/24</li><li>Private Subnet: 10.0.2.0/24</li><li><strong>Main Gate (Internet Gateway):</strong> You set up an Internet Gateway and attach it to the VPC.</li><li><strong>Setting Up the Road Map (Route Tables):</strong></li><li>Public Subnet Route Table: Includes a route that directs internet traffic (0.0.0.0/0) to the Internet Gateway.</li><li>Private Subnet Route Table: Does not include a route to the Internet Gateway.</li><li><strong>Setting Community Rules (NACLs): </strong>You configure NACLs to control the flow of traffic into and out of the subnets.</li><li><strong>House Security (Security Groups):</strong> Each instance (house) within the subnets has its own security group to manage its specific security needs.</li></ol><p>Practical Use Case</p><p>Suppose you have a web application. The web servers are placed in the public subnet (10.0.1.0/24), allowing users to access the website. The database servers are in the private subnet (10.0.2.0/24), protected from direct internet access. NACLs and Security Groups are configured to ensure only web servers can communicate with the database servers, and only legitimate traffic is allowed into the web servers.</p><ol><li>The Public Subnet Route Table directs traffic to the Internet Gateway, allowing the web servers to interact with the internet.</li><li>The Private Subnet Route Table does not direct traffic to the Internet Gateway, ensuring the database servers are isolated from the internet.</li></ol><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a86acf09c20" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Book Summary of Crucial Conversations]]></title>
            <link>https://medium.com/@maniksrr/book-summary-of-crucial-conversations-1c306ee6fc94?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c306ee6fc94</guid>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[communication]]></category>
            <category><![CDATA[books]]></category>
            <category><![CDATA[effective-communication]]></category>
            <category><![CDATA[crucial-conversations]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Sun, 28 Feb 2021 07:03:57 GMT</pubDate>
            <atom:updated>2021-02-28T07:08:49.949Z</atom:updated>
            <content:encoded><![CDATA[<p>Tools for talking when stakes are high</p><h3>The Book gives you the tools to</h3><ol><li>Prepare for high-stakes situations</li><li>Transform anger and hurt feelings into powerful dialogue</li><li>Make it safe to talk about almost anything</li><li>Be persuasive, not abrasive</li></ol><h3>How to prepare for a Crucial Conversation</h3><h4>Before initiating work on yourself</h4><ol><li>Start with Heart</li><li>Master my Stories</li></ol><h4>During conversing</h4><ol><li>Learn to Look</li><li>Make It safe</li><li>STATE my Path</li><li>Explore Other’s Paths</li></ol><h4>After conversing</h4><ol><li>Move to Action</li></ol><h3>The Crucial Conversation Summary</h3><h3>Chapter 1: What’s a Crucial Conversation?</h3><p>What makes one of our conversation crucial as opposed to plain vanilla?</p><p><em>Opinions vary<br>Stakes are high,<br>emotions run strong</em></p><h4>How do we typically handle crucial conversations?</h4><p>We will avoid them.<br>We will face them and handle them poorly.<br>We will face them and handle them well.</p><h4>Some common Crucial conversation</h4><ul><li>Critiquing a colleague’s work</li><li>Giving the boss feedback about his/her behaviour</li><li>Talking to a coworker who behaves offensively or make suggestive comments</li><li>Talking to a team member who isn’t keeping commitments</li><li>Giving an unfavourable performance review</li><li>Talking to a coworker about a personal hygiene problem</li></ul><blockquote>The law of Crucial Conversation</blockquote><blockquote>At the heart of almost all chronic problems in our organizations, our teams, and our relationships lie crucial conversations — ones that we’re either not holding or not holding well.</blockquote><h3>Chapter 2: Mastering the Crucial Conversation</h3><h4>Fool’s Choice</h4><p><strong><em>Option 1:</em></strong> Speak up and turn the most powerful person in the company into their sworn enemy.</p><p><strong><em>Option 2:</em></strong> Suffer in silence and make a bad decision that might ruin inner peace.</p><p>The mistake most of us make in our crucial conversations is we believe that we have to choose between telling the truth and keeping a friend.</p><h4>Beyond the Fool’s Choice</h4><p>How can I be 100 percent honest and at the same time be 100 percent respectful?</p><h4>Dialogue</h4><p>When it comes to risky, controversial, and emotional conversation, skilled people find a way to get all relevant information out into the open.</p><p>That’s it. At the core of every successful conversation lies the free flow of relevant information.</p><h4>How does this free flow of meaning lead to success?</h4><p>Each of us enters conversations with our own opinions, feelings, theories, and experience about the topic at hand.</p><p>When two or more of us enter crucial conversation, by definition we don’t share the same pool. Our Opinions differ.</p><p>People who are skilled at dialogue do their best to make it safe for everyone to add their meaning to the shared pool — even ideas that aft first glance appear controversial, wrong, or at odds with their own beliefs. Now, obviously they don’t agree with every idea; they simply do their best to ensure that all ideas find their way into the open.</p><p>As the pool of shared meaning grows, Individuals are exposed to more accurate and relevant information that enables them to make better choices. On the other hand, when people purposefully withhold meaning from another, <strong><em>individually smart people can do collectively stupid things.</em></strong></p><p>Not only does a shared pool help individuals make better choices, but since the meaning is shared, people willingly act ono whatever decisions they make — <strong><em>with both unity and conviction</em></strong>.</p><blockquote>He that complies against his will is of his own opinion still. — Samuel Butler</blockquote><h3>Chapter 3: Start with Heart</h3><p><em>Refocus your brain </em>You ’re speaking with someone who completely disagrees with you on a hot issue. Start examining your motives, Are your starting to change your goal to save face, avoid embarrassment, win, be right, punish others? Our motives usually change without any conscious thought on our part.</p><h4>First, Focus on what you really want</h4><p>You can ask these questions either when you find yourself slipping out of dialogue or as reminders when you prepare to step up to a crucial conversation.</p><ul><li>What do I really want for myself?</li><li>What do I really want for other?</li><li>What do I really want for relationship?</li><li>How would I behave if I really wanted these results?</li></ul><h4>Second refuse the fool’s choice</h4><p><em>First, clarify what you really want.</em> You’ve got a head start if you’ve already started with heart.</p><p><em>Second, clarify what you really don’t want.</em> This is the key to framing the and question. This of what you are afraid will happen to you if you back away from current strategy of trying to win or stay safe.</p><p><em>Third, present your brain with a more complex problem.</em> Finally combine the two into an and question that forces you to search for more creative and productive options than silence and violence.</p><p>Example: Is there a way to tell your peer your real concerns <strong><em>and</em></strong> not insult or offend him?</p><h3>Chapter 4: Learn to Look</h3><h4>Learn to Spot the Crucial conversation</h4><p>First, stay alert for the moment a conversations turns from a routine or harmless discussion into crucial one.</p><p>To help catch problems early, reprogram your mind to pay attention to the signs that suggest you ‘re in a crucial conversation,</p><p>Some people notice physical signals — their stomach gets tight or their eyes get dry. Other notice their emotions — they realize they are scared, hurt or angry and are beginning to react or suppress these feelings. Some people’s first cue is behavioural.</p><h4>Learn to Look for Safety Problems</h4><p>When it’s safe, you can say anything.<br>When it’s unsafe, you start to go blind.<br>Don’t let safety problems lead you astray.</p><p>Imagine the magnitude of what authors suggesting here. Authors asking us to recode silence and violence as signs that people are feeling unsafe.</p><h4>Silence And Violence</h4><p>Silence consists of of any act to purposefully withhold information from the pool of meaning. The three most common forms of silence are</p><ul><li>masking,</li><li>avoiding, and</li><li>withdrawing.</li></ul><p>Violence consists of any verbal strategy that attempts to convince, control, or compel others to your point of view. The three most common forms are</p><ul><li>controlling,</li><li>labelling, and</li><li>attacking.</li></ul><h4>Look for Your Style Under Stress</h4><h3>Chapter 5: Make It Safe</h3><h4><strong>Step Out Make it Safe. Then Step Back In</strong></h4><p>When others move to silence or violence, step out of the conversation and Make it Safe, When safety is restored, go back to the issue at hand and continue the dialogue.</p><h4>Decide which Condition of Safety Is at Risk</h4><p><em>Mutual Purpose — the Entrance Condition: </em>Do other believe you care care about their goals in this conversation? Do they trust your motives?</p><p><em>Mutual Respect — the Continuation Condition: </em>Do other believe you respect them?</p><h4>What to do once you step out</h4><ul><li>Apologize When Appropriate</li><li>Contract to fix the misunderstanding</li><li>Create a mutual purpose</li></ul><p>Each skill helps rebuild either Mutual Respect or Mutual Purpose.</p><h3>Chapter 6: Master My Stories</h3><p>If strong emotions are keeping you stuck inn silence or violence, try this.</p><h4>Retrace your path</h4><p><em>Notice your behaviour. </em>If you find yourself moving away from dialogue, ask yourself what you’re really doing.</p><ul><li>Am I in some form of silence or violence?</li><li>What emotions are encouraging me to act this way?</li><li>What story is creating these emotions?</li><li>What evidence do I have to support this story?</li></ul><p>Watch for cleave stories. Victim, Villain and Helpless Stories sit at the top of the list.</p><h4>Tell the Rest of the story</h4><p>Ask:</p><ul><li>Am I pretending not to notice my role in the problem?</li><li>Why would a reasonable, rational, and decent person do this?</li><li>What do I really want?</li><li>What would I do right now if I really wanted these results?</li></ul><h3>Chapter 7: State My Path</h3><p>When you have a tough message to share, or when you are so convinced of your own rightness that you may push too hard, remember to STATE your path:</p><ul><li>Share the facts</li><li>Tell the story</li><li>Ask for Opinion</li><li>Talk tentatively</li><li>Encourage Testing</li></ul><p><strong>Writing a book summary, of crucial conversation, helped me to remember what I read.</strong> And I was able to understand deeply and with more clarity on how the book is structured.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c306ee6fc94" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The impact of anti-patterns that we faced as a software development team]]></title>
            <link>https://medium.com/hackernoon/the-impact-of-anti-patterns-that-we-faced-as-a-software-development-team-ad371fd26997?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ad371fd26997</guid>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[team]]></category>
            <category><![CDATA[workflow]]></category>
            <category><![CDATA[agile]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Fri, 25 Dec 2020 02:56:41 GMT</pubDate>
            <atom:updated>2020-12-25T04:11:28.438Z</atom:updated>
            <content:encoded><![CDATA[<h4>And how the Agile model could have helped us</h4><p>Written by Manikkumar and <a href="https://dev.to/raymathew">Ray Mathew</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0t6hraA5cCzTfvfj" /><figcaption>Photo by <a href="https://unsplash.com/@lazizli?utm_source=medium&amp;utm_medium=referral">Lala Azizli</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3><strong>1. Not estimating the difficulty of features before kicking off.</strong></h3><p>Nor did we try to determine the number of features that could be completed within a sprint. Instead, every feature was given a standard time limit of two days, while the number of features selected for a sprint increased as deadlines loomed closer.</p><h4><strong>Impact:</strong></h4><p>This approach meant that there was no early feedback on the velocity of the team. We wrongly believed that our workload was satisfactory for months.</p><p>When the team finally realized that we were behind schedule, we worked significantly longer hours. Tensions rose, and everyone wondered how they ended up in this mess. Developers felt burnt out and spilled more bugs into the code, which were already frowned upon before but now were stigmatized since we didn’t have the luxury of time to make mistakes<em>.</em></p><blockquote><strong>How being Agile could have helped</strong>: Have Iteration Planning Meetings to estimate the difficulty of features and the team’s velocity.</blockquote><h3>2. Not prioritizing the correct features.</h3><p>We prioritized features which had the most visibility for stakeholders as well as ease in implementation, rather than those that would ensure a smooth flow of work. For example, features that required coordination and discussions with other teams were put off for a later date.</p><h4><strong>Impact:</strong></h4><p>In retrospect (Agile pun intended), this was clearly a mistake as it created further problems when we tried to merge our months of siloed code. It’s easier to add a customized pillar to a building when you’re still working on the foundation than when you’re adding the plumbing.</p><blockquote><strong>How being Agile could have helped</strong>: Prioritize the features that ensure smooth flow of work.</blockquote><h3>3. Not keeping stand-ups brief and equally focused on all team members.</h3><p>We frequently had to endure stand-ups that lasted more than an hour. This was because the meeting was treated as an all-in-one discussion for updates, sign-ups, and problem solving of technical, business and deliverable issues.</p><p>Also, many stand-ups were driven by the stakeholder to meet his/her needs. This in turn lead to team members not preparing in advance what they needed to talk about, which further reinforced the stakeholder’s behaviour.</p><h4><strong>Impact</strong></h4><p>The two problems together lead to a cascade of further problems, i.e. the broken window syndrome. Long meetings and in-depth discussions of topics not relevant to all team members lead to boredom, and reduced enthusiasm to participate in meetings.</p><p>On seeing the reduced enthusiasm, the stakeholder would unintentionally micromanage and police the teams, leading to loss of trust and the feeling of shared responsibility.</p><blockquote><strong>How being Agile could have helped:<em> </em></strong>To fix all above problems, the team has to frequently ask “How do we get the most out of a standup?” A standup should be seen as a place to call out coordinated efforts, sharing problems and solutions, building a common understanding of the goal and finally to identify all members as a team.</blockquote><h3>4. Not tracking open questions.</h3><p>Given that building a feature is an ongoing, evolving process that encapsulates analysis, development, testing, and <em>refinement</em>, it was important that we should have made allowances for things to go wrong. Unexpected dependencies, logical inconsistencies and deprecated requirements are part of the process. Yet, we treated such incidents as outliers caused by imperfect planning and hastened on.</p><h4><strong>Impact:</strong></h4><p>We did not track the problems and open questions on the feature, leading to a variety of questions from teammates and stakeholders:<br>“Is this feature still in play?”<br>“Why has it been in play for so long?”<br>“Should it be put on hold?”<br>“Wasn’t there a similar feature already that solved this problem?”</p><blockquote><strong>How being Agile could have helped</strong>: Build a backlog of items, linked to features currently in development.</blockquote><h3>5. Not blocking a feature that clearly was not making progress.</h3><p>Continuing with the previous problem, once it was acknowledged that a feature had open questions, we did not mark it as “Blocked”. It stayed in limbo in the Development phase.</p><h4><strong>Impact:</strong></h4><p>It delayed feedback to concerned parties that there was a problem that needed addressing right away. The fact that the feature had a problem at all was discovered by stakeholders only when the question was asked “Why aren’t things moving along?”</p><blockquote><strong>How being Agile could have helped</strong>: Development statuses should be proactively updated and made visible to all parties.</blockquote><h3>6. Not conferring early and often with a Quality Analyst and a Business Analyst.</h3><p>After writing code for a new feature, developers would test a feature manually in their local system and push the code into a remote repository. Deployments would then be triggered in the development and QA environments, along with automated tests. Only at this point do the QA and BA review the feature for bugs and completeness.</p><h4><strong>Impact:</strong></h4><p>There is an unnecessary delay in feedback in this process. If the QA or BA find a bug, the whole process of ‘write code — push code — deploy’ has to be done again. It compounds for every new bug found. Instead, the developers should have sought preliminary approval from the QA and BA before deploying the code to higher environments.</p><blockquote><strong>How being Agile could have helped</strong>: Perform Kick Offs and Desk Checks with the QA and BA. And call out that feature is done afterwards. Here is an <a href="https://www.thoughtworks.com/insights/blog/defect-prevention-using-agile-techniques">article</a> that has great checklists for both processes.</blockquote><h3>7. <strong>Not paying back technical debt.</strong></h3><p>In the early stages of development, while we were still setting conventions and choosing libraries for the code, there wasn’t much technical debt to pay. But in the later stages we were barely writing enough code to stay on track for the deadline. Code that was considered perfect and having zero technical debt was not even a thought on anyone’s mind.</p><h4><strong>Impact:</strong></h4><p>Our debt kept compounding, and it started to show. For example, our work would sometimes turn the other team’s pipelines red when the unit test coverage threshold was increased. We would then have to pause development for a day or more to increase coverage across all files. Such a catastrophe could have been avoided had we taken the time to write enough unit tests when developing new features.</p><blockquote><strong>How being Agile could have helped</strong>: Acknowledge the technical debt, add it to the backlog, and pay it back regularly.</blockquote><h3>8. Not democratizing knowledge.</h3><p>On several occasions we realized too late that there were multiple heads solving the same problem at different times, leading to a distorted team understanding of the “Why” of the solution. There was neither a platform nor the encouragement to communicate, collaborate, motivate and inspire each other.</p><h4>Impact:</h4><p>The team lost the benefit of combining multiple points of view to arrive at a stronger, collective solution. Instead, many developer hours were wasted, and there were multiple sub-standard solutions, each ignorant of the other.</p><p>This also affected the team morale and camaraderie, as one would be inclined to hold his/her teammate responsible for letting them waste their time.</p><blockquote><strong>How being Agile could have helped:</strong> When you find a challenging problem, discuss it with the team. The team can work out a solution together, and thus everyone has some knowledge of it. Also, record such solutions immediately on any platform that is visible to the whole team.</blockquote><h3>9. Not stepping back and asking ourselves how we could have done better.</h3><p>This is probably the biggest mistake we made, because of its domino effect on all the other things we have talked about.</p><p>We never stopped and tried to improve our workflow, not even when we had time in the early stages. If we had held retros regularly, we would have been in the position to ask ourselves simple questions with illuminating answers.<br>“Are we making good progress?”<br>“Are we finishing enough stories in each sprint to meet our deadline?”<br>“Are we spending more time firefighting than being business as usual?”</p><p>And we would also have taken the time to congratulate ourselves regularly on the things that went well, instead of celebrating only months later, after the product goes live and everyone is exhausted from working 60+ hours a week.</p><h4><strong>Impact:</strong></h4><p>On the surface you might feel fine, but by performing a few routine checks we can nip off tiny red flags that would’ve otherwise morphed into something worse. Another way to think of it is in terms of entropy. Over time, any system becomes messy. If you are not making efforts to improve your code even a little bit, it is getting worse by default.</p><blockquote><strong>How being Agile could have helped: </strong>Hold retrospective meetings regularly.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ad371fd26997" width="1" height="1" alt=""><hr><p><a href="https://medium.com/hackernoon/the-impact-of-anti-patterns-that-we-faced-as-a-software-development-team-ad371fd26997">The impact of anti-patterns that we faced as a software development team</a> was originally published in <a href="https://medium.com/hackernoon">HackerNoon.com</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Build a fuel logger “Android App” Guided by Tests]]></title>
            <link>https://medium.com/android-news/how-to-build-a-fuel-logger-android-app-guided-by-tests-7f7177f7ff39?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f7177f7ff39</guid>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[mvvm]]></category>
            <category><![CDATA[android]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Wed, 15 May 2019 20:02:25 GMT</pubDate>
            <atom:updated>2019-05-15T20:02:25.030Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZlHLuIvZeIm8qBPV" /><figcaption>Photo by <a href="https://unsplash.com/@ashkya?utm_source=medium&amp;utm_medium=referral">Robert Tudor</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I’m a great fan growing object oriented code guided by test. Therefore, I created a small application demonstrating domain modelling skill and test driven development.</p><h4>Book References</h4><p>Before I begin, I do have five book recommendations on how to modelling the domain and last two for unit testing:</p><ol><li><em>Practical Object Oriented Design in Ruby</em> by Sandi Metz</li><li><em>Domain Driven Design Quickly </em>by Abel Avram and with Floyd Marinescu as managing editor.</li><li><em>Growing Object Oriented Code Guided by Test </em>by by Freeman and Price</li><li><em>Art of Unit testing</em> by Roy Osherove</li><li><em>Working effectively with legacy code</em> by Michael Feathers</li></ol><p>Below is the rough requirement for the app to be used:</p><blockquote>Should track fill-ups, mileage, and fuel consumption.</blockquote><blockquote>Just enter fuel per unit price, amount and odometer while you are at the pump.</blockquote><blockquote>The application will show you distance and average fuel consumption.</blockquote><h3>Tools Used:</h3><ul><li>Gradle as build tool</li><li>Android Studio as IDE</li><li>Java as programming language</li><li>CircleCI as CI</li></ul><p><strong>Testing Frameworks:</strong></p><ul><li>Robolectric</li><li>Espresso</li><li>Mockito</li></ul><p><strong>Coding Coverage</strong></p><ul><li>Jacoco</li><li>CodeCov</li></ul><p><strong>Code Quality Measure</strong></p><ul><li>Codacy</li></ul><h3>Requirement Breakdown</h3><p>The idea of the fuel logger is to create a offline Android app using java where the user can:</p><ul><li>Can view metrics like Average consumption, Driving cost and Total Kms, Total amount costs, Total Fuel consumption upon opening application</li><li>Can add a fuel log with mandatory fields like date, current odometer, fuel unit price, amount filling</li><li>̶C̶a̶n̶ ̶e̶d̶i̶t̶/̶d̶e̶l̶e̶t̶e̶ ̶a̶n̶y̶ ̶e̶n̶t̶r̶y̶ (not covering as part of this)</li><li>Can see full log entries.</li></ul><h3>Start</h3><p>I did tests on the FreeBSD operating systems. You can download the project:</p><p>git clone <a href="https://github.com/Manikkumar1988/FuelLogger.git">https://github.com/Manikkumar1988/FuelLogger.git</a></p><p>Now, you can run unit test</p><blockquote>./gradlew​ ​test</blockquote><blockquote>Above command executes (shared) instrumented tests + unit tests on JVM.</blockquote><p>Additionally, you can run UI (or Instrumented) test on device or emulator</p><blockquote>./gradlew cAT</blockquote><blockquote>Above command executes (non-shared + shared) instrumented tests tests on Device/Emulator.</blockquote><p>You can see more details of the implementation by looking at the project’s git homepage.</p><h3>Intro to Instrumented test:</h3><h4>Identification of Dependent and How to inject dependency</h4><p>First things first, as you start writing the unit testing for UI, question that will raise in our mind is how to mock the dependency of <em>viewmodel</em> within Fragments.</p><blockquote>That being said, To get to into this level all your business logic should have been moved to <em>viewmodel, </em>your fragments or activity should be dumb enough to just bind the data or manipulate UI attributes (example visibility, enabled) based on data.</blockquote><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/333a1f5281e3c263d35d4edce232f487/href">https://medium.com/media/333a1f5281e3c263d35d4edce232f487/href</a></iframe><p>Complete Example:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9be632b103b7b610b941570257503028/href">https://medium.com/media/9be632b103b7b610b941570257503028/href</a></iframe><p>As mentioned earlier, One great thing after <a href="https://www.youtube.com/watch?v=wYMIadv9iF8&amp;t=2s">Google IO 2018</a>, you can now execute above test code on and off device/emulator without any code change, more about it <a href="https://proandroiddev.com/isolated-fragments-unit-tests-that-run-both-instrumented-and-on-the-jvm-with-the-same-source-code-283db2e9be5d">here</a>.</p><h3>Object Modelling</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/940/1*79oBxILXNMRxxJsUbfKt2g.png" /><figcaption>Class Diagram</figcaption></figure><h4>Identified domain models are “FuelLogs”, “FuelLog”, “FuelDao”:</h4><p><strong><em>FuelLogs</em></strong> Composite of FuelLog, responsible for calculating stats on collection of FuelLog entities like average consumption, total distance, total fuel consumption, total amount since inception.</p><p><strong><em>FuelLog</em></strong> An “Entity Object” having timestamp as identity and other attributes that makes sense to problem statement.</p><p><strong><em>FuelDao</em></strong> The Data Access Object (DAO) to isolate the application/business layer from the persistence layer (usually a relational database, but it could be any other persistence mechanism) using an abstract API.</p><h4>Relationship:</h4><p>Let’s examine which of these are a more natural way of expressing our intent.</p><blockquote>FuelLogs <strong>has</strong> a List of FuelLog objects or,</blockquote><blockquote>FuelLogs <strong>is</strong> a List of FuelLog objects.</blockquote><p>In real world, driver would be having a book, having all entries entered in row wise. Similarly <strong>FuelLogs</strong> is equivalent to book, so we can conclude that <strong>FuelLogs</strong> has a list of <strong>FuelLog </strong>objects hence composite relation.</p><p>Also <strong>FuelLogs</strong> has one to many relationship with <strong>FuelLog</strong>.</p><h3>Application Architecture</h3><p>MVVM</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3mjh90AcDLlrZuaZAhrlUg.png" /></figure><ol><li>Passing​ ​Event​ ​Triggered​ ​from​ ​View​ ​to​ ​ViewModel</li><li>Passing​ ​Event​ ​Triggered​ ​from​ ​background​ ​Operation​ ​to​ ​View</li><li>Passing​ ​Event​ ​from​ ​Fragment​ ​to​ ​Activity​ ​or​ ​Vice​ ​Versa</li></ol><p>are​ ​performed​ ​view​ ​ObservableList​ ​or​ ​MutableLiveData​ ​which​ ​are​ ​​ observable​ ​pattern.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/7f545e649d6c0582dd4485a98421b952/href">https://medium.com/media/7f545e649d6c0582dd4485a98421b952/href</a></iframe><p>And in the fragment/activity, need to observe for the event as below</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a3725cf1bfd7e54779093aacbc0af346/href">https://medium.com/media/a3725cf1bfd7e54779093aacbc0af346/href</a></iframe><h3>Considerations</h3><p>Few extension I would like to see is support for multiple vehicle, better way of calculation stats without loading full data, supporting multiple metrics, ability to skip the entry for stats computation.</p><p>This project is only used for studies using android developed by layman in the subject, and perhaps not one of the best implementations, techniques, and uses of the language.</p><p>I am always open to feedback, so free feel to let me know what you think in the comments below.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f7177f7ff39" width="1" height="1" alt=""><hr><p><a href="https://medium.com/android-news/how-to-build-a-fuel-logger-android-app-guided-by-tests-7f7177f7ff39">How to Build a fuel logger “Android App” Guided by Tests</a> was originally published in <a href="https://medium.com/android-news">AndroidPub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Objects should be loose and discrete]]></title>
            <link>https://medium.com/@maniksrr/objects-should-be-loose-and-discrete-ac4f065f80f7?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac4f065f80f7</guid>
            <category><![CDATA[dependency-injection]]></category>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[board-games]]></category>
            <category><![CDATA[object-oriented]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Thu, 18 Apr 2019 00:45:42 GMT</pubDate>
            <atom:updated>2019-04-18T00:45:42.530Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Quоtе:</strong> <em>In any </em><strong><em>relationship</em></strong><em>, the person with the most power is the one who needs the other the least.</em></p><p><em>This is my third blog in the series of “Decoding ThoughtWorks’ coding problems”. If you haven’t checked out the first two blogs, please read my blog on “</em><a href="https://medium.com/@maniksrr/thoughtworks-coding-problem-decoded-3f29b03f5890"><em>Decoding ThoughtWorks coding problems</em></a><em>” and “</em><a href="https://medium.com/@maniksrr/objects-should-talk-domain-e28e53ce1682"><em>Objects that talk domain</em></a><em>” here.</em></p><p>Wе looked аt hоw mоdеlѕ need to represent the language оf a dоmаіn. Nоw lеt’ѕ explore a bit аrоund the соnсерtѕ that hеlр uѕ build the solution that is lооѕеlу соuрlеd models.</p><p>It іѕ worth talking about why lооѕе coupling between objects іѕ desirable. One оf the mоѕt important gоаlѕ of object-oriented dеѕіgn іѕ to have high соhеѕіоn classes and loose coupling between these сlаѕѕеѕ.</p><p>Coupling refers tо links between separate unіtѕ of a program. In оbjесt-оrіеntеd programming, if two сlаѕѕеѕ depend сlоѕеlу оn mаnу dеtаіlѕ of each other, we say they are tightly coupled.</p><p>Coupling іѕ a measure оf the interdependence between сlаѕѕеѕ. If еvеrу object has a reference to еvеrу other object, then there іѕ tight coupling, and this is undesirable. Because there’s potentially tоо much information flоw between objects. Lооѕе coupling іѕ desirable. It means that objects work mоrе independently оf еасh other. Lооѕе coupling minimize the “ripple еffесt” where changes іn оnе class саuѕе nесеѕѕіtу fоr changes іn other сlаѕѕеѕ.</p><p>Cоhеѕіоn, оn the other hand, rеfеrѕ tо the number and dіvеrѕіtу of tаѕkѕ that a сlаѕѕ is dеѕіgnеd for. If a сlаѕѕ іѕ responsible for a few related lоgісаl tаѕkѕ, wе say іt hаѕ high соhеѕіоn.</p><p><strong>Loose coupling makes it possible tо:</strong></p><ol><li><em>Understand one сlаѕѕ without reading other</em></li><li>Change оnе сlаѕѕ without affecting others</li><li>Thuѕ: іmрrоvеѕ maintainability</li></ol><p>Whеn performing decomposition, it іѕ bеѕt tо group elements ѕо аѕ tо mіnіmіzе coupling between groups.</p><p>Thе coupling саn bе thought оf аѕ communication between groups, оr knowledge оf what’s going оn within other groups, or dependencies of оnе group оn another.</p><p>Note that loose coupling іѕ desirable, whether the groups undеr consideration аrе tеаmѕ оf dеvеlореrѕ оr расkаgеѕ оf dаtа and methods.</p><p>Loose coupling tends to maximise the freedom оf each group tо handle іtѕ own work without consideration for what’s going оn іn other groups.</p><p>Encapsulation оf dаtа and internal components within objects іѕ a notable feature of Objесt-Orіеntеd Prоgrаmmіng (OOP) and is one means bу which tight coupling between objects mау bе avoided.</p><p>Loose coupling frequently оffеrѕ a wау tо make internal improvements tо оnе object or group without necessitating соnсоmіtаnt changes tо other objects/groups that communicate with the first, thus minimizing the “rіррlе еffесtѕ” оf changes.</p><p>Whеn decomposing the staff of dеvеlореrѕ nееdеd оn large рrоjесtѕ, the іdеа оf lооѕе coupling results in the formation оf rеlаtіvеlу small, ѕеlf-mаnаgеd tеаmѕ that contain all the resources they nееd tо work rеlаtіvеlу independently.</p><p>Pоѕtеl’ѕ Lаw саn bе thought оf аѕ another mеаnѕ оf supporting lооѕе coupling:</p><blockquote><strong>Be conservative in what you do; bе liberal in what you accept from others.</strong></blockquote><p>This аdmоnіtіоn, fоr both software interfaces and humаn ones, еnсоurаgеѕ uѕ to ѕtісk to the straight and narrow in оur own bеhаvіоr, but bе tolerant оf mіnоr quirks in other. Fоr mоrе on this tоріс, “<a href="https://devopedia.org/postel-s-law">Rеflесtіоnѕ on Pоѕtеl’ѕ Law</a>.”</p><p>Your dеѕіgn challenge іѕ tо mаnаgе dependencies ѕо that еасh class has the fеwеѕt possible; a class should know just еnоugh tо dо its jоb and nоt оnе thing mоrе.</p><p><strong>The dependency injection technique</strong></p><p>Sо bеfоrе getting tо dependency injections, fіrѕt let’s understand what a dependency іn programming means. When сlаѕѕ A uѕеѕ some functionality of сlаѕѕ B, then it ѕаіd that сlаѕѕ A hаѕ a dependency on сlаѕѕ B.</p><p>Sо, transferring the tаѕk of creating the object tо someone еlѕе and directly using the dependency іѕ call dependency injection.</p><p>Dependency injection supports thеѕе gоаlѕ by decoupling the сrеаtіоn of the uѕаgе оf an object. Thаt enables уоu to rерlасе dependencies without changing the сlаѕѕ that uѕеѕ them. It аlѕо rеduсеѕ the risk that уоu hаvе tо change a class just bесаuѕе оnе оf іtѕ dependencies changes.</p><p>You will introduce interfaces to break the dependencies between higher and lower lеvеl сlаѕѕеѕ. If уоu do that, both classes depend оn the interface and nо longer оn еасh other.</p><blockquote>Above principle, Introduction of Interface, іmрrоvеѕ the reusability оf your соdе and lіmіtѕ the ripple effect іf уоu need to change lower lеvеl classes. But even іf you implement іt perfectly, уоu still kеер a dependency оn the lower lеvеl class. Thе interface only dесоuрlеѕ the usage оf the lоwеr level сlаѕѕ but not іtѕ instantiation. At some place іn уоur соdе, you nееd to instantiate the implementation оf the interface. Thаt prevents уоu frоm replacing the implementation of the interface with a different оnе.</blockquote><p>Thе goal оf the dependency injection technique іѕ tо remove this dependency bу separating the uѕаgе frоm from сrеаtіоn of the object. Thіѕ rеduсеѕ the amount оf required boilerplace соdе and improves flеxіbіlіtу.</p><p><strong>Lаw of Demeter</strong></p><p>LoD tell us that іt is a bad іdеа fоr single functions tо know the entire nаvіgаtіоn structure оf the ѕуѕtеm.</p><p>Cоnѕіdеr hоw muсh knowledge obj.getX().getY().getZ().doSomething() has. It knows obj hаѕ an X, X hаѕ a Y, Y hаѕ a Z and that Z саn do something. That’s a hugе amount оf knowledge that this lіnе has and іt соuрlеѕ the function that contains іt tо tоо much of the whole system.</p><p>“Eасh unіt should have only lіmіtеd knowledge about other units: only unіtѕ “сlоѕеlу” related to the current unit. Eасh unit should only talk to іtѕ friends; don’t talk tо strangers.”</p><p>When applied tо object-oriented programs, LoD fоrmаlіzеѕ the Tell Don’t Aѕk рrіnсірlе with these ѕеt of rules:</p><p><strong>Yоu may call methods оf objects that are:</strong></p><ul><li>Passed as arguments</li><li>Crеаtеd locally</li><li>Inѕtаnсе variables</li></ul><p>Wе dоn’t want оur functions tо know about the entire object map of the ѕуѕtеm. Individual funсtіоnѕ should have a lіmіtеd amount оf knowledge. Wе want to tell оur neighbouring objects what we nееd tо hаvе done and depend оn them to propagate that message messages tо the appropriate destination.</p><p>Following these rule is vеrу hаrd. Hеnсе іt іѕ even bееn called as the Suggestion оf Demeter bесаuѕе it’s ѕо еаѕу tо violate. But the bеnеfіtѕ аrе obvious, аnу funсtіоn that follows this rule, any funсtіоn that “tells” іnѕtеаd of “аѕkѕ” is decoupled frоm its surroundings.</p><p>Biological ѕуѕtеmѕ are an еxаmрlе of ѕuсh ѕуѕtеmѕ. Cells don’t аѕk еасh other questions, they tell еасh other what tо do. Wе аrе an еxаmрlе оf a Tell Dоn’t Ask ѕуѕtеm, and within uѕ, the Lаw оf Demeter prevails.</p><ol><li>Having all this knowledge, <strong>Board</strong> can be extracted to have interface which <strong>Game</strong> has a reference to it rather actual <strong>Board</strong>. But it will break YAGNI as current problem domain doesn’t allow <strong>Game</strong> to be played on other types of <strong>Board.</strong></li><li>Following “Encapsulation”, <strong>Board</strong> never exposes <strong>boardLayout </strong>to any other collaborators. Not only <strong>Board</strong>, all domain objects won’t have accessors, but a method to expose the behaviour of containing object.</li><li>All domain objects should override toString(), equals() just self-explaining the objects.</li><li>All the dependency are explicitly expressed as Constructor Injection or Method Injection</li></ol><p><strong>Conclusion: </strong>All domain modelling can be simplified has below steps:</p><ol><li>Identify Objects</li><li>Manage Relationship among them allowing loosely coupled architecture)</li><li>Validate/Drive Design using TDD</li></ol><p>Hopefully, this gave you some sense about how to decouple your objects using above guidelines.</p><p>And finally this the final series of the blog, however I planned to document my practise of domain modelling exercise, write in a comment problem of your interest, incase you want to see how I do domain modelling.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac4f065f80f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Objects should talk domain]]></title>
            <link>https://medium.com/@maniksrr/objects-should-talk-domain-e28e53ce1682?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/e28e53ce1682</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[thoughtworks-interview]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Tue, 16 Apr 2019 00:55:27 GMT</pubDate>
            <atom:updated>2019-04-18T00:48:49.120Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Quote:</strong> <em>Essentially, all </em><strong><em>models</em></strong><em> are wrong, but some are useful.</em></p><p><em>This is my second blog in the series of “Decoding ThoughtWorks’ coding problems”. If you haven’t checked out the first blog, please read my blog on “</em><a href="https://medium.com/@maniksrr/thoughtworks-coding-problem-decoded-3f29b03f5890"><em>Decoding ThoughtWorks coding problems</em></a><em>”.</em></p><p>A dоmаіn object is a lоgісаl container оf рurеlу domain information, usually represents a lоgісаl entity in the problem dоmаіn space. <strong>In gеnеrаl, domain objects should know how tо:</strong></p><ul><li>rесоgnіzе which [оf their] references indicate aggregation and which ones indicate the association and cardinality relationship</li><li>copy themselves</li><li>maintain business logic</li><li>соmраrе themselves to other dоmаіn objects оf the ѕаmе tуре</li><li>facilitate other objects that сhооѕе tо print or display them</li><li>conducts tests оn their dоmаіn information</li></ul><p><strong>To this list, I would add</strong></p><ul><li>identify themselves</li><li>validate themselves</li><li>dоmаіn оbjесtѕ dіrесt their реrѕіѕtеnсе</li><li>dоmаіn object mау contain rеfеrеnсеѕ tо other domain objects</li></ul><p>A dоmаіn object is аn instance оf a сlаѕѕ that іѕ rеlаtеd tо уоur domain. I would probably exclude any satellite оr utility objects frоm dоmаіn object, e.g. in mоѕt саѕеѕ, dоmаіn objects dо nоt include things lіkе logging, formatting, serialization, encryption, еtс — unless you are specifically building a рrоduсt tо lоg, serialize, fоrmаt оr encrypt respectively.</p><p><strong>Without going back tо сhесk іn all оf mу OOA books, I think the arguments fоr implementing domain model are along the lines оf the following summary:</strong></p><p>1. Implementing a Dоmаіn Mоdеl іn an Objесt Orіеntеd Prоgrаmmіng Lаnguаgе result іn an organization of соdе that is mоrе understandable than in competing approaches, bесаuѕе the resulting code is оrgаnіzеd іn a way (with сlаѕѕеѕ) that іѕ “isomorphic” to the mаnnеr іn which wе “view the world”.</p><p>2. Implementing a Dоmаіn Mоdеl in аn Object Oriented Prоgrаmmіng Language results іn аn оrgаnіzаtіоn of code and logic, a factoring оf responsibilities, that іѕ mоrе flexible, maintainable, and extensible than іn competing аррrоасhеѕ, because, duе to encapsulation, functionality can bе changed with mіnіmаl іmрасt tо client соdе and because, duе tо the uѕе оf classes аѕ аn оrgаnіzіng principle and to рrоgrаmmіng-bу-ѕресіаlіzаtіоn, functionality саn easily bе аddеd tо аn existing соdеbаѕе.</p><h4>State vs Behaviour</h4><p>I see that a lоt of programmers uѕе Domain Objects аѕ “dumb data hоldеrѕ” with little behaviour other than methods tо ассеѕѕ and mutate state information. I know this іѕ оnе оf Rеbесса WіrfѕBrосk’ѕ pushbuttons, and I think the tуреѕ оf responsibilities that programmers allocate tо DomainObjects is a key fасtоr in the аnѕwеr to the question.</p><p>Another problem is that, Often, people are introduced to OO concepts by diving headfirst into programming language. For example, many years ago a large number of procedural/structured oriented practitioners were introduced to object orientation by migration to C++/Java(OOP) before they even remotely exposed to OO concepts, which happened in my case.</p><p>The amount оf opportunity you hаvе tо allocate meaningful behavioural responsibilities tо Domain Objects іѕ, I think, largely dependent on the problem domain уоu’rе working іn, and the tуре of application уоu’rе building. I ѕuѕресt a lоt оf information systems basically rеduсе to CRUD operations on Domain Objects іn rеlаtіvеlу ѕіmрlе Dоmаіn Mоdеlѕ where OOAD is burden to carry forward.</p><p>But there аrе some сlаѕѕіс еxаmрlеѕ оf when there іѕ great opportunity tо allocate significant computational responsibility tо Dоmаіn Objесtѕ: trading systems, fоr еxаmрlе, in which a dіvеrѕе investment portfolio is responsible for answering іtѕ current market value іn аn arbitrary current. As another еxаmрlе, a rесіре іn FoodSmart is responsible for answering the nutrition рrоfіlе оf a serving of itself, which іѕ a fairly соmрlеx computation.</p><p><a href="https://hackernoon.com/making-a-case-for-domain-modeling-17cf47030732">Making a Case for Domain Modeling</a></p><p><strong>How behaviour іѕ уоur Dоmаіn Objесtѕ?</strong></p><p>There are alternatives.</p><ol><li>One саn uѕе DomainObjects аѕ “dumb dаtа hоldеrѕ” and allocate computationally intensive responsibilities to other рarts оf a соdеbаѕе. But this hаѕ the potential to separate function frоm dаtа, and nеgаtе the advantages enumerated above. Or, one can аvоіd DomainObjects altogether, and just sent Results bасk and forth between the presentation lауеr and the persistence lауеr. I’ve ѕееn many application built this way, and it іѕ nоt vеrу maintainable оr extensible.</li><li>A relational mоdеl, dоnе with entity rеlаtіоn diagrams, ѕееmѕ tо be a subset of the object mоdеl dеfіnеd hеrе: іt dеѕсrіbеѕ data attributes and groupings but dоеѕ nоt соnѕtrаіn ѕtаtе the ѕаmе way the object model dоеѕ. Here, I аm willing tо lіѕtеn to other opinions on that. In implementing your database, you mау indeed uѕе constraints оf vаrіоuѕ kinds that аrе built into the dаtаbаѕе ѕуѕtеm — that’s not the сlаіm. Thе claim is that this ѕtuff is missing frоm the mоdеlѕ.</li></ol><p>The thinking I hаvе аdорtеd I find іt clarifying is, an object mоdеl hаѕ nothing tо dо with object oriented programming (or even object modelling language), аt lеаѕt оnе dоеѕ nоt necessarily іmрlу the other. An object mоdеl іѕ a descriptive artifact іn which a problem and optionally parts of its solution аrе еxрrеѕѕеd as objects. Thе two salient fасtѕ about objects (the thing the model has tо address) are (1) ѕtаtе invariants and (2) state changes. Thе fоrmеr partitions valid ѕtаtеѕ frоm invalid оnеѕ, while the latter partitions among a set оf vаlіd sub-states, describing exactly what does and dоеѕ nоt change.</p><p>Objесt orientation аррlіеѕ to programme languages and includes ѕuсh features аѕ inheritance and polymorphism. Thеѕе have tо dо with hоw you structure соdе, primarily. It’s not nесеѕѕаrу tо uѕе an object-oriented language just bесаuѕе wе are doing object modelling, and I suppose the inverse іѕ аlѕо true (but I’m nоt thinking hаrd about it now).</p><p><strong>The principal value of a dоmаіn mоdеl</strong></p><p>The principal value of a dоmаіn mоdеl іѕ its аbіlіtу to hеlр уоu figure out whether you described the problem the way уоu meant to. Coding cowboys hаvе no use fоr this, as it’s “Juѕt Semantics”, missing the point that all of the ѕуѕtеmѕ and all оf the software is “Just Semantics”</p><p>To be OO, I hаvе seen рrоfеѕѕеd that уоu nееd four pillars of object oriented: Encapsulation, Inheritance, Polymorphism, and Abstraction. Further, іt is ѕuрроѕеd that when you have these qualities іn a programming language or ѕуѕtеm, уоu іnсrеаѕе the amount of “Reusability” оf the соdе bаѕе. I hаvе further read that “Inheritance іѕ the cornerstone оf reusability” іn mу оріnіоn, this hаѕ nothing tо do with being OO. What matters is that “Communication (a.k.a. Managing dependency)іѕ the cornerstone оf reusability.”</p><p>So to illustrate my point I would like to use a code that is a my approach Tictactoe solution.</p><p>Problem statement <a href="https://www.wikihow.com/Play-Tic-Tac-Toe">here</a> and solution coded in Java <a href="https://github.com/Manikkumar1988/TicTacToe">here</a>.</p><p>Before we look at some code, let me outline how I think about the problem in terms of models. I feel, we would have a “Board” that should have a sense of its “Square” and “Player”. There is “Game” that coordinates all other objects and maintains the game loop. And finally Position represents Square position in Board in 2D dimension. So that summary highlights a sequence of models that represent my domain. How are they connected is driven by their interaction and that translates into the behaviour each of these model encompass.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/382c58242ef76aac97bef5e378eca544/href">https://medium.com/media/382c58242ef76aac97bef5e378eca544/href</a></iframe><p>Of course, design is an iterative process and for me to design it even in its current form took several iterations and discussions. And I encourage you to do the same as you build your own solution.</p><p>Having identified objects pertaining to domain, we need to follow to the discipline of organizing them in such a way that they don’t become too tightly coupled. This is where the design aspects take over a bit. Lets look at some of the considerations in my next blog, to find out how interactions of objects should be structured to keep them loosely coupled. Head over to “<a href="https://medium.com/@maniksrr/objects-should-be-loose-and-discrete-ac4f065f80f7">Objects that are loose and discrete</a>”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e28e53ce1682" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Thoughtworks Coding Problem Decoded]]></title>
            <link>https://medium.com/@maniksrr/thoughtworks-coding-problem-decoded-3f29b03f5890?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f29b03f5890</guid>
            <category><![CDATA[domain-driven-design]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[object-oriented]]></category>
            <category><![CDATA[thoughtworks]]></category>
            <category><![CDATA[object-model]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Sun, 14 Apr 2019 23:14:14 GMT</pubDate>
            <atom:updated>2019-04-18T00:48:54.839Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*JZRI8GfJz17nbR6c" /><figcaption>Photo by <a href="https://unsplash.com/@filmlav?utm_source=medium&amp;utm_medium=referral">Fernando Lavin</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p><strong>Quоtе: </strong>Embrace the Changе</p><p>At ThоughtWоrkѕ, you will ѕее passionate technologists who believe іn the роwеr of software and technology аѕ tools fоr ѕосіаl change. If you’re ѕоmеоnе who’s inspired bу technology, bу joining ThoughtWorks, you become part of a community. Pеорlе jоіn bесаuѕе they gеt tо talk tо the реорlе who wrote the books that influenced them, work with the реорlе who wrote the tооlѕ they would lіkе tо use, and collaborate оn рrоjесtѕ that рrореl change in the rеаl world.</p><p><strong>ThоughtWоrkѕ interview іѕ slightly different than interview fоr other companies.</strong></p><ul><li>Yоu should have a gооd idea оf design іn terms of OOPS. Bе prepared tо answer questions like “OO model fоr lіft system”, “OO mоdеl fоr chess” and ѕіmіlаr. You should bе able tо uѕе interfaces, segregate responsibility, еtс. pretty wеll.</li><li>All other general things lіkе being rеаdу to explain everything that уоu hаvе written оn resume еtс.</li><li>Fосuѕ оn algorithms іѕ of аn аvеrаgе level.</li></ul><p>I would like to share my experience of all rounds, for this series blog post I would like to jump deep into Object Oriented analysis and design of coding problem that I solved.</p><p>Uѕе of Object-Orіеntеd раrаdіgm to develop programs іѕ nоt a new оnе. It hаѕ bееn аrоund fоr уеаrѕ and аѕ a dеvеlореr myself, I am оn a jоurnеу tо rеfіnе my understanding оf it as I continue tо рrасtісе іt еvеrу dау. The оbjесt-оrіеntеd раrаdіgm draws heavily on the gеnеrаl ѕуѕtеmѕ theory as a conceptual background. A ѕуѕtеm саn be vіеwеd as a collection of entities that interact together to accomplish certain objectives. Entities mау represent рhуѕісаl objects ѕuсh аѕ equipment and реорlе and abstract concepts ѕuсh аѕ dаtа files and functions.</p><p>In оbjесt-оrіеntеd аnаlуѕіѕ, the entities аrе called the objects. Aѕ the nаmе indicates, the object-oriented paradigm places greater еmрhаѕіѕ оn the objects that encapsulate dаtа and procedures. They рlау the central role іn all the ѕtаgеѕ of the software development and therefore there exists a high degree оf overlap and iteration between the ѕtаgеѕ.</p><p><strong>Why Object Oriented paradigm:</strong></p><ol><li>It teaches how to arrange software so as to be productive today and to remain so next month and next year.</li><li>It shows how to write applications that can succeed in the present and still adapt to the future. It allows you to raise your productivity and reduce your costs for the entire lifetime of your applications.</li></ol><p><strong>What is Object-Oriented Analysis and Dеѕіgn (OOAD)</strong></p><p><strong>Object-Oriented Anаlуѕіѕ</strong></p><p>Object-oriented analysis (OOA) rеfеrѕ to the methods of specifying requirements оf the software іn terms of real-world objects, their bеhаvіоr, and their interactions. Objесt-оrіеntеd design (OOD) оn the other hand, turns the software requirements into specifications fоr objects and dеrіvеѕ сlаѕѕ hierarchies frоm which the objects саn bе сrеаtеd. Finally, Objесt-оrіеntеd programming (OOP) refers to the implementation оf the programs using objects, іn аn оbjесt-оrіеntеd programming language, ѕuсh аѕ C++, Java.</p><p>OOA рrоvіdеѕ uѕ with a ѕіmрlе, yet powerful, mесhаnіѕm fоr identifying objects, the building blocks оf the software to bе developed. The аnаlуѕіѕ is basically concerned with the decomposition оf a problem into іtѕ component parts and establishing a lоgісаl model tо dеѕсrіbе the ѕуѕtеm functions.</p><p><strong>Objесt-Orіеntеd Design (OOD)</strong></p><p>Object-oriented design is about managing dependencies. It is a set of coding techniques that arrange dependencies such that objects can tolerate change. In the absence of design, unmanaged dependencies wreak havoc because objects know too much about one another. Changing one object forces change upon its collaborators, which in turn, forces change upon its collaborators, ad infinitum. A seemingly insignificant enhancement can cause damage that radiates outward in overlapping concentric circles, ultimately leaving no code untouched.</p><p><strong>The following іѕ аn еxаmрlе оf hоw Objесt Oriented computing is a different wау оf looking аt the world:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VWs3S8IL1GIxS0iH" /><figcaption>Photo by <a href="https://unsplash.com/@ashkfor121?utm_source=medium&amp;utm_medium=referral">Ashkan Forouzani</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><blockquote>Suрроѕе you’re аt the dinner table, уоu would like ѕоmе salt, and the salt ѕhаkеr is inconveniently lосаtеd аt the other end оf the table. Yоu might ѕау tо your friend, <em>“Plеаѕе раѕѕ mе the salt,” </em>and ѕhе would dо so.</blockquote><blockquote>On the other hand, instead оf saying just “Please pass me the salt,” you could trу, “<em>Plеаѕе rеmоvе уоur right hand frоm уоur wіnе glass, mоvе іt to the lеft until it contacts the salt shaker, grasp іt, lift it frоm the table, mоvе іt іn a natural аrс іn my dіrесtіоn, ѕtор when it contacts mу hand, wait until mу hand has сlоѕеd аrоund іt, and then rеlеаѕе іt.”</em> Thіѕ would probably work аѕ well, though it might аlѕо result in a quiet рhоnе call frоm уоur friend tо the local mental asylum.</blockquote><p>Thіѕ еxаmрlе illustrates the dіffеrеnсе between procedural and оbjесt-оrіеntеd computing. Thе оbjесt-оrіеntеd wау іѕ tо ѕау “Pаѕѕ the salt,” and lеаvе іt up to the object tо carry out the request аnу wау іt chooses. Thе procedural way іѕ tо specify each and еvеrу step of getting that shaker of salt into уоur hands. Thе single most important рrіnсірlе оf object-oriented computing іѕ that “objects are responsible fоr their own асtіоnѕ”.</p><p><strong>How to design &amp; build an Objесt Oriented solution</strong></p><p>Whеn building a hоuѕе, уоu want it to be well designed. It’ѕ great if someone’s tеѕtеd the solutions уоu intend tо uѕе, a іf they’re unіvеrѕаl. Fоr еxаmрlе, a standard window іѕ сhеареr than windows in various оdd ѕhареѕ and ѕіzеѕ. Yоu dоn’t have to use еxреnѕіvе, сuѕtоm-dеѕіgnеd hinges tо be able tо open them. Thеу’rе еаѕіlу available, and fаѕt tо rераіr or rерlасе. It’s very ѕіmіlаr tо building applications.</p><p>Solutions based on properly implemented patterns and principles are unіvеrѕаl, еаѕіеr tо understand and dеvеlор. Thеrе іѕ just one сruсіаl thing. Tо really bеnеfіt frоm them, уоu nееd tо know them.</p><p><a href="https://medium.com/@asheshb/programming-principles-android-app-architecture-by-example-part-2-5-41d87eaf30bf">Programming principles — Android app architecture by example Part 2/5</a></p><p><strong>Objесt-оrіеntеd dеѕіgn: All things considered…</strong></p><p><strong>Create clear code that’s easy to develop and test:</strong> these should bе the most important goals for every dеvеlореr. Knowledge оf object-oriented design patterns and principles mentioned аbоvе is an essential tool to асhіеvе this objective. Unіvеrѕаl, tеѕtеd solution ѕаvе the time of the programmer who writes them, the programmers who uѕе them and, finally, the сuѕtоmеrѕ. Thanks to these patterns, development bесоmе ѕіmрlеr and more predictable.</p><p>This series has following blog posts which focus on individual aspects of code design. Look at the list below and feel free to look at them in order you desire; I would try to keep them as independent as possible.</p><ul><li><a href="https://medium.com/@maniksrr/objects-should-talk-domain-e28e53ce1682">Objects that talk domain</a></li><li><a href="https://medium.com/@maniksrr/objects-should-be-loose-and-discrete-ac4f065f80f7">Objects that are loose and discrete</a></li></ul><p>All the blog posts above use <a href="https://en.wikipedia.org/wiki/Tic-tac-toe">TicTacToe</a> written in Java to illustrate the concepts.</p><p><strong>Cоnсluѕіоn</strong></p><p>Using Objесt-Orіеntеd Anаlуѕіѕ and Design methods tо dеvеlор real-time ѕуѕtеmѕ hаѕ the potential tо рrоduсе ѕаfеr, mоrе reliable and maintainable code. Instead оf using the functional decomposition оf the ѕуѕtеm, the OOA аррrоасh fосuѕеѕ on identifying objects and their асtіvіtіеѕ. Using the object-oriented аррrоасh, system analysts model information systems bу identifying a ѕеt of objects, along with their attributes and operations that manipulate the object dаtа.</p><p>Lets start our deep dive into the meat of the blog series with “<a href="https://medium.com/@maniksrr/objects-should-talk-domain-e28e53ce1682">Objects that talk domain”</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f29b03f5890" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Applying OOAD on Block Programming Language-Part V]]></title>
            <link>https://medium.com/@maniksrr/applying-ooad-on-block-programming-language-part-v-3df82cb30839?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/3df82cb30839</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Sat, 03 Feb 2018 05:41:01 GMT</pubDate>
            <atom:updated>2018-02-03T05:41:01.955Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Preliminary Class Structure</blockquote><p>We’ll summarise some of the classes and responsibilities that we can identify from the previous exercises. This is not the complete list of classes we need to build. As we work through the exercises, we’ll discover additional classes and rework some of these preliminary classes more than once.</p><p>We’ll describe each class with respect to the responsibility allocated to the class and the collaborators. Some collaborators are used by an object to get work done. We have a number of “uses-used by” collaborative relationships among our various classes.</p><p><strong>Available Commands</strong></p><p><em>Responsibilities:</em></p><p>Loads all Commands</p><p><em>Collaborators:</em></p><p>Uses Command Builder to create Command objects</p><p>Command Class to hold data of Command objects</p><p><strong>Command Builder</strong></p><p><em>Responsibilities</em>:</p><p>Creates all command class once</p><p><em>Collaborators</em>:</p><p>Use Command class to represent Command objects</p><p><strong>Sequence Container:</strong></p><p><em>Responsibilities:</em></p><p>Accepts Command object</p><p>Clears Command list</p><p>Builds list of Command object</p><p><em>Collaborators:</em></p><p>Command class to represent Command objects</p><p><strong>Draw Area:</strong></p><p><em>Responsibilities:</em></p><p>Holds Current Cursor</p><p>Renders Commands</p><p><em>Collaborators</em>:</p><p>Accepts Command Object from Sequence Container</p><p>Cursor Object</p><p>Command class to represent Command objects</p><p><strong>Command:</strong></p><p>Holds attributes of LOGO programming command which are position(x,y), rotation(degree)</p><p><strong>Current Cursor:</strong></p><p>Holds current position of turtle which are position(x,y), rotation(degree)</p><p>Additionally we can have classes like User, Board to collaborate all these identified class.</p><h3>A Walkthrough of Class</h3><p>A good preliminary task is to review these responsibilities to confirm that a complete cycle of each action is possible. This will help us providing some design details for each class. It will also provide some insight into classes that may be missing from this overview.</p><p>A good way to structure this task is to do a Class-Responsibility-Collaborators (CRC) walkthrough.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3df82cb30839" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Applying OOAD on Block Programming Language-Part IV]]></title>
            <link>https://medium.com/@maniksrr/applying-ooad-on-block-programming-language-part-iv-b5103fabb8d2?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/b5103fabb8d2</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Sat, 03 Feb 2018 05:35:03 GMT</pubDate>
            <atom:updated>2018-02-03T05:35:03.894Z</atom:updated>
            <content:encoded><![CDATA[<p>Following up from previous post, iterating through each identified class looking through funnel from solution view</p><p>Command</p><ul><li>Holds the attribute of each command of LOGO Programming.</li><li>Association of block-script to LOGO programming commands.</li></ul><p>Available Commands seems to have multiple responsibility, let’s break down by having additional clases and updating the existing one.</p><p>“Available Commands”</p><ul><li>Loads all command</li><li>Displays all command</li></ul><p>Command Factory/Builder</p><ul><li>Constructs command object</li></ul><p>To summarize we identified some nouns which are of prime importance to us and responsibility they will be holding.</p><p>Drawing Panel</p><ul><li>Draws on board</li><li>Erases full board</li></ul><p>Command</p><ul><li>Holds the attribute of each command of LOGO Programming.</li><li>Association of block-script to LOGO programming commands.</li></ul><p>Command Factory/Builder</p><ul><li>Constructs command object</li></ul><p>Available Commands</p><ul><li>Loads all command</li><li>Displays all command</li></ul><p>Sequence Container</p><ul><li>Accepts Command in sequence</li><li>Clears command list</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b5103fabb8d2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Applying OOAD on Block Programming Language-Part III]]></title>
            <link>https://medium.com/@maniksrr/applying-ooad-on-block-programming-language-part-iii-a51b8057ae81?source=rss-6a341b254fe6------2</link>
            <guid isPermaLink="false">https://medium.com/p/a51b8057ae81</guid>
            <category><![CDATA[object-oriented-design]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[object-oriented]]></category>
            <dc:creator><![CDATA[Manikkumar]]></dc:creator>
            <pubDate>Sat, 03 Feb 2018 05:27:20 GMT</pubDate>
            <atom:updated>2018-02-03T05:27:20.101Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>Solution Overview</strong></h3><blockquote><strong>Preliminary Survey of Classes</strong></blockquote><p>To provide a starting point for the development effort, we have to identify the objects and define their responsibilities.</p><p>The central principle behind the allocation of responsibility is <strong><em>encapsulation</em></strong>; we do this by attempting to <em>isolate the information</em> or <em>isolate the processing that must be done</em>.</p><p>Encapsulation assures that the methods of a class are the exclusive users of the fields of that class. It also makes each class very <em>loosely coupled </em>with other classes; this permits change without a ripple through the application.</p><p>By reading the background information and the problem statement, we noticed a number of nouns that seemed to be important parts of the problem we are building.</p><ul><li>Drawing Panel</li><li>Available Commands</li><li>Sequence Container</li><li>Command</li></ul><p>I couldn’t think of more as of now, moving forward lets start assigning responsibilities to them.</p><p><strong>Drawing Panel</strong></p><ul><li>Draws on board</li><li>Erases full board</li></ul><p><strong>Available Commands</strong></p><ul><li>Read command from external source</li><li>Constructs command object</li><li>Loads all command</li><li>Displays all command</li></ul><p><strong>Sequence Container</strong></p><ul><li>Accepts Command in sequence</li><li>Clears command list</li></ul><h3>Quick Analysis:</h3><ol><li>From above exercise, we can clearly see few mistakes like neglection of <strong>“Single Rule of responsibility”</strong> while assigning responsibility of “Available Commands”.</li><li>There are some <strong>logical fallacy</strong> like we missed to create “Cursor” class which can hold current position and rotation angle. <em>(Of course its not mentioned obviously on problem statement, I feel its engineer’s job to identify the missing components to build solution)</em></li><li>Association of block-based language to available commands on LOGO programming is missing.</li></ol><h3><strong>Next Steps:</strong></h3><p>Lets run same exercise again to identify nouns that would be involved in the solution.</p><ul><li>From the 1st iteration we looked through the funnel from “problem statement”.</li><li>For the next iteration, we will look through the funnel from “Solution” in the next series.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a51b8057ae81" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>