<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>qnoid.com</title>
    <description>This is a personal website, at the outskirts of the web, away from social media and publishing platforms.</description>
    <atom:link href="https://qnoid.com/feed.xml" rel="self" type="application/rss+xml" />
    <language>en-us</language>
    <copyright>Creative Commons Attribution 3.0 License (CC-BY 3.0)</copyright>
    <pubDate>Wed, 01 Jan 2025 14:29:50 +0000</pubDate>
    <lastBuildDate>Mon, 24 Feb 2025 15:36:20 +0000</lastBuildDate>
    <docs>http://cyber.law.harvard.edu/rss/rss.html</docs>
    <generator>Hugo -- gohugo.io</generator>
    <ttl>1140</ttl>
    <link>https://qnoid.com/</link>
      <item>
        <title>2025</title>
        <link>https://qnoid.com/2025/01/01/2025.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2025/01/01/2025.html</guid>
        <description><![CDATA[<p>Hope for the best; expect the worst.</p>
]]></description>
        <pubDate>Wed, 01 Jan 2025 14:29:50 +0000</pubDate>
      </item>
      <item>
        <title>Chaos</title>
        <link>https://qnoid.com/2024/12/12/Chaos.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2024/12/12/Chaos.html</guid>
        <description><![CDATA[<p>In the last 15 years, I have lost all of my savings <a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html">twice</a> <a href="https://qnoid.com/2024/05/13/Countdown.html#main">now</a> and gone into a significant debt twice <a href="https://qnoid.com/2020/04/30/Debt-and-borrowed-time.html#main">more</a>. Each time I have rebuilt my life back up. In the last 15 years, I have only earned a salary in 10 of these and had no other income to live by. In the last 15 years, I have <a href="https://qnoid.com/2020/12/22/Bravery.html#main">faced</a> <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">anxiety and depression</a> and <a href="https://qnoid.com/2022/05/20/back-in-london.html#main">came back</a> from the brink.</p>
<p>I have done all that while moving across countries, cities, uprooting my life and dealing with fear, uncertainty and instability in the process. How do you expect a man to grow in such harsh conditions? How do you expect him to feel safe? What do you think it does to him? What do you make of him? Is he a free spirit? Do you really want to live his life? Does he come across as <a href="https://qnoid.com/2019/08/13/Anxiety-Looks-Different-in-Men.html#main">a jerk</a>? Can you accept him for who he is? Is he worthy <a href="https://qnoid.com/2015/12/09/To-be-celebrated-as-a-human.html#main">to be celebrated as a human</a>? Does he <a href="https://qnoid.com/2019/10/03/Control.html#main">deserve love</a>? Can you really love him?</p>
<p>How do I expect order when I am made of chaos?</p>
]]></description>
        <pubDate>Thu, 12 Dec 2024 23:56:58 +0000</pubDate>
      </item>
      <item>
        <title>In case of emergency break (empty) glass</title>
        <link>https://qnoid.com/2024/11/23/In-case-of-emergency-break-empty-glass.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2024/11/23/In-case-of-emergency-break-empty-glass.html</guid>
        <description><![CDATA[<p><a href="https://qnoid.com/2024/05/13/Countdown.html#main">Somehow, I made it</a>. I am lucky son of a bitch. I know it. I prey that my luck does not run out in this lifetime. At times, it feels that&rsquo;s all I have. A lucky star. Perseverance? Yes. Patience. Plenty. Grit? Check. Still, you can be capable and demonstrate all of that yet still fail the dice roll.</p>
<p>I was well past the deadline of giving notice to my flat. Which in practice would mean being liable for money I wouldn&rsquo;t have and had to borrow while also getting my ass kicked back down the ladder. Imagine playing high stakes poker. It&rsquo;s the last round. You have lost all of your money and this is the final hand. You decide to bet the house on a last ditch attempt to win everything back. You win the hand.</p>
<p>I started a new role in June, on a 6 months probation. I started building myself back up again. Saving money to prepare for the next emergency.</p>
<p>It&rsquo;s been almost 6 months and for the past couple of weeks I finally had a feeling of peace and stability. I would even go as far as to say I had been the happiest and most relaxed I had ever been since a brief period in my twenties.</p>
<p>Then calamity came knocking at my door.</p>
<p>On Thursday night at 23:00, I heard a loud, persistent, urgent knock on the front door. <strong>Bang! bang! bang!</strong> I opened the door to see a man from the fire brigade instructing me to leave the property. The building on which I am housed was at a risk of a collapse. I had 5 minutes to go. No time to pack a bag. Things were happening so fast before I knew it I was one of about 70 people in a Sports Leisure Centre with a blanket and a chair to sit on. I spent the night barely getting any sleep.</p>
<p>With very little explanation and a lack of timely, prompt and regular updates, my mind started filling in the blanks for me. All I could think of was the worst. I couldn&rsquo;t believe that having just spent the last year building my life back up, it could all just crumble again in an instant.</p>
<p>I thought of how I could lose all my possessions should the building collapse to the ground. How I would have to use months of savings to find temporary accommodation, buy clothes and basic household items. How this was putting at jeopardy my job and how I could lose it. How I would have to build myself back up yet again.</p>
<p>I started feeling very vulnerable, tired and powerless. All I wanted in that moment was to have a shower, take a nap and to feel safe in the presence of a friend, family or a loved one.</p>
<p>I looked at the glass screen of my phone, opened up the contacts app and starting scrolling through my contacts.</p>
<ul>
<li>This person seems upset with me and don&rsquo;t know why.</li>
<li>This person hasn&rsquo;t responded the last few times I have reached out to.</li>
<li>This person is just an acquaintance.</li>
<li>This person is an ex.</li>
<li>This person and I have lost touch.</li>
<li>This person is going through some hard time right now.</li>
</ul>
<p>It slowly dawned on me that there is no-one I feel close enough to, don&rsquo;t fear rejection, one who lives in close proximity, one I can reach out to, one I can rely on. I am by myself. Which, to be fair, has felt true for most of my life. I was staring at an empty glass. I felt like crying.</p>
<p>After 24 hours I finally made it back home. It&rsquo;s corny but it&rsquo;s true. Home sweet home. I channelled my mom&rsquo;s attitude who knows how to have fun, lift others and be full of life even when she is hurting. I had a hot shower, trimmed my hair, shaved my beard, put on a shirt, my perfume and headed out to clear my head. I wanted to be in the presence of others, feel connected and alive.</p>
<p>I wanted to feel human again.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/dtC1W-6hwIU?si=MGoctgihir6vM9o1" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>]]></description>
        <pubDate>Sat, 23 Nov 2024 14:50:20 +0000</pubDate>
      </item>
      <item>
        <title>Countdown</title>
        <link>https://qnoid.com/2024/05/13/Countdown.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2024/05/13/Countdown.html</guid>
        <description><![CDATA[<p>I don&rsquo;t know how to write this post. I can write it as a rant. I can write it to be hopeful, put a positive spin on it. I can write it in a way that is reflective, poignant and sad. I am upset. That much I know. I am upset that I find myself in a situation I thought I had escaped or at the very least moving away from.</p>
<p>Between my 9 years relationship coming to an end, resigning from a workplace that was making me miserable, the UK economy being in a dire state and the job market in the tech industry facing its biggest crisis probably since the dot com boom, I am heading towards bankruptcy.</p>
<p>Fuck that.</p>
<p>Today I basically need to give notice to my flat and with that start the clock. I have 2 months to find a job or pack my shit and fuck off of <a href="https://qnoid.com/2022/05/20/back-in-london.html#main">London</a>. That means going back to Greece and live with my mom. The last time I lived with my mom was 30 years ago. What happens after that? Who fucking knows. I&rsquo;ll just go for a swim.</p>
<p>I don&rsquo;t know what needs to go into this post. I have stated how I want this website to be mostly about human stories. How life is fucking messy. I am just not in the mood to be reflective right now when I am in the middle of my life crashing down like a house of cards.</p>
<p>I know very well the challenges I have been facing ever since I was a child. I always did. I am aware of the risks I am taking and what makes my life hard. I am fortunate to be in good health so it&rsquo;s easy to tell me I am being over-dramatic; offering unsolicited opinions and lecturing from the comfort of your perfectly knit life you have wrapped in a bow telling me I have a choice.</p>
<p>Fuck off.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/-bu5f1Zr3_s?si=uaXlOmUelx3Zr970" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>]]></description>
        <pubDate>Mon, 13 May 2024 11:39:09 +0100</pubDate>
      </item>
      <item>
        <title>Delta’s 10-year journey to the top of the App Store</title>
        <link>https://qnoid.com/2024/05/07/Deltas-10-year-journey-to-the-top-of-the-App-Store.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2024/05/07/Deltas-10-year-journey-to-the-top-of-the-App-Store.html</guid>
        <description><![CDATA[<p><a href="https://www.theverge.com/authors/david-pierce">David Pierce</a> at <a href="https://www.theverge.com">TheVerge</a> has an interview of <a href="https://mastodon.social/@rileytestut">Riley Testut</a> about <a href="https://www.theverge.com/24150467/delta-emulator-apple-app-voice-notes-ai-vergecast">Delta’s 10-year journey to the top of the App Store</a> on the latest episode of the <a href="https://www.theverge.com/the-vergecast">VergeCast</a>.</p>
<p>To distribute <a href="https://apps.apple.com/us/app/delta-game-emulator/id1048524688">Delta</a> Riley went through the effort of creating an alternative App Store, <a href="https://altstore.io">AltStore</a>. AlStore on the iPhone which is now <a href="https://www.apple.com/newsroom/2024/01/apple-announces-changes-to-ios-safari-and-the-app-store-in-the-european-union/">officially supported by Apple</a> as of iOS<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> 17.4 is made possible thanks to EU regulation.</p>
<p>Riley&rsquo;s perseverance, ingeniously, courage and resolve are commendable. Alongside <a href="https://shanegillio.github.io">Shane Gill</a> they accomplished more than I could ever do with <a href="https://qnoid.com/software-engineer/#windmill">Windmill</a>.</p>
<p>I tip my hat to you both 🎩.<br>
Well fucking done.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://mjtsai.com/blog/2019/08/08/windmill-for-iphone-rejected-from-the-app-store/">Windmill for iPhone Rejected From the App Store</a></li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Soon on <a href="https://ec.europa.eu/commission/presscorner/detail/en/IP_24_2363">iPadOS</a> too.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Tue, 07 May 2024 18:00:04 +0100</pubDate>
      </item>
      <item>
        <title>Debugging Closed Source Code</title>
        <link>https://qnoid.com/2024/04/11/debugging-closed-source-code.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2024/04/11/debugging-closed-source-code.html</guid>
        <description><![CDATA[<p>NSLondon kindly offered me a slot to talk about a whodunnit mystery at <a href="https://www.meetup.com/nslondon/events/299928914/">NSLondon 2024.2</a>.</p>
<p>I have been absent from the developer scene in years, cause life! I had a great time and got a buzz out of giving this talk. My favourite moment was when people clapped at the big reveal! Thank you! It was good to see some familiar faces from back in the NSConf<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> days 👋🏽.</p>
<p>I want to give a special shout out to <a href="https://bitsplitting.org">Daniel Jalkut</a> who gave a talk at NSConf (sometime between 2013 and 2015) where he went on to debug Mail.app. Daniel<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> was the first one to talk about frames and registers that I had come across. He was an inspiration. I hope this talk can act as an inspiration to others!</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/p60VcwlvwY8" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<figure>
<a class="border" href="/software-engineer/talks/a_whodunnit_mystery.pdf" download= a_whodunnit_mystery.pdf> Slides </a></figure>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-1.html#main">How to debug a &ldquo;class JKserializer is implemented in both&rdquo; case (Part 1)</a></li>
<li><a href="https://qnoid.com/2013/06/08/Sound-Debugging.html#main">Sound Debugging</a></li>
</ul>
<h2 id="references">References</h2>
<ul>
<li><a href="https://developer.apple.com/forums/thread/729071">DateFormatter, fixed-format dates and iOS Simulator</a></li>
<li><a href="https://developer.apple.com/documentation/xcode/setting-breakpoints-to-pause-your-running-app#Pause-on-a-symbol-outside-your-code">Pause on a symbol outside your code</a></li>
<li><a href="https://developer.apple.com/videos/play/wwdc2022/110370/">Debug Swift debugging with LLDB</a></li>
<li><a href="https://developer.apple.com/documentation/objectivec/1456712-objc_msgsend">Objective-C Runtime/objc_msgSend</a></li>
<li><a href="https://releases.llvm.org/14.0.0/tools/clang/docs">Clang 14.0.0 documentation</a></li>
<li><a href="https://lldb.llvm.org/man/lldb.html">lldb – The Debugger</a></li>
<li><a href="https://math.hws.edu/eck/cs220/f22/registers.html">Registers</a></li>
<li><a href="https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ProgrammingWithObjectiveC/CustomizingExistingClasses/CustomizingExistingClasses.html">Customizing Existing Classes, Programming with Objective-C</a></li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Scotty if you are reading this, I miss NSConf!&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>Check out his apps at <a href="https://redsweater.com">redsweater</a>&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Thu, 11 Apr 2024 10:42:39 +0100</pubDate>
      </item>
      <item>
        <title>A decade of progress in finance is only the beginning</title>
        <link>https://qnoid.com/2023/06/25/A-decade-of-progress-in-finance-is-only-the-beginning.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2023/06/25/A-decade-of-progress-in-finance-is-only-the-beginning.html</guid>
        <description><![CDATA[<p>Ever since coming to the UK, first time in 1998 as a student, there has always been a need to exchange currencies and send money across borders. Back then, my mom would have to convert Greek Drachma<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> and wire them to a UK bank account as British Sterling. In the nineties, making a bank transfer from one country to another, in a different currency was an opaque process, associated with high costs with very little transparency on the fees and how it all worked. The cost was tens of pounds (thousands of drachmas) and it would take days for the transfer to complete. Banks were pretty much responsible and in control of currency exchanges and money transfers in a market with a dominant position.</p>
<p>As late as 2010, about 10 years later and the introduction of the Euro in Greece, Sterling in the UK, transferring money to a Greek Euro bank account would still cost tends of pounds and take days to complete. The only difference is that going to a branch wasn&rsquo;t required anymore. You could setup, make and monitor the progress of a transfer all with the power of the internet, using mobile or web banking. Roughly, you would come to expect the following in terms of the time taken and associated cost:</p>
<ul>
<li>£XX (<strong>tens</strong>) of pounds in fees from a UK bank to &ldquo;convert and make&rdquo; a transfer</li>
<li>€X of euros in fees from a Greek bank account to &ldquo;accept&rdquo; the transfer</li>
<li>X <strong>days</strong> for the transfer to complete and the money to become &ldquo;available&rdquo; in your account</li>
</ul>
<p>Say, to send £1000, you would have to pay £30 to a UK bank, €5 to a Greek bank and wait 3 <strong>business</strong> days for the money to become available. It was widely accepted and understood that a transfer on a Friday evening, could mean your money was outside of your control and unavailable until Tuesday.</p>
<p>Over the last 10 years there&rsquo;s been many changes in banking that albeit slowly, have lead to a steady overhaul of the banking system over time. Changes to KYC<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>, the introduction of the E-Money Directive<sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup>, SEPA<sup id="fnref:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup>, the Cross-border Payments Regulation and the migration to IBAN for bank accounts to name a few.</p>
<p>In my opinion, these changes in the regulatory framework is what eventually forced banks and new participants in the market to innovate using technology.</p>
<p>To the point where, today, I can send £1000 from a UK bank account with a <strong>total cost of £4.49</strong> and have the money available <strong>within seconds</strong> to my Greek account, even <strong>on a Sunday</strong>. I believe this is only the beginning of the banking transformation and one factor that can play a role and have a knock-on effect on how we think of money/currency, what is the role of a bank account, where/how we get paid/credit, how a tax residency is defined.</p>
<p>As someone in tech and with some experience working in fintech<sup id="fnref:5"><a href="#fn:5" class="footnote-ref" role="doc-noteref">5</a></sup>, I find this prospect more exciting and the environment ripe for the next innovation in banking/finance. Keep in mind that technology followed regulation reform that paved the way; not the other way around.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p><a href="https://en.wikipedia.org/wiki/Modern_drachma">https://en.wikipedia.org/wiki/Modern_drachma</a>&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p><a href="https://en.wikipedia.org/wiki/Know_your_customer">https://en.wikipedia.org/wiki/Know_your_customer</a>&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p><a href="https://en.wikipedia.org/wiki/E-Money_Directive">https://en.wikipedia.org/wiki/E-Money_Directive</a>&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:4">
<p><a href="https://en.wikipedia.org/wiki/Single_Euro_Payments_Area">https://en.wikipedia.org/wiki/Single_Euro_Payments_Area</a>&#160;<a href="#fnref:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:5">
<p><a href="https://en.wikipedia.org/wiki/Fintech">https://en.wikipedia.org/wiki/Fintech</a>&#160;<a href="#fnref:5" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Sun, 25 Jun 2023 11:15:47 +0100</pubDate>
      </item>
      <item>
        <title>Back in London</title>
        <link>https://qnoid.com/2022/05/20/back-in-london.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2022/05/20/back-in-london.html</guid>
        <description><![CDATA[<p>It&rsquo;s almost been 5 years since I left. Yet it feels like I never did. I am getting goosebumps writing this. The Smiths is playing on Spotify. Take me home tonight. Take me out tonight. Because I want to see people and I want to see life.</p>
<p>I see the light UK drizzle outside. Tears of happiness are running down my eyes. I can&rsquo;t believe I&rsquo;m back. I made it. I&rsquo;m back. Back in my old flat. That&rsquo;s a funny story. With my old furniture back. A bit rundown but the same. Like my body.</p>
<p>I had no idea. I would have never imagined. I wouldn&rsquo;t believe you if you told me. Five years ago, I was running away. Now I&rsquo;ve run home. It&rsquo;s been less than a week yet it feels like a month. Feels like I&rsquo;ve never left. I am fortunate. I know I am. I am also a survivor. I can&rsquo;t believe I&rsquo;ve survived this but I did.</p>
<p>In these past 5 years I found my father. In these past 5 years, I did years of therapy to get to the bottom of my <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">anxiety and depression</a>. In these past 5 years I got to know myself better that ever before.</p>
<p>I am glad I did this. Even though I didn&rsquo;t know I had to. I neither had the insight nor the awareness 5 years ago. Imagine having to &ldquo;put on hold&rdquo; your life as it is today and go away for 5 years to work on yourself, pay your dues, pay back <a href="https://qnoid.com/2020/04/30/Debt-and-borrowed-time.html#main">the debt from the time you&rsquo;ve borrowed</a> to keep going. I was in my late thirties. I now am in my early forties. I feel good! I feel good because of how much I&rsquo;ve grown. I feel good knowing this is behind me.</p>
<p>As I was getting ready to leave Athens, I met with a friend. He said to me, &ldquo;This is the most relaxed I&rsquo;ve ever seen you as you are about to pack up and leave again.&rdquo;</p>
<p>I am not running away anymore.</p>
<p><img src="/static/2022/05/20/IMG_1462.jpeg" alt=""></p>
]]></description>
        <pubDate>Fri, 20 May 2022 10:31:44 +0100</pubDate>
      </item>
      <item>
        <title>A change is gonna come</title>
        <link>https://qnoid.com/2022/05/02/change.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2022/05/02/change.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/cEXhZ8PwM-Y" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p><img src="/static/2022/05/02/67309183180__5CF5D0C3-76E7-456E-A7B9-F81B91FE2434.fullsizerender.jpeg" alt=""></p>
]]></description>
        <pubDate>Mon, 02 May 2022 15:19:51 +0300</pubDate>
      </item>
      <item>
        <title>Interview on the CERN Alumni Podcast</title>
        <link>https://qnoid.com/2021/03/26/cern.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2021/03/26/cern.html</guid>
        <description><![CDATA[<p><a href="https://soundcloud.com/qnoid/cern-alumnicast-interview-part-1/s-PJV29G7msWM">CERN AlumniCast - Interview (Part 1)</a> with <a href="https://alumni.cern/users/701093">Rachel Bray</a>.</p>
<p>Rachel asked me to give an interview as an alumni about my experience arriving and working at CERN.</p>
<p>We talk about the circumstances that lead to my arrival at CERN, my life there as a technical student and how CERN defined my career trajectory for the next 10 years. Also, the great people that supported me and taught me valuable lessons at the age of 21 that shaped me as a professional.</p>
<p>Rachel was really accommodating and asked questions that dug deep into the human psyche. It&rsquo;s a story I was happy to share and I would like to thank Rachel for giving me the opportunity to do so.</p>
]]></description>
        <pubDate>Fri, 26 Mar 2021 08:46:47 +0200</pubDate>
      </item>
      <item>
        <title>Developing Applications for iOS using SwiftUI</title>
        <link>https://qnoid.com/2021/02/11/Developing-Applications-for-iOS-using-SwiftUI.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2021/02/11/Developing-Applications-for-iOS-using-SwiftUI.html</guid>
        <description><![CDATA[<p>Stanford has shared the <a href="https://cs193p.sites.stanford.edu">Spring 2020 course</a> online for free. You can find lecture videos, presentation slides and assignments that will teach you the basics and guide you on your way to becoming an iPhone developer. This is how I started as an <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">Apple Developer</a> back in 2009.</p>
<p>Know that doing the course is only the beginning. You will still have to dedicate time and effort practicing what you have learned. Building <a href="/software-engineer/#verylargebox">verylargebox</a> as a side project was what helped me build confidence and accumulate experience.</p>
<hr>
<p>Developing for mobile was fast becoming an essential part of your business strategy at the time. The iPhone was still in its infancy in 2011 so not much experience was needed or expected. It might be a higher bar to clear today but demand, as far as I can tell, is still high. As a seasoned software engineer it was easier for me to get a job and get started so keep that in mind.</p>
<p>If you are young and only just starting out as a software engineer, see if you can get a some work experience through school. Alternatively, reach out to companies that do iOS and ask whether they offer any short term internships.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://aiesec.org">AIESEC</a> - &ldquo;AIESEC is a global platform for young people to develop their leadership potential through international internships and volunteer opportunities.&rdquo;</li>
</ul>
]]></description>
        <pubDate>Thu, 11 Feb 2021 08:18:23 +0200</pubDate>
      </item>
      <item>
        <title>To live without fear</title>
        <link>https://qnoid.com/2021/01/30/To-live-without-fear.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2021/01/30/To-live-without-fear.html</guid>
        <description><![CDATA[<p>In May of 2015 I visited a long time friend in Israel. It was my first time there. Our friendship dates back to the late 90s where we studied together at University. All these years, he kept asking me to visit. I was nervous. Israel had a long history of conflict and turmoil.</p>
<p>I finally took the plunge and booked a flight. I stayed for a week and I remember feeling unsettled at least for the first few days. Anticipating that something bad was going to happen at any moment. At the same time, I was impressed by the industrial development I could bear witness to.</p>
<p>This wasn&rsquo;t a country paralysed in fear. People weren&rsquo;t just dragging their feet. They where studying, working, falling in love, raising children, building and decorating their houses, going for coffee, surfing at the sea. They celebrated life, making the most of it.</p>
<p>In my head I couldn&rsquo;t reconcile the two. How can people, under constant threat, live life seemingly carefree?</p>
<p>&ndash; &ldquo;Are you not afraid?&rdquo; I asked.<br>
&ndash; &ldquo;To live in fear is to not live your life.&rdquo; Eli responded.</p>
<p>It was a profound statement to hear back then. Still, I believe there is more to what Eli said. <strong>To live without fear is to live life in solidarity.</strong> It&rsquo;s ok to be afraid; you are not alone.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2020/05/10/endurance.html#main">Fear, support and endurance in the face of adversity</a> - “Sometimes, comfort found in your presence is what people look for as they endure hardship.”</li>
<li><a href="https://qnoid.com/2019/08/13/Anxiety-Looks-Different-in-Men.html#main">Anxiety looks different in men</a> - “When a man explodes in anger over something seemingly insignificant, he may appear like just a jerk. But he could be anxious.”</li>
</ul>
]]></description>
        <pubDate>Sat, 30 Jan 2021 14:59:56 +0200</pubDate>
      </item>
      <item>
        <title>Two more examples of Encoding and Decoding Custom Types in Swift</title>
        <link>https://qnoid.com/2021/01/20/codable.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2021/01/20/codable.html</guid>
        <description><![CDATA[<h2 id="overview">Overview</h2>
<p>Swift provides a Foundation API to serialise from and to JSON &ldquo;<em>by implementing the <code>Encodable</code> and <code>Decodable</code> protocols on your custom types</em>&rdquo;.</p>
<p>The team at Apple has also written a great article about <a href="https://developer.apple.com/documentation/foundation/archives_and_serialization/encoding_and_decoding_custom_types">Encoding and Decoding Custom Types</a> that provides a few examples to get you started and a few ones that require &ldquo;<em>a custom implementation of Encodable and Decodable</em>&rdquo;. I want to add two more examples that may not be immediately obvious after you read the article.</p>
<p>Both examples build upon the knowledge you have on encoding and decoding custom types from the article above. So consider that a prerequisite. The first one shows how to decode only part of a JSON document. This can be useful when working with an API where you are only interested in <strong>part of the response</strong>.</p>
<p>The second example is useful typically in an API that uses JSON to encode a &ldquo;data&rdquo; or &ldquo;error&rdquo; response. In this case, the HTTP response code is typically <code>200 OK</code> yet the actual JSON response communicates whether the request has been successful, returning the data requested or unsuccessful in which case an error is returned in the JSON payload.</p>
<h2 id="decode-only-part-of-a-json-document">Decode only part of a JSON document</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JSON" data-lang="JSON"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;user&#34;</span><span class="p">:</span> <span class="s2">&#34;qnoid&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;created_at&#34;</span><span class="p">:</span> <span class="s2">&#34;2021-01-19T18:47:01+0200&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;text_entries&#34;</span><span class="p">:</span> <span class="p">[{</span>
</span></span><span class="line"><span class="cl">      <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;Hello!&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;¡Hola!&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>In the example above, we are only interested in the text entries returned and have no need for the rest of the data. Consider an <code>Entry</code> type describing each text entry that stores the &ldquo;text&rdquo; and a <code>TextEntries</code> type that holds the Array of entries:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">Entry</span><span class="p">:</span> <span class="n">Codable</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">text</span><span class="p">:</span> <span class="nb">String</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">TextEntries</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">enum</span> <span class="nc">Key</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">CodingKey</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">case</span> <span class="n">entries</span> <span class="p">=</span> <span class="s">&#34;text_entries&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">values</span><span class="p">:</span> <span class="p">[</span><span class="n">Entry</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>In the example below, the <code>TextEntries</code> type is extended to conform to the <code>Decodable</code> protocol by implementing its required initialiser, <code>init(from:)</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">extension</span> <span class="nc">TextEntries</span><span class="p">:</span> <span class="n">Decodable</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">init</span><span class="p">(</span><span class="n">from</span> <span class="n">decoder</span><span class="p">:</span> <span class="n">Decoder</span><span class="p">)</span> <span class="kr">throws</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">response</span> <span class="p">=</span> <span class="k">try</span> <span class="n">decoder</span><span class="p">.</span><span class="n">container</span><span class="p">(</span><span class="n">keyedBy</span><span class="p">:</span> <span class="n">Key</span><span class="p">.</span><span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="kd">var</span> <span class="nv">entries</span> <span class="p">=</span> <span class="k">try</span> <span class="n">response</span><span class="p">.</span><span class="n">nestedUnkeyedContainer</span><span class="p">(</span><span class="n">forKey</span><span class="p">:</span> <span class="p">.</span><span class="n">entries</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kd">var</span> <span class="nv">values</span> <span class="p">=</span> <span class="p">[</span><span class="n">Entry</span><span class="p">]()</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="o">!</span><span class="n">entries</span><span class="p">.</span><span class="n">isAtEnd</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nv">entry</span> <span class="p">=</span> <span class="k">try</span> <span class="n">entries</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="n">Entry</span><span class="p">.</span><span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">values</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">entry</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">values</span> <span class="p">=</span> <span class="n">values</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The <code>TextEntries</code> type can now be decoded using the <code>JSONDecoder</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">entries</span> <span class="p">=</span> <span class="k">try</span> <span class="n">JSONDecoder</span><span class="p">().</span><span class="n">decode</span><span class="p">(</span><span class="n">TextEntries</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">from</span><span class="p">:</span> <span class="n">data</span><span class="p">)</span>
</span></span></code></pre></div><p>Let&rsquo;s dymistify. <code>JSONDecoder</code> uses the initialiser in the <code>TextEntries</code> type to decode the data. In our case, the root object in the JSON is a collection of name/value pairs <sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>. The <code>try decoder.container(keyedBy: Key.self)</code> &ldquo;<em><a href="https://developer.apple.com/documentation/swift/decoder/2892621-container">‌returns the data stored in this decoder as represented in a container keyed by the given key type</a>.</em>&rdquo;. In simple terms, the code will try to interpret the root object as a dictionary where its keys are typed by the <code>TextEntries.Key</code> enum type. The <code>TextEntries.Key</code> defines only one key present, namely the case <code>entries</code> (&ldquo;text_entries&rdquo; in JSON), as this is the only one we are interested in. The <code>response</code> variable represents that dictionary.</p>
<p>Next, we want to extract the array of text entries. Hence the call to <a href="https://developer.apple.com/documentation/swift/keyeddecodingcontainerprotocol/2894405-nestedunkeyedcontainer"><code>nestedUnkeyedContainer(forKey:)</code></a> which returns an <a href="https://developer.apple.com/documentation/swift/unkeyeddecodingcontainer"><code>UnkeyedDecodingContainer</code></a> type. You can think of the <code>UnkeyedDecodingContainer</code> as an iterator where every call to <code>decode()</code> decodes the type at the current index, starting at 0, then increments the index. When the iterator is exhausted, <code>isAtEnd</code> will return false.</p>
<p>At the end of the initialiser, the <code>values</code> are initialised with every entry in the &ldquo;text_entries&rdquo; Array and a <code>TextEntries</code> instance is returned.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="n">entries</span><span class="p">.</span><span class="n">values</span><span class="p">.</span><span class="bp">map</span> <span class="p">{</span> <span class="n">entry</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">    <span class="n">entry</span><span class="p">.</span><span class="n">text</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h2 id="decode-a-custom-successerror-json-response">Decode a custom success/error JSON response</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JSON" data-lang="JSON"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;success&#34;</span><span class="p">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;contents&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;text_entries&#34;</span><span class="p">:</span> <span class="p">[{</span>
</span></span><span class="line"><span class="cl">        <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;Hello!&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="p">},</span>
</span></span><span class="line"><span class="cl">      <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nt">&#34;text&#34;</span><span class="p">:</span> <span class="s2">&#34;¡Hola!&#34;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">      <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-JSON" data-lang="JSON"><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;success&#34;</span><span class="p">:</span> <span class="kc">false</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nt">&#34;error&#34;</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;code&#34;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">    <span class="nt">&#34;message&#34;</span><span class="p">:</span> <span class="s2">&#34;User not found&#34;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>In this case you have two possible JSON responses thus the decision as to which one to decode must be done at runtime. One is considered a success with the &ldquo;contents&rdquo; (or &ldquo;payload&rdquo;) holding the data you are interested in. The other one is a failure that includes an &ldquo;error&rdquo;. The <a href="https://developer.apple.com/documentation/swift/result"><code>Result</code></a> type is ideal to describe this &ldquo;exclusive or&rdquo; truth and the <a href="https://developer.apple.com/documentation/swift/result/3139399-init"><code>init(catching:)</code></a> initialiser is fitting in trying to decode a successful response or throw the returned error in case of a failure. Let&rsquo;s see how that looks in practice.</p>
<p>Consider the <code>Error</code> type that stores the “code” and &ldquo;message&rdquo;:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">Error</span><span class="p">:</span> <span class="n">Codable</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">enum</span> <span class="nc">Key</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">CodingKey</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">case</span> <span class="n">error</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">code</span><span class="p">:</span> <span class="nb">Int</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">message</span><span class="p">:</span> <span class="nb">String</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">init</span><span class="p">(</span><span class="n">from</span> <span class="n">decoder</span><span class="p">:</span> <span class="n">Decoder</span><span class="p">)</span> <span class="kr">throws</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">response</span> <span class="p">=</span> <span class="k">try</span> <span class="n">decoder</span><span class="p">.</span><span class="n">container</span><span class="p">(</span><span class="n">keyedBy</span><span class="p">:</span> <span class="n">Key</span><span class="p">.</span><span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">contents</span> <span class="p">=</span> <span class="k">try</span> <span class="n">response</span><span class="p">.</span><span class="n">nestedContainer</span><span class="p">(</span><span class="n">keyedBy</span><span class="p">:</span> <span class="n">CodingKeys</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">forKey</span><span class="p">:</span> <span class="p">.</span><span class="n">error</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">code</span> <span class="p">=</span> <span class="k">try</span> <span class="n">contents</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="nb">Int</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">forKey</span><span class="p">:</span> <span class="p">.</span><span class="n">code</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">message</span> <span class="p">=</span> <span class="k">try</span> <span class="n">contents</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="nb">String</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">forKey</span><span class="p">:</span> <span class="p">.</span><span class="n">message</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>The <code>Error</code> type can now be decoded using the <code>JSONDecoder</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">error</span> <span class="p">=</span> <span class="k">try</span> <span class="n">JSONDecoder</span><span class="p">().</span><span class="n">decode</span><span class="p">(</span><span class="n">Error</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">from</span><span class="p">:</span> <span class="n">data</span><span class="p">)</span>
</span></span></code></pre></div><p>Now consider the <code>Contents</code> type with an &ldquo;entries&rdquo; property of type <code>TextEntries</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">Contents</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">enum</span> <span class="nc">Key</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">CodingKey</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">case</span> <span class="n">contents</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">enum</span> <span class="nc">CodingKeys</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">CodingKey</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">case</span> <span class="n">entries</span> <span class="p">=</span> <span class="s">&#34;text_entries&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">entries</span><span class="p">:</span> <span class="n">TextEntries</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">extension</span> <span class="nc">Contents</span><span class="p">:</span> <span class="n">Decodable</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">init</span><span class="p">(</span><span class="n">from</span> <span class="n">decoder</span><span class="p">:</span> <span class="n">Decoder</span><span class="p">)</span> <span class="kr">throws</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">response</span> <span class="p">=</span> <span class="k">try</span> <span class="n">decoder</span><span class="p">.</span><span class="n">container</span><span class="p">(</span><span class="n">keyedBy</span><span class="p">:</span> <span class="n">Key</span><span class="p">.</span><span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">contents</span> <span class="p">=</span> <span class="k">try</span> <span class="n">response</span><span class="p">.</span><span class="n">nestedContainer</span><span class="p">(</span><span class="n">keyedBy</span><span class="p">:</span> <span class="n">CodingKeys</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">forKey</span><span class="p">:</span> <span class="p">.</span><span class="n">contents</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">entries</span> <span class="p">=</span> <span class="k">try</span> <span class="n">contents</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="n">TextEntries</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">forKey</span><span class="p">:</span> <span class="p">.</span><span class="n">entries</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>As a reminder, the <code>Contents</code> is at the root object in the JSON data. First, we obtain the container as keyed by the &ldquo;contents&rdquo; key, followed by the &ldquo;text_entries&rdquo; as the <code>TextEntries</code> type:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">TextEntries</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">values</span><span class="p">:</span> <span class="p">[</span><span class="n">Entry</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">extension</span> <span class="nc">TextEntries</span><span class="p">:</span> <span class="n">Decodable</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">init</span><span class="p">(</span><span class="n">from</span> <span class="n">decoder</span><span class="p">:</span> <span class="n">Decoder</span><span class="p">)</span> <span class="kr">throws</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">var</span> <span class="nv">entries</span> <span class="p">=</span> <span class="k">try</span> <span class="n">decoder</span><span class="p">.</span><span class="n">unkeyedContainer</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kd">var</span> <span class="nv">values</span> <span class="p">=</span> <span class="p">[</span><span class="n">Entry</span><span class="p">]()</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="o">!</span><span class="n">entries</span><span class="p">.</span><span class="n">isAtEnd</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nv">entry</span> <span class="p">=</span> <span class="k">try</span> <span class="n">entries</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="n">Entry</span><span class="p">.</span><span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">values</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">entry</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">values</span> <span class="p">=</span> <span class="n">values</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Notice how in this case the <code>TextEntries</code> decoding is part of the <code>Contents</code> decoding hence the call to <code>unkeyedContainer()</code> as this is done under the &ldquo;text_entries&rdquo; key<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>. The <code>Contents</code> type can now be decoded using the <code>JSONDecoder</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">contents</span> <span class="p">=</span> <span class="k">try</span> <span class="n">JSONDecoder</span><span class="p">().</span><span class="n">decode</span><span class="p">(</span><span class="n">Contents</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">from</span><span class="p">:</span> <span class="n">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">contents</span><span class="p">.</span><span class="n">entries</span><span class="p">.</span><span class="n">values</span><span class="p">.</span><span class="bp">map</span> <span class="p">{</span> <span class="n">entry</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">    <span class="n">entry</span><span class="p">.</span><span class="n">text</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>Before we can write the closure expected by <a href="https://developer.apple.com/documentation/swift/result/3139399-init"><code>init(catching:)</code></a> for the <code>Result</code> type, the <code>Error</code> type must be declared as a <code>Swift.Error</code> that we can <code>throw</code>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">extension</span> <span class="nc">Error</span><span class="p">:</span> <span class="n">Swift</span><span class="p">.</span><span class="n">Error</span><span class="p">,</span> <span class="n">CustomNSError</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">public</span> <span class="kd">static</span> <span class="kd">var</span> <span class="nv">errorDomain</span><span class="p">:</span> <span class="nb">String</span> <span class="p">=</span> <span class="s">&#34;com.qnoid&#34;</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nv">errorCode</span><span class="p">:</span> <span class="nb">Int</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">code</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nv">errorUserInfo</span><span class="p">:</span> <span class="p">[</span><span class="nb">String</span> <span class="p">:</span> <span class="nb">Any</span><span class="p">]</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="n">NSLocalizedDescriptionKey</span> <span class="p">:</span> <span class="n">message</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>With both <code>Content</code> and <code>Error</code> types defined, here is how we can now construct a <code>Result</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">result</span> <span class="p">=</span> <span class="n">Result</span><span class="p">&lt;</span><span class="n">Contents</span><span class="p">,</span> <span class="n">Swift</span><span class="p">.</span><span class="n">Error</span><span class="p">&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">do</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="k">try</span> <span class="n">JSONDecoder</span><span class="p">().</span><span class="n">decode</span><span class="p">(</span><span class="n">Contents</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">from</span><span class="p">:</span> <span class="n">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">catch</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">//log `error` in the catch block</span>
</span></span><span class="line"><span class="cl">            <span class="k">throw</span> <span class="k">try</span> <span class="n">JSONDecoder</span><span class="p">().</span><span class="n">decode</span><span class="p">(</span><span class="n">Error</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="n">from</span><span class="p">:</span> <span class="n">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span></code></pre></div><p>Effectively, the closure will try to decode the <code>Contents</code> type. In case that fails, there is an assumption<sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> that instead this is a failure response and the included <code>Error</code> is thrown. Keep in mind that the <code>try</code> to decode the <code>Error</code> might fail, in which case the <code>Result</code> type will throw the <code>Swift.Error</code> as thrown by the <code>decode(from:)</code> function.</p>
<p>This is the calling code:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="k">do</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">contents</span> <span class="p">=</span> <span class="k">try</span> <span class="n">result</span><span class="p">.</span><span class="kr">get</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">contents</span><span class="p">.</span><span class="n">entries</span><span class="p">.</span><span class="n">values</span><span class="p">.</span><span class="bp">map</span> <span class="p">{</span> <span class="n">entry</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">        <span class="n">entry</span><span class="p">.</span><span class="n">text</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="k">catch</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">error</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><h2 id="resources">Resources</h2>
<ul>
<li><a href="/static/2021/01/20/codable.zip"><code>codable.playground</code></a></li>
</ul>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://useyourloaf.com/blog/using-swift-result-and-flatmap/">Using Swift Result and flatMap</a> &ldquo;Create A Result From A Throwing Expression&rdquo;</li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>As opposed to an ordered list of values.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>This is a good hint that serialising a type is highly coupled with the decoding algorithm itself and should take into consideration.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>Even though, this contract is well defined, consider logging the error thrown instead of silently ignoring it.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Wed, 20 Jan 2021 19:39:07 +0200</pubDate>
      </item>
      <item>
        <title>People, teams, creativity and innovation</title>
        <link>https://qnoid.com/2021/01/04/teams.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2021/01/04/teams.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/aCNKUArd7Q4" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>I watched a few documentaries on the history of video games and the rise of an industry.</p>
<ul>
<li><a href="https://www.imdb.com/title/tt11916218">Insert Coin</a> by Joshua Tsui.</li>
<li><a href="https://www.imdb.com/title/tt5843300">From Bedrooms to Billions: The Playstation Revolution</a> by Nicola and Anthony Caulfield.</li>
<li><a href="https://www.imdb.com/title/tt4603210">From Bedrooms to Billions: The Amiga Years!</a> by Nicola and Anthony Caulfield.</li>
<li><a href="https://www.imdb.com/title/tt2404567">From Bedrooms to Billions</a> by Nicola and Anthony Caulfield.</li>
<li><a href="https://www.imdb.com/title/tt12759400/">High Score</a> by William Acks, France Costrel, Sam LaCroix and Melissa Wood.</li>
</ul>
<hr>
<p>I am a sucker for these types of documentaries. Documentaries that provide a retrospective, hearing the stories from the people that made history. Nostalgia definitely played a part in my enjoyment as well. I grew up in the 80s and the 90s so I saw the video game industry unfold before my eyes.</p>
<p>What I find most fascinating is how people came together and how their creativity flourished. I wish I could know more about both the personal and societal circumstances that lead to that. Granted, back then the boom of personal computing and the video game industry was just getting started. Still, what I want to know is how people had the time, support, resources, attitude and appetite to take risks and pursue their dreams?</p>
<hr>
<p>The gaming industry hasn&rsquo;t stopped as far as I can tell. My guess is that there are way more indie developers now. On the other end of the spectrum, video game productions are growing bigger and bigger. There doesn&rsquo;t seem to be a shortage in diversity and development of video games.</p>
<p>The rest of the tech scene looks and feels much different. You have &ldquo;indie hackers&rdquo; chasing monthly recurring revenue. Startups thinking of becoming the next billion dollar company. Venture Capitalists betting money left and right playing the odds of winning back tenfold on an acquisition or a public listing.</p>
<hr>
<p>We live in a world that is more connected, technology is more accessible, the bar to entry for manufacturing and production is lower yet Facebook, Apple, Amazon, Microsoft and Google pretty much dominate.</p>
<p>It seems like we have all become numb, waiting for the next big tech event, year after year to hear about the &ldquo;new innovations&rdquo; and latest products.</p>
<p>What happened to the tinkerers, creatives, rebels and dreamers in the tech industry? What will it take to create a movement? I&rsquo;m dying to be part of one right now.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://www.bloomberg.com/news/articles/2020-11-09/game-prices-go-up-to-70-the-first-increase-in-15-years">Video Game Prices Are Going Up for the First Time in 15 Years</a></li>
<li><a href="https://www.polygon.com/2020/12/11/22170468/cyberpunk-2077-sales-revenue-cd-projekt">Cyberpunk 2077 has already recouped its development costs, CD Projekt says</a></li>
<li><a href="https://linktr.ee/insertcoindoc">Insert Coin</a> - Where to watch Insert Coin</li>
<li><a href="https://rebellion.com/films/">From Bedrooms to Billions</a> - The studio behind the &ldquo;From Bedrooms to Billions&rdquo; films.</li>
<li><a href="https://www.netflix.com/title/81019087">High Score</a> - On Netflix</li>
<li><a href="https://www.youtube.com/watch?v=Bp8owQCxCUw">The Documentary Exploring Midway, Mortal Kombat &amp; NBA Jam - Noclip Podcast #44</a> - How I learned about the &ldquo;Insert Coin&rdquo; documentary</li>
<li><a href="https://www.polygon.com/features/2013/1/24/3754750/from-fatalities-to-flip-tricks-josh-tsuis-20-years-of-chicago-game">From fatalities to flip tricks: Josh Tsui&rsquo;s 20 years of Chicago game development</a></li>
<li><a href="https://www.patreon.com/noclip">Noclip</a> - Noclip is creating Video Game Documentaries</li>
<li><a href="https://www.relay.fm/remaster">Remaster</a> - A show about playing games and making games. Shahid Kamal Ahmad who appears on the Playstation Revolution documentary is on it. I love listening to this show.</li>
</ul>
]]></description>
        <pubDate>Mon, 04 Jan 2021 16:19:24 +0200</pubDate>
      </item>
      <item>
        <title>Bravery</title>
        <link>https://qnoid.com/2020/12/22/Bravery.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/12/22/Bravery.html</guid>
        <description><![CDATA[<p>Bravery is looking despair in the eye. Feeling hopeless yet not letting fear overcome you. Knowing that there is nothing you can do for the people you love and care about yet still facing that fear head on. Even if that is merely not collapsing under that enormous pressure.</p>
]]></description>
        <pubDate>Tue, 22 Dec 2020 17:20:19 +0200</pubDate>
      </item>
      <item>
        <title>What it takes</title>
        <link>https://qnoid.com/2020/11/26/What-it-takes.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/11/26/What-it-takes.html</guid>
        <description><![CDATA[<p>The music that YANNI produces has this amazing quality of moving me to tears, getting me pumped, making me melancholic and inspiring me. I have been listening to his music since the 90s and it still has the same effect on me.</p>
<p>Just recently I came across a Q&amp;A with Yanni at The Grammy Museum with journalist Steve Hochman at the Los Angeles, USA dated September 18, 2014. Here are a few things that stood out and spoke to me on personal level for different reasons. I do recommend that you watch the whole session. I have edited the responses for brevity down to the specifics that caught my attention.</p>
<p>On creativity and judgement. How the two don&rsquo;t go together.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/a9H8nM1D10U?start=734" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p><strong>Question:</strong> “Being a creative soul, is your mind constantly working? Are you able to quiet your mind and if so, how?”</p>
<blockquote>
<p>“You must not judge it. Judgement and creativity are opposites. They cannot exist together. Because as soon as you judge what’s coming in, you are outside looking at yourself and the creative moment has just ended.”</p>
</blockquote>
<p>On the importance of technology being accessible. How something as &ldquo;primitive&rdquo; as a short wave radio has technological merit and can be empowering as long as freedom of expression exists and there is no centralised control.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/a9H8nM1D10U?start=1160" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p><strong>Question:</strong> “You came from a place that was a fairly small town and you didn’t speak any english when you came here. I am curious what music you were exposed to there?”</p>
<blockquote>
<p>“We didn’t have a turntable or a tape recorder so the only music I could hear was on the radio. […] At night I would stay, I have a short wave radio and since I was living in southern Greece, I had access to all of the music from Italy, Rome I could hear all the stuff, all the way to north Africa, Morocco, Middle East and I would sit there and I would listen to all types of music.”</p>
</blockquote>
<p>On depression, the importance and significance to feel worthy as a human above all of your titles and achievements. His depression kicked in having reached new heights at the time. Performing <a href="https://en.wikipedia.org/wiki/Live_at_the_Acropolis">live at the Acropolis</a> and being the only westerner to perform at the <a href="https://en.wikipedia.org/wiki/Taj_Mahal">Taj Mahal</a> and the <a href="https://en.wikipedia.org/wiki/Forbidden_City">Forbidden City</a> at the time.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/a9H8nM1D10U?start=2610" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<blockquote>
<p>“There was a time in my life that I got lost. I went through a depression. […] I run home to Greece, stayed with my mom and dad and didn’t play the piano for a whole year. I did not touch it. I just wanted to know that I could be a normal human being. That there was a Yanni without the music.”</p>
</blockquote>
<p>On what every artist strives for and how time is the ultimate judge.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/a9H8nM1D10U?start=4475" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<blockquote>
<p>&ldquo;I was thinking, when I started writing music. What could I possibly do that could last more than a week. Maybe a year. People are going to hear a song then a year later they can go ok, next one, I can&rsquo;t hear this one anymore. Every artist strives for that. We all strive to create things that stand the test of time. [&hellip;] Ultimately, I will never know. I can&rsquo;t decide that. You have to decide that and the ultimate judge is time and I have nothing to do with it.&rdquo;</p>
</blockquote>
<p>I feel tired. Tired and lost.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://youtu.be/ju6O1Huh_6w">Yanni - No borders, no boundaries</a> - &ldquo;A 60-min documentary from PBS show,  narrated by Christopher Plummer. This is a unique film journal describing the extraordinary effort, purpose and achievement of Yanni&rsquo;s groundbreaking performances at Taj Mahal, India and Forbidden City, China, 1997.&rdquo;</li>
<li><a href="https://qnoid.com/2020/02/29/Coding.html#main">Coding</a> - “It’s like the 80s all over again, where you plug in a machine, and you can instantly start coding. I for one miss that.”</li>
<li><a href="https://qnoid.com/2020/04/28/coding-challenges.html#main">Coding challenges as part of an interview</a> - &ldquo;Nobody is watching me type and judging.&rdquo;</li>
<li><a href="https://qnoid.com/2020/07/30/windmill.html#main">Over a year since Apple gave me an ultimatum on Windmill</a> - &ldquo;I got especially emotional hearing an audio clip of a book seller pleading to Jeff Bezos to restore their business operations so that they could earn their livelihood.&rdquo;</li>
<li><a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">An Apple Developer for 10 years</a> - &ldquo;On a personal level, Windmill allows me to have freedom of expression, be creative and pursue excellence.&rdquo;</li>
</ul>
]]></description>
        <pubDate>Thu, 26 Nov 2020 16:06:24 +0200</pubDate>
      </item>
      <item>
        <title>Knowledge</title>
        <link>https://qnoid.com/2020/11/26/Knowledge.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/11/26/Knowledge.html</guid>
        <description><![CDATA[<p>One of the things I remember being told that has stood the test of time, goes back to my University years. It is about what is expected of you at each stage of your higher-level education and where the knowledge you achieve leads you.</p>
<p>First and foremost, to obtain a bachelor, you must <strong>prove that you can research</strong>. In other words, gather enough information on a subject that will help with your understanding of the problem.</p>
<blockquote>
<p>As a practitioner of software engineering, that could be doing research on design patterns and being able to write code in the one that is best suited for the task at hand.</p>
</blockquote>
<p>For a master&rsquo;s degree. Not only you have to research but also <strong>draw your own conclusions</strong> from that research. You have to be able to put two and two together. You need to prove that you have mastered the knowledge enough that you can wield it.</p>
<blockquote>
<p>Each individual knowledge of generics, asynchronous programming and http may not be enough. You will need to be able to combine them in a meaningful way to write an http client capable of sending requests, serialising responses and calling back with results.</p>
</blockquote>
<p>For a PhD, you have to read on existing research, draw your own conclusions, <strong>do your own research</strong> that leads to something new which in turn can be added back to the knowledge pile. That could be because you realise that existing knowledge is not enough. You need to break new ground.</p>
<blockquote>
<p>In a programming language that you use, that could be working on the interpreter or the compiler to introduce new features to the language that help you write code that previously wasn&rsquo;t possible.</p>
</blockquote>
<p>It is fair to say that each stage takes hard work. It certainly can&rsquo;t be done on a whim. It takes time to do research, evaluate, comprehend, apply and expand your knowledge.</p>
<p>This mantra of knowledge gathering and application isn&rsquo;t unique to a University study. It is very much true as part of a professional career too. It has been my guide to a professional conduct and in critically evaluating my place on a subject matter.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2016/01/14/We-need-to-raise-the-bar-on-software-development.html#main">We need to raise the bar on software development</a> &ldquo;Finally you, the developer, study, practice, challenge, repeat. Read books, attend courses. Get structured, formal education.&rdquo;</li>
</ul>
]]></description>
        <pubDate>Thu, 26 Nov 2020 13:32:13 +0200</pubDate>
      </item>
      <item>
        <title>Tired</title>
        <link>https://qnoid.com/2020/09/12/Tired.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/09/12/Tired.html</guid>
        <description><![CDATA[]]></description>
        <pubDate>Sat, 12 Sep 2020 14:19:53 +0300</pubDate>
      </item>
      <item>
        <title>Back to the 80s and the 90s</title>
        <link>https://qnoid.com/2020/09/11/Back-to-the-80s-and-the-90s.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/09/11/Back-to-the-80s-and-the-90s.html</guid>
        <description><![CDATA[<p>Between listening to <a href="https://club.poolside.fm/gtGc">Poolside FM</a><sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> and watching the <a href="https://rebellion.com/from-bedrooms-to-billions-the-playstation-revolution/">PlayStation Revolution</a> documentary it felt good to escape the constant news cycle, twitter<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> and coping with my mental struggle.</p>
<p>Everyone at Poolside FM, know that joining you at the pool has brought joy to my life.</p>
<p>Thank you.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>The fact that &ldquo;Poolside FM was conceived one awfully rainy summer in the Highlands of Scotland&rdquo; blows my mind.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>Please, someone, anyone, come up with a replacement to the current form of social media already.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Fri, 11 Sep 2020 14:40:36 +0300</pubDate>
      </item>
      <item>
        <title>Apple&#39;s letter to developers</title>
        <link>https://qnoid.com/2020/08/22/apple-letter-to-developers.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/08/22/apple-letter-to-developers.html</guid>
        <description><![CDATA[<p><em><strong>Paraphrasing</strong></em></p>
<blockquote>
<p>The App Store is not simply a marketplace &ndash; it is part of a larger bundle of tools, technologies and services that Apple makes available to developers to develop and create great applications for iPhone, iPad and other Apple products. We know <em><strong>you</strong></em> knows this. <em><strong>You have</strong></em> been a major beneficiary of this investment and support. <em><strong>You have</strong></em> made great use of Apple-provided tools, such as TestFlight, VOIP, Stickers, iCloud document storage, ARKit, Messages Extension, ReplayKit, and Push Notifications. To highlight one example, for years now, <em><strong>you have</strong></em> used Apple’s groundbreaking <em><strong>programming language</strong></em>, <em><strong>Swift</strong></em>. [&hellip;] Apple doesn’t charge separately for the use of <em><strong>Swift</strong></em> or any of the other tools that <em><strong>you have</strong></em> used to develop great <em><strong>apps</strong></em> on iOS.</p>
<p>Not only has Apple supplied tools and technologies for <em><strong>you</strong></em> to build <em><strong>your</strong></em> apps, but it also provided a marketplace—the App Store—to help make them a success. Because of the App Store, <em><strong>you have</strong></em> been able to get <em><strong>this app</strong></em> and other apps into the hands of millions instantly and at no cost, as Apple charges nothing upfront to distribute apps that are free to download. [&hellip;] Of course, <em><strong>you</strong></em> could not have achieved this success without great apps, but it nonetheless underscores the value Apple brings to developers like <em><strong>you</strong></em>.</p>
<p>Still, <em><strong>you have</strong></em> many ways to reach consumers, including through Android stores, PC-based platforms, consoles (Xbox, Nintendo, Play Station) and <em><strong>your</strong></em> very own app marketplace.</p>
<p>Apple has hundreds of thousands of developers distributing apps on the App Store, and Apple is proud that it offers them all, from the student in her living room to some of the largest companies in the world, the same terms and opportunities.</p>
<p>The App Store is not a public utility.</p>
<p>Sincerely,<br>
Apple</p>
</blockquote>
<p><a href="https://www.scribd.com/document/473210410/Email-exhibits-from-Epic-v-Apple">Exhibit E</a>, Email exhibits from Epic v. Apple.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2020/08/18/what-has-become-of-apple.html#main">What has become of Apple?</a></li>
<li><a href="https://qnoid.com/2020/07/30/windmill.html#main">Over a year since Apple gave me an ultimatum on Windmill</a></li>
<li><a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">An Apple Developer for 10 years</a></li>
</ul>
]]></description>
        <pubDate>Sat, 22 Aug 2020 13:10:08 +0300</pubDate>
      </item>
      <item>
        <title>Oh how far the apple has fallen from the tree</title>
        <link>https://qnoid.com/2020/08/18/apple-tree.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/08/18/apple-tree.html</guid>
        <description><![CDATA[<p><img src="/images/2020/08/18/IMG_2731.jpeg" alt=""></p>
]]></description>
        <pubDate>Tue, 18 Aug 2020 17:02:51 +0300</pubDate>
      </item>
      <item>
        <title>What has become of Apple?</title>
        <link>https://qnoid.com/2020/08/18/what-has-become-of-apple.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/08/18/what-has-become-of-apple.html</guid>
        <description><![CDATA[<p>At some point in the last few weeks the ability to run code on both an iPhone and an Apple TV I own has not been possible. In Apple Developer terms, Xcode fails to <a href="https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/Introduction/Introduction.html">codesign</a> with an error &ldquo;Signing for [project name] requires a development team. Select a development team in the Signing &amp; Capabilities editor.&rdquo;. Under &ldquo;Preferences&rdquo;, &ldquo;Accounts&rdquo;, I get a &ldquo;No Teams&rdquo; message for the Apple ID I use as an Apple Developer.</p>
<p><img src="/images/2020/08/18/accounts.png" alt=""></p>
<blockquote>
<p><a href="https://help.apple.com/xcode/mac/11.4/#/dev23aab79b4">Assign a project to a team, Xcode Help</a></p>
</blockquote>
<p>This issue went completely off the radar, for weeks, as I have been focused on writing a framework instead, hence never had the need to run code on a device. I reached out to Apple for help and 10 days later here is the gist from their response.</p>
<blockquote>
<p>I escalated your issue to the senior desk, and have been advised to tell you that Apple Developer Program Support only provides direct assistance to Developers that hold active Apple Developer Program memberships.</p>
</blockquote>
<p>Effectively Apple says it cannot help because I am not a paid member.</p>
<p>Leaving aside the fact that I had been an <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">Apple Developer for 10 years</a> until I stopped this year, since when does the &ldquo;I cannot run code I write on hardware I own&rdquo; started being a paid, active Apple Developer Program membership support ticket?</p>
<p>Apple may claim that all you need is &ldquo;just an Apple ID&rdquo; to &ldquo;access Xcode, software downloads&rdquo; and &ldquo;test your apps on devices&rdquo; in their <a href="https://developer.apple.com/support/compare-memberships/">Apple Membership</a> support page yet it casually dismisses the fact &ldquo;I cannot&rdquo; under the pretext of &ldquo;not an active Apple Developer&rdquo;.</p>
<p>Now, I believe this to be some misconfiguration on Apple&rsquo;s backend combined with the level of support you have come to expect from an enteprise company that Apple has become, still this is an indication on where Apple&rsquo;s priorites lie.</p>
<p>Apple has been on a very slippery slope over the years, methodically excercising control on distributing and running software on Apple platforms while at the same time trivialising and commercialising software.</p>
<p>Are we on a path where being a software developer will only be a profession exercised as part of an established business? With distribution only controlled by Apple and the only means to deliver software via the App Store? In this dystopian future how much freedom do we have over devices we own and code we write as independent software engineers?</p>
<p>The main reason I stopped the development of <a href="/software-engineer/#windmill">Windmill</a> wasn&rsquo;t because <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">Apple rejected Windmill on the iPhone</a>. I stopped because <a href="https://qnoid.com/2020/07/30/windmill.html#main">Apple made it pretty clear it wasn&rsquo;t happy with Windmill</a> and brought forward violations of my Apple Developer Membership agreement.</p>
<p>With Apple now threatening to <a href="https://mjtsai.com/blog/2020/08/17/apple-to-cut-epic-off-from-ios-and-mac-developer-tools/">cut Epic off from iOS and Mac Developer tools</a> by closing down their Apple Developer account based on violations of the App Store agreement, this is exactly the kind of retaliation I feared at the time.</p>
<p>It&rsquo;s upsetting, sadenning, madenning and troubling because I love the Swift language, the Apple SDK, the devices and the development platform yet Apple seems hell bent on ruining it all with its petulance, not having the courage to accept it is in the wrong.</p>
<blockquote>
<p>I&rsquo;ve been a self-employed dev ever since I became an adult (over 35 years). The Apple platform has been my main base of income for the last 30. I&rsquo;m invested in this platform. And suddenly Apple wants to change the rules - from being a provider of a platform and infrastructure to the one controlling who can use that platform and who can&rsquo;t - I feel immensely threatened by this. This is not progress, this is the opposite.
<a href="https://mjtsai.com/blog/2020/08/17/apple-to-cut-epic-off-from-ios-and-mac-developer-tools/#comment-3291895">Thomas Tempelmann</a></p>
</blockquote>
<h3 id="update-23-aug-2020">Update (23 Aug 2020)</h3>
<p>I pushed back</p>
<blockquote>
<p>I should be able to run code on devices I own. You don’t need to be part of the Apple Developer Program, <a href="https://developer.apple.com/support/compare-memberships/">https://developer.apple.com/support/compare-memberships/</a></p>
<p>None of the support documents you have provided help with the issue. I am unable to sign any code I write to run on any of the devices I own. That is a Mac, an iPhone and an Apple TV right.</p>
<p>While I understand Apple cannot provide &ldquo;free support” to non paid members, this isn’t something that the Apple Developer Forums can help me with.</p>
<p>This is something that only Apple can and needs to act on. Please escalate this.</p>
<p>Appreciated</p>
</blockquote>
<p>Only to get the same response</p>
<blockquote>
<p>As previously advised our department, Apple Developer Program Support is an administrative team that assists our Developers with the creation and maintenance of their Apple Developer Program memberships. Therefore, the support we have provided up to this point is the limit to what we can provide given that that your membership is not active. Thank you for your understanding.</p>
</blockquote>
<p>I pushed even more</p>
<blockquote>
<p>You are putting a $99 ransom fee so that I can get support on what is meant to be working as expected.<br>
Xcode reports “No Teams” for the Apple ID when I should be assigned to a “Personal Team” so that I am able to launch apps on devices I own.</p>
<p><a href="https://help.apple.com/xcode/mac/11.4/index.html?localePath=en.lproj#/devaf282080a%3E">https://help.apple.com/xcode/mac/11.4/index.html?localePath=en.lproj#/devaf282080a&gt;</a></p>
<p>This is unacceptable.</p>
<p>You have clearly demonstrated that you are [not] able to solve this.<br>
I demand you assign someone else about this case.</p>
</blockquote>
<p>At which point I was assigned a &ldquo;senior advisor with Apple Developer Programme Support&rdquo; who resolved the issue in 3 days.</p>
<p>So that was a total of 16 days. Make of that what you will. The writing is on the wall. The risk is only growing larger. The risk of being locked out of your account, the risk of being asked to pay Apple 30% of your revenue, the risk of not being able to write code for your devices.</p>
<p>I want to run miles away from what Apple has now become.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2020/04/08/windmill-source-code-public.html#main">The Windmill source code is now public</a> &ldquo;These are times where running software, on your computer (desktop or mobile), unfettered is near impossible.&rdquo;</li>
<li><a href="https://www.sicpers.info/2020/08/six-colours/">Six Colours</a>, &ldquo;Apple is now the IBM that fans booed in 1984, or the Microsoft that fans booed in 1997&rdquo;</li>
<li><a href="https://wormsandviruses.com/2020/08/epic-precendent/">Epic Precendent</a></li>
<li><a href="https://ia.net/topics/monopolies-apple-and-epic">On Monopolies, Apple, and Epic</a></li>
<li><a href="https://www.sicpers.info/2020/08/concrete-freedoms/">Concrete freedoms</a></li>
<li><a href="https://twitter.com/lapcatsoftware/status/1295524764073758722">Jeff Johnson</a> &ldquo;Prior to the introduction of Gatekeeper in 2012, Mac developers didn&rsquo;t need to sign a contract with Apple to distribute software outside the Mac App Store.&rdquo;</li>
</ul>
]]></description>
        <pubDate>Tue, 18 Aug 2020 11:27:43 +0300</pubDate>
      </item>
      <item>
        <title>Over a year since Apple gave me an ultimatum on Windmill</title>
        <link>https://qnoid.com/2020/07/30/windmill.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/07/30/windmill.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/WBFDQvIrWYM" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Yesterday, I watched live a session by the House Judiciary Subcommittee on &ldquo;Antitrust, Commercial, and Administrative Law | Online Platforms and Market Power, Part 6: Examining the Dominance of Amazon, Apple, Facebook, and Google.&rdquo;</p>
<p>It so happened that yesterday, was the 1 year anniversary of the post <a href="/2019/07/29/Windmill-on-the-iPhone.html#main">Where is Windmill on the iPhone?</a>.</p>
<p>Hearing the committee standing up for small business owners and individuals trying to support their family and employees, calling out corporations&rsquo; tactics on excercising control with a firm grip over people&rsquo;s freedoms to operate on a free market while also hindering innovation brought back memories.</p>
<p>I got especially emotional hearing an audio clip of a book seller pleading to Jeff Bezos to restore their business operations so that they could earn their livelihood.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/WBFDQvIrWYM?start=9014" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>It’s fair to say that Apple got the least amount of attention and scrutiny by far.</p>
<blockquote>
<p>Apple arguably got off the lightest of any of the companies in today’s hearing, if only by volume of questions: Tim Cook got just 35, compared to 59 for Bezos, 62 for Mark Zuckerberg, and 61 for Sundar Pichai</p>
<p>Casey Newton - <a href="https://www.getrevue.co/profile/caseynewton/issues/antitrust-finally-gets-its-hearing-267252">Antitrust finally gets its hearing</a></p>
</blockquote>
<p>With this enquiry as a landmark, I feel now is the time to share a few more details on what happened behind the scenes last summer as I was fighting to earn a living having spent countless months working on Windmill burning through the last of my savings. I want to also share some emails that capture my thoughts and emotions as I was going through the motions. I will also share, in full, the letter of appeal that I sent to the App Review Team.</p>
<h2 id="timeline">Timeline</h2>
<p><strong>May 20, 2019:</strong> Windmill is approved on TestFlight for beta testing.<br>
<strong>May 22, 2019:</strong> Windmill is “Waiting for Review” in the App Store.<br>
<strong>June 12, 2019:</strong> I send a “Status Request”.<br>
<strong>June 22, 2019:</strong> I email Phil Schiller bringing the case to his attention.<br>
<strong>June 22, 2019:</strong> I get a call from the App Review Team where I am being given the reasons why Windmill on the iPhone will be rejected.<br>
<strong>June 22, 2019:</strong> Windmill is “Rejected”.<br>
<strong>June 26, 2019:</strong> I send an 8 pages “Letter of Appeal” to the App Review Team with the following:</p>
<ol>
<li>An overarching description that explains, what Windmill does, why I think it’s useful for developers, why it does not violate the App Store Guidelines and Apple Developer Program License Agreement, how Apple benefits by approving Windmill.</li>
<li>The security considerations and implementation details that went into Windmill, for full transparency in an effort to make Apple feel comfortable about Windmill.</li>
<li>In detail, why I believe Windmill complies with the App Store Review Guidelines and the Apple Developer Program License Agreement</li>
<li>Final thoughts</li>
</ol>
<p><strong>July 3, 2019:</strong> “Based on the current material, the original rejection feedback remains valid.”<br>
<strong>July 3, 2019:</strong> I send a message to the App Review Team asking for clarification on what grounds Windmill is rejected and for feedback to help me work towards making Windmill compliant.<br>
<strong>July 9, 2019:</strong> I get a call from the App Review Team where I am being told that Windmill, “holistically” is not appropriate. This decision was made in   collaboration with the App Review Board.<br>
<strong>July 12, 2019:</strong> I email a developer tools evangelist at Apple asking for help to find a way forward with Windmill and for some some course correction to be done.</p>
<p>I never hear back.</p>
<h2 id="correspondance">Correspondance</h2>
<blockquote>
<p>Hello Phil,</p>
<p>My name is Markos and I am an independent Apple Developer living in Athens, Greece.</p>
<p>Apple’s developer relations and customer service has been overwhelmingly positive throughout the years, kudos for that.</p>
<p>In this rare case however, the App Review process seems to have fallen a victim of a scripted, no individual stepping forward, corner case where it just falls apart.</p>
<p>I will just give you the gist of it.</p>
<p>Windmill has been In Review for 21 work days, i.e. since the 23rd of May.
I made a Status request 7 work days ago, i.e. since the 12th of June,
It’s been about 12 hours since I have asked for some visibility on the status.</p>
<p>I wanted to bring this to your attention as this is now the cause of anxiety.
I would very much appreciate you looking into this. I don’t expect a personal reply.</p>
<p>Thank you<br>
.-<br>
Markos</p>
</blockquote>
<p>Seemingly, this email prompted the call I received on the very next (US) day.</p>
<p>I strenuously tried to understand Apple and listen to its concerns in an effort to meet its demands even though <strong>there was very little guidance in making Windmill compliant</strong>. At the same time, I vigorously made the case for Windmill&rsquo;s approval. Alas, it eventually became clear to me that the call was a &ldquo;courtesy&rdquo; call. The decision had already been made and I was just being told how it is going to be.</p>
<p>I was confident this was a misunderstanding. That Windmill was not seen by Apple as a serious endevour given that I was just an indie developer. I was not ready to give up. I started drafting a letter of appeal with some feedback from fellow developers.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/WBFDQvIrWYM?start=18900" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<blockquote>
<p>On 24 Jun 2019, at 12:29, Markos Charatzas <a href="mailto:markos@qnoid.com">markos@qnoid.com</a> wrote:</p>
<p>Having had some time to think about the rejection, I now get the impression that Apple strongly believes Windmill on the iPhone to be no different to TestFlight which couldn’t be further from the truth.</p>
<p>Also, since Apple itself hasn&rsquo;t really been much in support of the development process outside of Xcode, I worry that it may not believe in the value of Windmill. It does not help that Apple has a tendency of having a narrative that everything must fit into it.</p>
</blockquote>
<p>2 days later, I sent a <a href="/static/2020/07/31/Windmill%20Letter%20of%20Appeal.pdf">Windmill Letter of Appeal</a> to the App Review Team. Windmill gets rejected again.</p>
<blockquote>
<p>From:  Apple<br>
Date: 09/07/2019, 19:13<br>
2. - 5 Performance: Software Requirements<br>
3. - 1.2 Business: Payments - Subscriptions<br>
5. - 2.5 Legal: Intellectual Property - Apple Products Other - Other  <br>
Date: 03/07/2019, 07:02</p>
<p>Hello Markos,</p>
<p>Thank you for your detailed response and ongoing patience.</p>
<p>Based on the current material, the original rejection feedback remains valid.</p>
<p>However, if you believe your app is compliant with the App Store Review Guidelines, you are certainly well within your right to file an appeal to the App Review Board. As a member of the Apple Developer Program, you may exercise this option at any time.</p>
<p>Best regards,<br>
[Redacted]<br>
App Store Review</p>
</blockquote>
<hr>
<blockquote>
<p>Date: 03/07/2019, 07:37<br>
Hello [Redacted],</p>
<p>It is not clear to me whether the App Review team believes Windmill is still in violation of every App Store Review Guideline as well as the Apple Developer Program License Agreement. Can you please clarify whether Windmill is in compliance with some or all? Your feedback can help me work towards making Windmill compliant.</p>
<p>In regards to filing an appeal to the App Review Board. Given that the form to submit an appeal, only accepts plain text, how can I best send the letter in the PDF format?</p>
<p>Appreciated,<br>
Markos</p>
</blockquote>
<hr>
<blockquote>
<p>Date: 05/07/2019, 13:13<br>
Hello [Redacted],</p>
<p>I would love to get on a call with you so that I can better understand how to proceed.
Not sure what your schedule is like. I am generally available in the next few days and happy to talk during the weekend like last time.</p>
<p>By the way, I noticed that the number to contact you, [+1-XXX-XXX-XXXX], does not support FaceTime audio.
It would make a positive difference to have that option available.</p>
<p>Regards,<br>
Markos</p>
</blockquote>
<hr>
<blockquote>
<p>From:  Apple<br>
Date: 09/07/2019, 19:13<br>
2. - 5 Performance: Software Requirements<br>
3. - 1.2 Business: Payments - Subscriptions<br>
5. - 2.5 Legal: Intellectual Property - Apple Products Other - Other</p>
<p>Hello Markos,</p>
<p>Thank you again for your time on the phone today, and further discussing the App Review Guidelines.</p>
<p>Whereas we are unable to provide you with specific development feedback for your app, we are dedicated to evaluating any revisions you would like to make in the form of a future resubmission.</p>
<p>Best regards,<br>
[Redacted]<br>
App Store Review</p>
</blockquote>
<p>In the phone call I stated my intention to appeal. While I was told it was certainly within my right, I was given the impression that it wouldn&rsquo;t make much of a difference. The decision was made having already consulted and factored in feedback from people outside the App Review Team.</p>
<p>It was on that final call, where it became pretty clear that Apple wasn&rsquo;t willing to work with me on this. It was a call to tell me how this is going down. It is striking how differently Apple conducts itself on a call versus in writing; in public versus in private. The call sounded eerie familiar to the one made to Kapeli back in 2016 in regards to Dash. <a href="https://blog.kapeli.com/dash-and-apple-my-side-of-the-story">Dash and Apple: My Side of the Story</a>.</p>
<blockquote>
<p>&ldquo;Has Apple ever retaliated against or disadvantaged a developer who went public about their frustration  with the App Store?&rdquo;</p>
</blockquote>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/WBFDQvIrWYM?start=4733" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<h2 id="going-public">Going public</h2>
<p>Having been given an ultimatum by Apple, I was encouraged by fellow developers to go public with the story. I was hesitant.</p>
<blockquote>
<p>On 24 Jul 2019, at 08:07, Markos Charatzas <a href="mailto:markos@qnoid.com">markos@qnoid.com</a> wrote:</p>
<ol>
<li>
<p>What is the end goal? Apple to reverse course and approve Windmill on the iPhone? Apple to change its stance, that holds privately, when it comes to how Command Line Tools can be used? Apple to have a public debate about developer tools on and about iOS?</p>
</li>
<li>
<p>What is the case I am making and on what grounds? What’s possible to ship as an Apple Developer on Apple platforms, how the App Store is the only way to distribute iOS apps and the role of Apple as a gatekeeper? How that hinders innovation, competition and user choice?</p>
</li>
</ol>
<p>These subjects have been debated for some time and right now are at the forefront even. How and why would they make a difference now?</p>
<p>Writing what Windmill does, how it’s helpful to developers, why it was rejected is only the setup. I don’t see that being sufficient to either get others’ support or for Apple to take this seriously.</p>
<p>Apple’s stance has caused me grief and a nihilistic view about the future of Windmill. At the same time, having Apple’s decision that Windmill holistically violates the Developer License Agreement hanging over my head is something I want to get off of me.</p>
<p>To be honest, I don’t feel comfortable, confident or keen on taking Apple, leading a movement or becoming a martyr in the process. I wish I could just go back to building Windmill and helping businesses get on board. I just feel that I can’t do that either.</p>
<p>Thank you for going through this with me.</p>
</blockquote>
<hr>
<blockquote>
<p>On 24 Jul 2019, at 22:56, Markos Charatzas <a href="mailto:markos@qnoid.com">markos@qnoid.com</a> wrote:</p>
<p>It’s possible that I’m overly emotional and choose to complicate things. I generally want to be well calculated and get things right. Even more so when I’m about to go on the public record with Apple when my developer license is on the line. It doesn’t help that have been beaten down by Apple twice already on this case.</p>
<p>This comes after more than 4 weeks of the App Review Team, the App Review Board and possibly Phil Schiller looking into Windmill on the iPhone. Also taking into account the 8 pages letter where I did say to Apple what the app does, how it works, and why the app would be helpful to other developers. I just can’t see how that alone would rally people. I might just be pessimistic.</p>
<p>After that letter, Apple decided to come after Windmill on the Mac saying I violate my developer license by building on top of the command line tools. This is more than simply  an iPhone app being rejected.</p>
<p>The way I understand it, Apple does not want to set a precedent or open the door for others to exploit.</p>
<p>Keep in mind that Windmill on the Mac is the only 3rd party native macOS app that offers “continuous delivery”. The other one is Xcode bots by Apple itself. Any other service that uses the command line tools is on the web hence outside of Apple’s influence. Thus yet again being the only one directly affected by this. I believe you are using CircleCI so you know what I’m talking about.</p>
<p>I left London behind, a high paying job and have sacrificed at least 2 years of my life to build Windmill. I feel a lot of pressure and have a lot to lose on this so it doesn’t come easy.</p>
<p>It would help if you could tell me what you see in Windmill? What do you think is at stake? How does the decision by Apple to allow or sustain the rejection affect you as an Apple developer? Why do you think others would care? Why do you care? :) knowing that can help me build confidence.</p>
</blockquote>
<hr>
<blockquote>
<p>On 26 Jul 2019, at 22:31, Markos Charatzas <a href="mailto:markos@qnoid.com">markos@qnoid.com</a> wrote:
Thanks!</p>
<p>So far I’ve had 2 more people giving me feedback.</p>
</blockquote>
<blockquote>
<p>One of them is [Redacted], who is definitely looking at this from a different, if not pessimistic angle. Which is good! Cause that means he does a great job covering the blind spots.</p>
<p>He made me think harder about what Apple is <em>probably</em> concerned about with Windmill. Creating a distribution mechanism which is available to the public, outside of the control of Apple and lacking the safety of the App Store. No matter how limited ad-hoc distribution may be.</p>
<p>Hard to debate about this as it brings the discussion back to the pros and cons of having the App Store as the only way to distribute apps&hellip;</p>
<p>Do you think there is a way to address this in the post without sounding like I’m not acknowledging the risk or sound insensitive to what Apple is concerned about?</p>
<p>I now think the “Final thoughts” section should be completely overhauled to touch on this issue and better communicate what I’m looking to get out of this by inviting a public debate/discussion.</p>
<p>I’m also thinking about removing both the “Timeline” and “Compliant” sections to keep the post shorter. I am not sure they add to anything. What do you think?</p>
</blockquote>
<hr>
<blockquote>
<p>On 26 Jul 2019, at 23:12, Markos Charatzas <a href="mailto:markos@qnoid.com">markos@qnoid.com</a> wrote:<br>
But in some way, it does. Windmill today is a public offering/service. It doesn’t matter what Windmill is designed to be used for but how it is implemented and how it could be used for.</p>
<p>It is precisely why Apple had to say that the Command Line Tools Package is only meant to be used by developers alone.</p>
<p>I feel like I&rsquo;ve completely misread the situation with Apple up until now.</p>
<p>Say, if an organisation had built Windmill for internal use. The server used for distribution would be under their control and probably in their internal network.</p>
<p>Windmill on the iPhone would probably be distributed using an Enterprise Certificate, internally to the employees of the organisation or using ad-hoc distribution. It doesn’t matter, it’s internal.</p>
<p>It completely changes how organisations would use Windmill.
In this case, I am not even sure a public post is useful.</p>
<p>What an epiphany.</p>
<p>Are you following my train of thought at all? :)</p>
</blockquote>
<p>I have removed the receipient in the emails above to focus on my thoughts, considerations and reasoning instead. For the final exchange though, I would like to include it as I believe it makes an important point about the App Store as the only means of distributing iOS apps.</p>
<blockquote>
<p>I think I’m following you. The topic is way outside my normal areas of expertise, though.</p>
<p>So, to be clear — could Windmill be used to distribute apps to the public, circumventing TestFlight and the App Store?</p>
</blockquote>
<hr>
<blockquote>
<p>On 27 Jul 2019, at 14:18, Markos Charatzas <a href="mailto:markos@qnoid.com">markos@qnoid.com</a> wrote:</p>
<p>You can&rsquo;t use Windmill to distribute apps to the public, circumventing TestFlight and the App Store any more than you can without using Windmill.</p>
<p>It’s nuanced.</p>
</blockquote>
<p>The rest <a href="/software-engineer/#windmill">is history</a>.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/WBFDQvIrWYM?start=19601" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">An Apple Developer for 10 years</a></li>
<li><a href="https://news.ycombinator.com/item?id=20897437">Hacker News</a> - &ldquo;An Apple Developer for 10 Years&rdquo;</li>
<li><a href="https://mjtsai.com/blog/2020/07/28/new-eu-regulations-for-app-stores/">New EU Regulations for App Stores</a></li>
<li><a href="https://mobile.twitter.com/keleftheriou/status/1274356729224892416">For the longest time, I&rsquo;ve been afraid to speak up about my story with App Review, fearing I&rsquo;d put my popular app at risk.</a> - Kostas Eleftheriou</li>
<li><a href="https://blog.kapeli.com/100-days-without-the-app-store">100 Days Without the App Store</a></li>
<li><a href="https://m.signalvnoise.com/on-apples-monopoly-power-to-destroy-hey/">On Apple’s monopoly power to destroy HEY</a></li>
<li><a href="https://hey.com/apple/">Apple vs. HEY</a></li>
<li><a href="https://mobile.twitter.com/dhh/status/1273019513538314245">Apple&rsquo;s abusive behavior with the App Store has been an open secret in the developer community for years. But very few people are interested in talking to regulators or the press, because you don&rsquo;t want to get on Apple&rsquo;s bad side, or you might get crushed.</a> - David Heinemeier Hansson</li>
</ul>
]]></description>
        <pubDate>Thu, 30 Jul 2020 15:54:16 +0300</pubDate>
      </item>
      <item>
        <title>Fear, support and endurance in the face of adversity</title>
        <link>https://qnoid.com/2020/05/10/endurance.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/05/10/endurance.html</guid>
        <description><![CDATA[<p>A dear friend lost his father recently. On the day of the service, I went by his house early morning as we had to drive for about an hour to attend the funeral. In that hour long drive, there were moments of laughter, quietness, reflection, sadness. All interwined with one another.</p>
<p>As he was facing the casket, I stood by, just a few steps behind and to his side, holding onto his shoulder. He was the one that had to deal with an insurmountable event. The one that had to find ways to cope with this unbeareable loss. He knew, nothing and noone could bring his father back. He knew that he had to learn to live without his presence. Find ways to navigate his life that has just been upended by forces outside of his control.</p>
<p>Yet, in that moment, he wasn&rsquo;t alone. He could feel my presence and the presence of others close to him. Every step he took to his father&rsquo;s grave, was a step he took in the presence of others. Not feeling alone, made this ordeal somewhat bearable.</p>
<p>Unlike death, which is very much real, hardship can be in disguise. Seeing a loved one struggling, feeling powerless to help them can be very frightening at times. A prolonging struggle will only grow that fear. Fear that you are not doing enough to help, fear that something bad is going to happen to them on your watch.</p>
<p>My friend knew I couldn&rsquo;t bring his father back. He knew he had to deal with what life had thrown his way, alone. There was nothing to say or do in this very moment. Being there was powerful enough.</p>
<p>Something so simple as being present, may seem hard to fathom outside ceremonial moments like these. Sometimes, what is being asked of you is not to come up with a solution or to offer a piece of advice. Sometimes, comfort found in your presence is what people look for as they endure hardship.</p>
<h2 id="related">Related</h2>
<p><a href="https://qnoid.com/2019/08/13/Anxiety-Looks-Different-in-Men.html#main">Anxiety looks different in men</a> - &ldquo;Be compassionate&rdquo;</p>
]]></description>
        <pubDate>Sun, 10 May 2020 11:36:42 +0300</pubDate>
      </item>
      <item>
        <title>Programming</title>
        <link>https://qnoid.com/2020/05/05/Programming.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/05/05/Programming.html</guid>
        <description><![CDATA[<p>I <a href="https://qnoid.com/2020/01/23/future.html#main">felt like learning something new</a>. This time web related. Eventually, I arrived at Kotlin. Between my background experience as a Java Web Developer and an <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">Apple Developer</a>, I thought Kotlin sounded like a good investment and fun to play with.</p>
<p>With Kotlin I should be able to bring forward all that Java EE knowledge I have while also learning a new language. Given that Kotlin is also used for native Android development, combined with the experience of building iOS apps, I could also expand to another mobile platform in the future.</p>
<hr>
<p>Some combination of cryptic error messages that I had to decode before I could have a development environment ready, open-source plugins no longer supported, out of date documentation, buggy releases, patchy tools meant that I had to jump through hoops before I could write even a single line of code.</p>
<p>I won&rsquo;t go into detail of every problem I run to. What I will say, is that it took hours of debugging, googling, reading through support forums, trial and error before I could finally focus on the task. Building something while learning a new language.</p>
<p>I have over 15 years of experience as a Software Engineer and it still took me hours to go through every issue. How would a newcomer deal with any of that? How accessible is programming today? How is it fun? What happened to:</p>
<pre tabindex="0"><code>10 PRINT &#34;Hello, World!&#34;
20 END
</code></pre><h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2020/02/29/Coding.html#main">Coding</a> - &ldquo;It’s like the 80s all over again, where you plug in a machine, and you can instantly start coding. I for one miss that.&rdquo;</li>
<li><a href="https://qnoid.com/2020/01/21/Opensource.html#main">Open-source</a> - &ldquo;I am not sure what to make of open-source software anymore.&rdquo;</li>
<li><a href="https://www.lexaloffle.com/pico-8.php">PICO-8</a></li>
<li><a href="https://www.gbstudio.dev">GB Studio</a></li>
</ul>
]]></description>
        <pubDate>Tue, 05 May 2020 21:56:48 +0300</pubDate>
      </item>
      <item>
        <title>Debt and borrowed time</title>
        <link>https://qnoid.com/2020/04/30/Debt-and-borrowed-time.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/04/30/Debt-and-borrowed-time.html</guid>
        <description><![CDATA[<p>I have been trying for weeks to write this one technical blog post on how Windmill secured over-the-air downloads on iOS. I just can&rsquo;t.</p>
<p>My brain just tells me no, it refuses. It tells me I need to spend more time looking for a job. I am wasting precious borrowed time. I am piling up debt that I need to pay back. It tells me that I need to make some progress getting my life back in order.</p>
<hr>
<p>I haven&rsquo;t been in this situation since 2009 - 2010. Just before I decided to leave Greece and return back to the UK. I was in debt while also being in limbo. I didn&rsquo;t want to leave Greece even though it was a dead end.</p>
<p>The way I was able to cope with the debt I was piling up was by thinking of it as borrowing time from the future. My future. It was just too much to think of it as monatery value. I was going to repay it back, eventually.</p>
<p>This wasn&rsquo;t a strategic decision on my part. It wasn&rsquo;t like taking a loan to use as an investement. It was a coping mechanism.</p>
<hr>
<p>Whatever savings I had to support me while building Windmill have run out since the end of September 2018. Back then, with only the free version of Windmill on the Mac available, I decided to look for a job. You would think that with all that talk about the <a href="https://qnoid.com/2019/08/06/Brain-drain.html#main">brain drain</a> in Greece it would have been easy. It wasn&rsquo;t, <a href="https://qnoid.com/2020/01/03/Windmill.html#main">it hasn&rsquo;t</a> and still isn&rsquo;t.</p>
<p>With the support and encouragement from my partner, I decided to push forward with the development of <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">Windmill on the iPhone</a>. This is precisely the moment where I started borrowing time, again.</p>
<hr>
<p>It has now been 19 months of borrowed time.</p>
<hr>
<p>This is not the complete picture though. This time around another human is carrying more than their fair share and while they do, I feel like I am holding them back. This is something that I struggle with as it goes against my beliefs in equality and opportunity.</p>
]]></description>
        <pubDate>Thu, 30 Apr 2020 12:15:12 +0300</pubDate>
      </item>
      <item>
        <title>Coding challenges as part of an interview</title>
        <link>https://qnoid.com/2020/04/28/coding-challenges.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/04/28/coding-challenges.html</guid>
        <description><![CDATA[<p>Brent Simmons writing about coding challenges as part of an interview process.</p>
<blockquote>
<p>I’ve read a bunch of the advice on this, and the advice says things like: “Start talking. Restate the problem. Talk out an approach. Consider how much space/time it will use. And then start writing code.”</p>
</blockquote>
<p>I feel like Brent is speaking for myself when he says:</p>
<blockquote>
<p>Which is of course not at all how I solve problems.</p>
</blockquote>
<p>He then goes on to explain in detail how he typically approaches a problem domain that he is unfamiliar with when writing code. Which sounds very familiar to how I go on about writing code too. Furthermore,</p>
<blockquote>
<p>And — even more critical — I don’t have a 45-minute time constraint. Nobody is watching me type and judging. I’m writing code to solve a problem, rather than writing code to get a job.</p>
</blockquote>
<blockquote>
<p>There’s a huge difference between “solve this performance problem with a binary search” and “pass this test so you can feed your family.”</p>
</blockquote>
<p>This hits the nail on the head. I too had to solve similar coding excercises during an interview only to suffer from anxiety. I get <a href="https://en.wikipedia.org/wiki/Tunnel_vision">tunnel vision</a> and I am unable to demonstrate clear thinking.</p>
<p>Thank you for saying this Brent. I take comfort reading that a developer like you, at the top of their game, is faced with the same challenges as I do. It tells me I am not alone.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://inessential.com/2020/04/26/practicing_the_coding_challenges">Practicing the Coding Challenges</a> - inessential
by Brent Simmons</li>
<li><a href="https://inessential.com/2020/04/27/a_coding_challenge_cant_show_how_i_solve">A Coding Challenge Can’t Show How I Solve A Problem</a> - inessential by Brent Simmons</li>
<li><a href="https://qnoid.com/2016/01/14/We-need-to-raise-the-bar-on-software-development.html#main">We need to raise the bar on software development</a> - qnoid.com</li>
</ul>
]]></description>
        <pubDate>Tue, 28 Apr 2020 09:21:01 +0300</pubDate>
      </item>
      <item>
        <title>I miss London</title>
        <link>https://qnoid.com/2020/04/23/london.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/04/23/london.html</guid>
        <description><![CDATA[<p>I miss London. I miss walking around. I miss the night sky. I miss walking around Fitzrovia, past that little chapel hidden away in a residential block where apartments have full glass windows. I miss walking up Primrose Hill, turning around and looking at the skyline. I miss Covent Garden. I miss SOHO. I miss the lions at Trafalgar Square. I miss London so much.</p>
<p>I feel like the clock has turned back 10 years. All the sacrifices made, all the time and effort I put to change my life around. Everything that lead me to London, has just vanished.</p>
<p>I am in Athens but I don&rsquo;t really want to be here. You would think that after 10 years of being away, coming back would feel like coming home but it doesnt. The UK felt like home. You would think friends would cherish your return, be close, want to spend time with you, be there. They are not. They are married, have grown older, are depressed, working overtime. You would think a family home would be there for you. To celebrate the holidays, to spend the weekend. There is none.</p>
<p>I am tired.</p>
<p>It&rsquo;s hard to go back. The UK has left Europe. There is so much uncertainty and I am no longer 29. The last 2 years have been nothing but struggle. I want to take back control yet I end up waiting. Waiting yet again for someone&rsquo;s approval, someone to tell me my worth, what I deserve.</p>
<p>I am tired.</p>
<p>It feels like I am back to where I was 10 years ago. In debt, lost, waiting. Only now I am 39 going 40.</p>
<p>I am tired.</p>
<p>I want to reinvent myself.
I miss you London. You belong in the past. I still miss you.</p>
]]></description>
        <pubDate>Thu, 23 Apr 2020 22:26:27 +0300</pubDate>
      </item>
      <item>
        <title>The Windmill source code is now public</title>
        <link>https://qnoid.com/2020/04/08/windmill-source-code-public.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/04/08/windmill-source-code-public.html</guid>
        <description><![CDATA[<p>I have made the decision to release the source code of <a href="/software-engineer/#windmill">Windmill</a>.</p>
<ul>
<li>
<p><a href="https://github.com/qnoid/windmill-osx">Windmill on the Mac</a><br>
Windmill on the Mac is a native macOS application written in Swift 5 on Xcode 10 targetting macOS 10.14. The codebase is about 16k LOC.</p>
</li>
<li>
<p><a href="https://github.com/qnoid/windmill-ios">Windmill on the iPhone</a><br>
Windmill on the iPhone is a native iOS app written in Swift 5 on Xcode 10 targetting iOS 12.2. The codebase is about 5k LOC.</p>
</li>
<li>
<p><a href="https://github.com/qnoid/windmill-api">Windmill REST API</a><br>
The Windmill REST API is a Java EE 8 implementation written in Java 8 using JAX-RS. The codebase is about 7.5k LOC.</p>
</li>
</ul>
<h2 id="history">History</h2>
<p>I started working on Windmill as a side project in 2014. In 2017 I decided to commit full time and in February 2018, Windmill on the Mac 1.0 was released. In July 2019 Apple rejected <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">Windmill on the iPhone</a> and took issue with Windmill in principle. I didn&rsquo;t make any money on Windmill and was not in a position to take it forward given these cirmustances thus formally <a href="https://qnoid.com/2020/01/03/Windmill.html">ending its development</a> in January 2020.</p>
<h2 id="why-make-the-source-code-public">Why make the source code public?</h2>
<p>Effectively, by Apple putting Windmill on notice, the only way I can distribute Windmill on the Apple platforms is at the source code level. Even though this does not serve the mission to make continuous delivery accessible, whatever value Windmill brings even as source code, is better than none at all.</p>
<p>The development of Windmill did come to an abrupt end and didn&rsquo;t get a fair chance to become what I had envisioned. It would bring me joy to know that developers will benefit from it by learning something new. It&rsquo;s a way to give back to the community.</p>
<p>Windmill is not some example software after all. It is production grade that spans across the desktop, mobile and the server. The software engineering behind it is still relevant and the technologies used modern.</p>
<p>I was diligent, took great care and put a lot of attention in building succint, performant, reliable, and bug free software across multiple platforms. I believe the source code of Windmill has something to offer whether you are a beginner or a senior in software development in any of the 3 platforms.</p>
<h2 id="what-does-making-the-windmill-source-code-public-mean">What does making the Windmill source code public mean?</h2>
<p>As a product, my gut feeling tells me that unless a company with the available resources gets behind it, Windmill will not go far. I am hopeful but don&rsquo;t expect much.</p>
<p>As software, I believe not that much. These are times where running software, on your computer (desktop or mobile), unfettered is near impossible. In order to run Windmill on your Mac and the iPhone you will need an Apple Developer account. Since Windmill is built for developers, chances are you do have one. Still.</p>
<p>Windmill is built to take advantage of and be tightly integrated with the Apple ecosystem. It makes use of Push Notifications, Background Mode, CloudKit and In-App Purchases. You can strip away and refactor some of the code but the point still stands. Distributing, modifying and running software outside walled gardens isn&rsquo;t as straight forward.</p>
<p>The Windmill REST API is no different. The implementation relies heavily on AWS infrastructure. It will also take some elbow grease to get up and running.</p>
<h2 id="what-not-to-expect">What not to expect</h2>
<p>Releasing the source code of Windmill does not make it open-source. I don&rsquo;t plan on contributing any time or energy developing it further. To support it as open-source would demand of me even more resources and attention which I don&rsquo;t have the luxury of.</p>
<p>Don&rsquo;t expect any instructions on how to build and run the code.<br>
Don&rsquo;t expect the code to be extensively documented.<br>
Don&rsquo;t expect me to respond to any issues raised or pull requests made.</p>
<p>I don&rsquo;t plan to publish any Windmill architecture diagrams, security considerations or design documents either.</p>
<h2 id="how-to-make-the-best-of-the-source-code">How to make the best of the source code</h2>
<h3 id="study-it">Study it.</h3>
<p>As a Swift developer, the macOS app<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> should be the most juicy one for you.</p>
<p>Have a look at the <code>ProcessManager</code> type on how to launch a Process, wait and receive data in the background from both standard out and err. The <code>ProcessManager</code> also allows you to recover a Process that has exited with an error code. As an example, look at how <code>ActivityBuild</code> creates a <code>RecoverableProcess</code>.</p>
<p>The <code>Windmill</code> type makes extensive use of the design pattern as described in <a href="https://qnoid.com/2019/05/07/A-series-of-steps.html#main">A series of steps</a> post. Take a closer look at the <code>ActivityBuilder</code> type to see how Windmill uses it to create the pipeline to a succesful build.</p>
<p>As fas as the iOS app goes, have a look at <code>PaymentQueue</code>
and <code>SubscriptionManager</code> on how to process transactions when purchasing a subscription that requires validating a receipt on the server.</p>
<p>I have already documented how to <a href="https://qnoid.com/2019/02/15/How_to_replace_the_-rootViewController-_of_the_-UIWindow-_in_iOS.html#main">replace the rootViewController of the UIWindow</a> that Windmill on the iPhone also makes use of.</p>
<p>As a Java developer, the REST API should prove useful as a reference implementation of the Java EE 8 spec. The most interesting tidbit is likely the use of an <code>EntityGraph</code> to retain the lazy associations of an <code>@Entity</code> while performing queries that require exclusively independent associations to materialise. In the case of the Windmill REST API, that would be the <code>AccountResource#list</code> that materialises a list of <code>Export</code> types and the <code>SubscriptionResource#isSubscriber</code> that materialises a list of <code>Transaction</code> types for a <code>Subscription</code>.</p>
<h3 id="own-the-code">Own the code.</h3>
<p>At the very minimum Windmill on the Mac should serve as a replacement to Jenkins. For any developers that still use Xcode 10 to build and test their app, this is as straightforward as building and signing the app using your Apple account. The iCloud capability can be disabled as it&rsquo;s only relevant when used alongside the iPhone app.</p>
<p>If you are using Xcode 11, it will take some effort to add support since Apple has changed the result bundle format. At the very least Windmill needs to be updated to support the new format.</p>
<p>If you do put in the time and effort, it should be possible to have Windmill on the Mac, on the iPhone and on the server running which will give you app distribution.</p>
<h2 id="what-did-the-future-hold-for-windmill">What did the future hold for Windmill?</h2>
<p>Windmill was really at its infancy. Allowing developers to distribute their app and have over-the-air installation was the first step in making its development sustainable.</p>
<p>I had plans to develop an TV App to act as a dashboard for teams and have company wide notifications.</p>
<p>I wanted to add support for nightlies, the ability to substitute resources during packaging and support conditional compilation to allow for different builds.</p>
<p>Finally, I wanted to tackle distributed building, support multiple configurations (e.g. to maintain multiple releases) and integration with 3rd party libraries.</p>
<p>Feel free to use these guidelines as a roadmap.</p>
<h2 id="the-licence">The licence</h2>
<blockquote>
<p>Created by Markos Charatzas (<a href="mailto:markos@qnoid.com">markos@qnoid.com</a>)<br>
Copyright © 2014-2020 qnoid.com. All rights reserved.</p>
<p>The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.</p>
<p>Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:</p>
<p>This software is provided &lsquo;as-is&rsquo;, without any express or implied
warranty.  In no event will the authors be held liable for any damages
arising from the use of this software.</p>
<ol>
<li>The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation is required.</li>
<li>Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.</li>
<li>This notice may not be removed or altered from any source distribution.</li>
</ol>
</blockquote>
<h2 id="final-words">Final words</h2>
<p>I still believe in Windmill and would love for a company with the resources to step in and take it forward.</p>
<p>I am <a href="/static/Curriculum%20vitae.pdf">available for hire</a>. I am based in Athens, Greece and able to invoice from a UK company if needed.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>I should point out that this was my first ever macOS app. It is highly probable that I have made some amateur mistakes while learning about the responder chain, how to manage multiple windows and handle the menu bar. Consider this a fair warning.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Wed, 08 Apr 2020 09:37:31 +0300</pubDate>
      </item>
      <item>
        <title>Hugo</title>
        <link>https://qnoid.com/2020/04/07/Hugo.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/04/07/Hugo.html</guid>
        <description><![CDATA[<p>I have been using <a href="https://jekyllrb.com">Jekyll</a> for quite some time. Quite possibly since the beginning of this blog. I have now migrated to <a href="https://gohugo.io">Hugo</a>. There wasn&rsquo;t a strong reason to do so. Jekyll was serving me just fine up until now. I even used Jekyll for the Windmill website.</p>
<p>Why do it then? I just felt like doing something productive and wanted something to tinker with. Hugo seems more geared towards building a website as opposed to just a blog and I would like this website to <a href="https://qnoid.com/2020/02/08/Evolution.html">evolve</a>.</p>
<hr>
<p>It took me about 2 days to migrate. I didn&rsquo;t use any of the existing tools as I wanted to get familiar with Hugo. The most time consuming was making sure, yet again, that permalinks don&rsquo;t change. In the 10 years of this website&rsquo;s lifespan, I had to deal with this at least 2-3 times that I can remember.</p>
<p>Hugo apparently generates permalinks in the form of <code>https://qnoid.com/hugo/#main</code> compared to what this website has been using, <code>https://qnoid.com/Hugo.html#main</code>.</p>
<p>To be honest, I don&rsquo;t recall the later format being a concious decision on my part but obviously didn&rsquo;t care enough at the time. I don&rsquo;t even know what the &ldquo;canonical&rdquo; format for URLs is. I didn&rsquo;t want to open this can of worms.</p>
<hr>
<p>I made sure to salvage the permalink for most of the posts. For those that had some obscure formatting due to using the title of a post at the time, I didn&rsquo;t bother. Life is too short. The good news is that the most prominent posts weren&rsquo;t affected so cheers to that.</p>
<p>While feeling the pain of salvaging the permalinks, I did begin to wonder. How can we better handle permanent redirects? I kinda wish for a way to &ldquo;track&rdquo; a resource across a URL the way Git can track a file across name changes.</p>
<hr>
<p>Now that I have migrated the website, I have a big announcement coming up about the future of <a href="/software-engineer/#windmill">Windmill</a>.</p>
]]></description>
        <pubDate>Tue, 07 Apr 2020 12:56:53 +0300</pubDate>
      </item>
      <item>
        <title>Coding</title>
        <link>https://qnoid.com/2020/02/29/Coding.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/02/29/Coding.html</guid>
        <description><![CDATA[<blockquote>
<p>What&rsquo;s the point in life? To have fun? I&rsquo;ve certainly had fun with this Next and that is good enough for me. But if you want the wider story, then I think there are several avenues.</p>
<p>For some, this could simply be a programming platform free from all the libraries, framework and constraints of modern day system.</p>
<p>It&rsquo;s like the 80s all over again, where you plug in a machine, and you can instantly start coding. I for one miss that.</p>
<p>There is something about the brutal simplicity, which just draws you in, and then, because this isn&rsquo;t a complex beast, you can actually gain an understanding of what you are doing.</p>
<p>Even using a high level language like BASIC you can see how your commands affect the system. It&rsquo;s an elegance we lack these days.</p>
<p>Sure, you could use a retro system for that, but this is a new machine, with a new community excited to see what they produce. It&rsquo;s not a rehash. It&rsquo;s current but it&rsquo;s grounded in the past.</p>
</blockquote>
<p>I miss that too.</p>
<p><a href="https://youtu.be/ckYN_TwbGiQ">ZX Spectrum Next <code>|</code> Nostalgia Nerd</a></p>
]]></description>
        <pubDate>Sat, 29 Feb 2020 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Evolution</title>
        <link>https://qnoid.com/2020/02/08/Evolution.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/02/08/Evolution.html</guid>
        <description><![CDATA[<p>I want to evolve this website to something more than just a <a href="/blog">blog</a>.</p>
<p>A website that is deeply personal yet it&rsquo;s not about me.<br>
A website that is about forming relationships, removing barriers, breaking taboos. <br>
A website that raises awareness to issues that trouble me.<br>
A website that recognises contributions made by others and elevates them.<br>
A website that helps people make sense of their lives and deal with their struggles.<br>
A website that brings your attention to people in need.<br>
A website that is connected to other people through the vastness of the World Wide Web.<br>
A website of what it means to be human.</p>
<p>I also want a website that can outlive me. That can be used for historical purposes, for people to look back and understand what life was like in the late 20th century, early 21st. A digital cave if you like. Full of footprints, drawings, sounds, videos.</p>
<p>For the past few days, I have started working towards making a website like this. It is still in its infancy but there is enough to share.</p>
<p><a href="/">Welcome to my life</a>.</p>
]]></description>
        <pubDate>Sat, 08 Feb 2020 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The next 10 years</title>
        <link>https://qnoid.com/2020/01/23/future.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/01/23/future.html</guid>
        <description><![CDATA[<p>BScIT (aka Biscuit) class of 2003 at the <a href="http://sunderland.ac.uk">University of Sunderland</a>.</p>
<p>There is a whole story of how I ended up working at <a href="http://cern.ch">CERN</a> but that&rsquo;s for another day. What&rsquo;s relevant is that at CERN, in 2001, I was &ldquo;christened&rdquo; a Java Developer. I had no prior experience in Java or related backend stack (e.g. databases). Fast forward to 2003, back in Greece, that experience landed me a job at <a href="https://en.wikipedia.org/wiki/Forthnet">Forthnet</a> which created a career trajectory as a Java Developer.</p>
<p>Starting with <a href="https://en.wikipedia.org/wiki/Java_Platform%2C_Enterprise_Edition">Java EE</a> as a junior developer gave ample room to grow. I practiced <a href="https://qnoid.com/2010/10/12/conclusion-dont-lose-your-train-of-thoughts.html#main">object oriented programming</a>. I got a grasp of HTTP and the web. I learned about databases, multithreading, linux, servers and infrastructure. Even though I was a junior developer, I was given plenty of autonomy and responsibility. The last professional role I held as a Java developer was in 2011. That&rsquo;s roughly 10 years of dedication to the platform, though just recently I wrote a full blown Java EE 8.0 application that served as the backend for Windmill. It felt like riding a bicycle.</p>
<p>Becoming an Apple developer was a different story altogether. Steve Jobs&rsquo; announcement of the iPhone, inspired me. I took the  “CS 193P iPhone Application Development” at Stanford University of my own volition. Java and the web had failed on the promise of a <a href="https://en.wikipedia.org/wiki/Rich_web_application">rich web application</a> and mobile as a platform had just become ready to take off. I saw it as an investment to further grow as a professional and it paid off. I spent the next <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">10 years as an Apple Developer</a>.</p>
<hr>
<p>A few days ago I watched a documentary where I learned about the <a href="https://en.wikipedia.org/wiki/World_Robot_Olympiad">World Robot Olympiad</a> and the non-profit organisation <a href="https://wrohellas.gr">WRO Hellas</a>. WRO Hellas provides training to academics, educational material and robot parts to aspiring robotics engineers living in Greece. It also organises national competitions for mentees to compete. Seeing so many young people passionate about robotics and programming, got me thinking about what I want to be engrossed in for the next 10 years.</p>
<p>I am not sure. I would love to hear your thoughts at <code>markos@qnoid.com</code>.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://www.youtube.com/watch?v=JyWqqqkn2Es">The Real Robokids</a> (in Greek)</li>
<li><a href="https://www.youtube.com/watch?v=x8BOHnLU3qs">Horace Dediu, Asymco - The Innovator&rsquo;s Stopwatch</a></li>
</ul>
]]></description>
        <pubDate>Thu, 23 Jan 2020 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Open-source</title>
        <link>https://qnoid.com/2020/01/21/Opensource.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/01/21/Opensource.html</guid>
        <description><![CDATA[<p>I am not sure <strong>what to make of</strong> open-source software anymore.</p>
<p>I am not referring to <a href="https://en.wikipedia.org/wiki/Copyleft">free and open-source</a> software nor open-source with a commercial license. There is also open-source, like <a href="https://ranchero.com/netnewswire/">NetNewsWire</a> and <a href="https://brew.sh">Homebrew</a> which are free and developed in the open. I am not talking about those either.</p>
<p>I am referring to open-source software addressed to developers.  Open-source software where <strong>a developer is the end user of code</strong>. Code that is available to bring in as a dependency to software you write.</p>
<p><a href="https://qnoid.com/2019/03/06/Standing-on-the-shoulders-of-giants.html#main">I am a user of open-source code</a>. Having said that, adding a dependency to a 3rd party is the exception, not the rule. I believe in writing the code or at the very least, owning it. Own it as in, know how it works, understand it, maintain it as and when required.</p>
<p>As a potential creator of open-source code, I stop and think now. Am I sharing code that will act as a dependency? What are my responsibilities as the original author? How do I manage its development? What purpose does it serve? What risks does it pose? Why does it need to be open source?</p>
<p>Is it merely for educational purposes? I prefer knowledge sharing as opposed to code sharing and I would rather share that knowledge through deliberation, writing and code examples that get to the crux of the matter.</p>
<p>That is not to say that code sharing can&rsquo;t act as knowledge sharing. I have most certainly expanded my knowledge and understanding by reading open-source code.</p>
<p>So, what value does open-source code really bring? Is it about writing it once, used by many? Providing a reference implementation? Time saving? Setting a quality bar, an example? Addressing social inequalities by giving equal access to code?</p>
<hr>
<p>I have been thinking of releasing the source code of <a href="/2020/01/03/Windmill.html#main">Windmill</a>. That is, the code for the macOS app, the iOS app and the backend code written in Java.</p>
<p>The Java implementation could be a useful reference for anyone building a <a href="https://www.oracle.com/java/technologies/java-ee-glance.html">Java EE</a> 8.0 application.</p>
<p>The macOS and iOS implementations are both &ldquo;real world&rdquo; apps that might prove useful as learning material.</p>
<p>The alternative would be for the source code to forever stay in my MacBook Pro as a relic. Still, I am not sure.</p>
<h2 id="a-namerelatedarelated"><a name="Related"></a>Related</h2>
<ul>
<li><a href="https://www.sicpers.info/2020/02/empowered-free-software/">Empowered free software</a></li>
<li><a href="https://blog.burntsushi.net/foss">My FOSS Story by Andrew Gallant</a></li>
<li><a href="https://words.steveklabnik.com/a-sad-day-for-rust">A sad day for Rust</a></li>
<li><a href="https://inessential.com/2019/12/27/how_we_run_the_netnewswire_open_source_p">How We Run the NetNewsWire Open Source Project</a></li>
<li><a href="https://en.wikipedia.org/wiki/Npm_(software)#Notable_breakages">Notable breakages for npm</a></li>
<li><a href="https://www.wired.com/2014/02/gotofail/">Behind iPhone&rsquo;s Critical Security Bug, a Single Bad &lsquo;Goto&rsquo;</a></li>
<li><a href="https://gist.github.com/AlamofireSoftwareFoundation/f784f18f949b95ab733a">A response to recent concerns about security vulnerabilities in AFNetworking</a></li>
</ul>
]]></description>
        <pubDate>Tue, 21 Jan 2020 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The curtain falls on Windmill</title>
        <link>https://qnoid.com/2020/01/03/Windmill.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2020/01/03/Windmill.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/qQzdAsjWGPg" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>This is it. I am officially ending <a href="https://windmill.qnoid.com">Windmill</a>. The writing has been on the wall for <a href="https://qnoid.com/2019/10/29/Windmill.html#main">some time now</a>. I will begin by dismantling the infrastructure that supports Windmill on the iPhone. I will also make a public announcement on the Windmill website. I expect the website to stay up until the domain expires if not sooner.</p>
<p>Windmill made continuous delivery accessible, without compromising on security or privacy and without the added cost that comes with paying for a cloud service. I am very proud of the work I put into Windmill.</p>
<p><img src="/images/2019/09/06/windmill.png" alt=""></p>
<p>Even though some things where <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">outside of my control</a>, I have no regrets. I did pursue my <a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">dream</a> and dedicated more than 12 months of working full time as well as all of my savings.</p>
<p>I did it my way. It is now time to take care of the one I love.</p>
<p><a href="/for-hire.html#main">For hire.</a></p>
]]></description>
        <pubDate>Fri, 03 Jan 2020 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Game Awards</title>
        <link>https://qnoid.com/2019/12/13/Game-Awards.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/12/13/Game-Awards.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/jxAihuiYxuU" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>I watched <a href="https://thegameawards.com">The Game Awards</a> last night. The whole show was oozing with talent, creativity and positivity. I came away feeling inspired.</p>
<p>Special shoutout to</p>
<ul>
<li><a href="https://lualmayen.com/">Lual Mayen</a> who from <a href="https://venturebeat.com/2019/03/23/lual-mayen-from-refugee-to-game-developer/">refugee became a game developer</a>.</li>
<li><a href="https://twitter.com/f_forough">Fereshteh Forough</a> for founding <a href="https://www.codetoinspire.org">Code to Inspire</a> in Afghanistan.</li>
<li><a href="https://apple.news/AeGfBOF_TQsqWW_a113k1Ww">Luke</a> who built the &ldquo;Let&rsquo;s Be Well&rdquo; video game to raise awareness and talk publicly about mental health.</li>
<li><a href="https://twitter.com/Fragorders">Mathew Bergendahl</a> at <a href="https://stackup.org">Stack Up</a> for providing mental health support to war veterans.</li>
</ul>
<p>Kudos <a href="https://twitter.com/geoffkeighley">Geoff Keighley</a> and team for putting on an amazing show and for being a gracious host.</p>
]]></description>
        <pubDate>Fri, 13 Dec 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>MacBook Pro random shutdown fix</title>
        <link>https://qnoid.com/2019/12/09/NoCrashMBP.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/12/09/NoCrashMBP.html</guid>
        <description><![CDATA[<p>I mentioned in the past how the <a href="https://support.apple.com/kb/SP690?locale=en_US">MacBook Pro Retina, 15-inch, Late 2013</a> would <a href="https://qnoid.com/2019/11/10/Apple-State.html#main">randomly shutdown</a> and shared my experience with an <a href="https://qnoid.com/2019/11/15/Apple-Premium-Service-Provider.html#main">Apple Premium Service Provider</a> in Athens, Greece.</p>
<p>I have been running <a href="https://realmacmods.com">RealMacMods</a>, <a href="https://realmacmods.com/product/macbook-pro-nocrash-utility/">NoCrashMBP</a> for over 3 weeks now and I haven&rsquo;t experienced any random shutdowns ever since.</p>
<p>From the RealMacMods website.</p>
<blockquote>
<p>The CPU has several power states and voltages.  Some CPUs have become unstable at the extremely low voltage on one of it&rsquo;s cores.   The CPU will sometimes briefly dip into that power state, and if it happens to be on the core wherein it is unstable you will see the “silent” crash.  Screen goes black, a few seconds later it dies completely.  This condition was observed with external test equipment, as well as through internal cpu voltage monitoring.</p>
</blockquote>
<p>Continued</p>
<blockquote>
<p>This utility runs in the background and keeps it from ever hitting that extremely low state/voltage.</p>
</blockquote>
<p>Indeed the &ldquo;NoCrashMBP&rdquo; app adds a load, at times up to 20% on a 4 core CPU that the MacBook Pro I own has. I haven&rsquo;t taken any measurements on the impact it has on battery. Compared to ~€750 service cost, I&rsquo;ll take the reduced battery performance.</p>
<p>I hope that the MacBook Pro lasts for at least 1-2 years. I&rsquo;ve only had it since April 2014.</p>
<p>Keep in mind that just because this solution worked in my case, it does not mean it will work on yours. For me, spending €9, when I was already at a loss of €340 was a small price to pay. Especially when I was told I had to pay an extra €750 to replace the logic board.</p>
]]></description>
        <pubDate>Mon, 09 Dec 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Apple Premium Service Provider</title>
        <link>https://qnoid.com/2019/11/15/Apple-Premium-Service-Provider.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/11/15/Apple-Premium-Service-Provider.html</guid>
        <description><![CDATA[<p>There is no official Apple presence<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> in Greece. As a result, there are no mail orders, no mail-in option to repair and you have to rely to a 3rd party to service your <a href="https://qnoid.com/2019/11/10/Apple-State.html#main">Apple Hardware</a>.</p>
<p>About 2 months ago, I noticed that the battery on the MacBook Pro (Retina 15-inch, Late 2013) had swollen. I took it to an Apple Premium Service Provider in Greece where I was told that the issue is indeed the battery and would need to be replaced at a cost of €341,81 (€215.33 for the battery plus €126.48 labour cost).</p>
<p>I agreed to the service. After all, the MacBook has a 2.3 GHz Quad-Core Intel Core i7 processor, 16 GB 1600 MHz DDR3 and 512GB SSD PCIe 2.0. It still holds up pretty well to do <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">development</a> so the cost of €340 is minimal compared to the value I get out of it.</p>
<p>As soon as I got the Macbook back, it started to shutdown at random times. The screen would go dark (with some light illuminating), the fans would start to spin and eventually it would shut down. Upon powering it on again, there was never a Panic Report but only once; in the tens of shutdowns.</p>
<blockquote>
<p>panic(cpu 2 caller 0xffffff7f928da528): &ldquo;ino 37945100 no extent covering dstream alloced_size 806912 (fsize 805656) pos/len 868809:0\n&rdquo;@/BuildRoot/Library/Caches/com.apple.xbs/Sources/apfs/apfs-945.275.7/nx/jobj.c:11881</p>
</blockquote>
<p><em><a href="/static/2019/11/15/report.txt">Kernel Panic Report</a></em></p>
<p><strong>Every hardware diagnostic run by the service provider came back green.</strong></p>
<p>Eventually, it took me 2 months to finally get the engineering team at Apple to trace<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> it to a faulty logic board (error 128 they said 🤷🏽‍♂️).</p>
<h4 id="update">Update</h4>
<p>Apparently, you can use <code>log show --predicate 'eventMessage contains &quot;Previous shutdown cause&quot;'</code> to check the shutdown cause.</p>
<p><img src="/static/2019/11/15/shutdown.png" alt=""></p>
<h4 id="end-update">End Update</h4>
<p>I was referred back to the service provider. I am now told, a replacement<sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> logic board will cost about ~€750. At a total price of €1090 to repair the MacBook Pro, repairing it doesn&rsquo;t sound as appealing or worth.</p>
<p>Other than the fact that I <a href="/for-hire.html#main">cannot afford a new MacBook Pro right now</a>, the bitter taste left in my mouth is directly related to the relationship that Apple has with service providers in a country like Greece.</p>
<p>You see, the tools provided to the service provider gave no indication of a faulty motherboard<sup id="fnref:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup>. As a result, I ended up paying €340 only to end up with a Mac that will randomly shutdown. As far as I am concerned, prior to the battery replacement, the MacBook Pro worked as expected. I am now €340 lighter and have a faulty MacBook Pro.</p>
<p>Keep in mind that a service provider is an independent, 3rd party. The manager doesn&rsquo;t have the luxury, the privilege nor the overall profits of Apple to take the hit or provide leeway.</p>
<p>And here is where I take issue with the service options offered by Apple in Greece. The service provider does not have all the required tools to make an overall assessment which in this case has cost me.</p>
<p>In the end, this arrangement is a mark against the reputation of Apple. For Apple to take pride in customer satisfaction in Greece, it must take all the necessary steps to have an Apple Store in Athens.</p>
<h2 id="update-1">Update</h2>
<p>I have now bought the software listed in one of the related links below. At $10 is a low risk to take. <a href="https://qnoid.com/2019/12/09/NoCrashMBP.html#main">I will report back once I have used the Mac for some time</a>.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://apple.stackexchange.com/questions/306714/macbook-pro-15-retina-mid-2014-random-shutdowns">MacBook Pro 15&quot; Retina mid 2014 random shutdowns</a></li>
<li><a href="https://apple.stackexchange.com/questions/126588/are-os-x-shutdown-cause-and-sleep-cause-numbers-listed-explained-anywhere">Are OS X shutdown cause and sleep cause numbers listed/explained anywhere?</a></li>
<li><a href="https://apple.stackexchange.com/questions/212809/shutdown-cause-128">Shutdown Cause -128</a></li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>No Apple Retail Stores, no option to trade-in, no Today at Apple, etc.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>Long story short, after getting in touch with Apple Care, I was sent a &ldquo;Capture Data&rdquo; app which performs a &ldquo;Sysdiagnose&rdquo; with &ldquo;Full Disk Access&rdquo;.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>Since the MacBook Pro is now considered <a href="https://support.apple.com/en-us/HT201624">Vintage</a>, a replacement logic board is not guaranteed to be available.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:4">
<p>Even if I assume that the faulty logic board is a result of the swollen battery, I don&rsquo;t quite understand why as a customer I have to bare that cost too.&#160;<a href="#fnref:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Fri, 15 Nov 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The state of Apple hardware I currently own</title>
        <link>https://qnoid.com/2019/11/10/Apple-State.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/11/10/Apple-State.html</guid>
        <description><![CDATA[<p>I own a <a href="https://support.apple.com/kb/SP690?locale=en_US">MacBook Pro Retina, 15-inch, Late 2013</a>. At the time I bought it, April 2014, I maxed out both the RAM at 16GB and HD at 512GB SSD.</p>
<p>About 2 months ago, I noticed the battery had swollen, so I had it replaced at a cost of ~€340. Since then, I have been experiencing random shutdowns, ranging from every few hours to couple of days. There has been an incredible amount of back and forth with Apple and their Authorised Service Provider in Greece<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>. I won&rsquo;t trouble you with the details<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> suffice to say that I am unable to do any software development on it.</p>
<p>The iPhone X, running iOS 13.2.2, over time seemingly exhausts its network connection pool with Apple services. App Store downloads are stuck forever, sharing a Note via iCloud comes back with a &ldquo;Connection Error&rdquo; etc. At this point, I need to restart the device.</p>
<p>When talking on said iPhone X via the AirPods (1st Gen), people will complain that they have trouble hearing me. At random times, I sound like talking from a distance.</p>
<p>Apple TV (4th Generation) is working fine overall tho I do come across glitches on tvOS from time to time.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>There is no official Apple presence in Greece i.e. Apple Store and no support for mail-in. Effectively you are being treated as a second grade customer while in Greece.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>At this stage, I have sent some sysdiagnose logs and waiting for a response.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Sun, 10 Nov 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The future of Windmill</title>
        <link>https://qnoid.com/2019/10/29/Windmill.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/10/29/Windmill.html</guid>
        <description><![CDATA[<p>The last update on Windmill was really the news about <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">Windmill on the iPhone getting rejected</a>. I have <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">yet to put any more work on Windmill</a>.</p>
<p><a href="https://windmill.qnoid.com/mac/">Windmill on the Mac</a> is a standalone, native, macOS app<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> that has always been free to download and use. Developers don&rsquo;t even need to have an account. I genuinely don&rsquo;t know how many developers do actually use<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> it. I never actively tracked downloads, users, monitored engagement or any other usage metrics. It has been a deliberate decision not to.</p>
<p><a href="https://windmill.qnoid.com/iphone/">Windmill on the iPhone</a> on the other hand, requires significant infrastructure and a backend server. I have been using AWS for that. Even though Windmill on the iPhone never saw the light of day in public, the infrastructure did cost money to operate during setup, development, testing, beta. It still does to this day since I never dismantled it.</p>
<p>Up until now, I have been paying for AWS using credits that Amazon used to offer to startups. The credits have now been depleted<sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> so starting in October, I will have to foot the bill<sup id="fnref:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup>. A couple of days ago I also got a reminder that the Windmill domain will expire soon.</p>
<p>I never made any money on Windmill while <a href="https://windmill.qnoid.com/changelog/">working on it full time</a>. Also, I haven&rsquo;t had a salary since summer 2017. Any savings I had, run out about 12 months ago. Still, it feels hard to bring down the whole thing just like that. I still haven&rsquo;t come to terms with the rejection by Apple and haven&rsquo;t had the head space to decide what to do with Windmill.</p>
<p>I still believe in both the Windmill vision and the product. I just don&rsquo;t have the money and resources to dedicate on time that has now become borrowed.</p>
<p>The future of Windmill is uncertain.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Interesting fact: The codebase is 16k LOC.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>If you do, please let me know via email at <code>markos@qnoid.com</code>&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>Do you know if there is a way to get extra AWS credits?&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:4">
<p>A good friend and for what is worth a prominent member in the Apple community, was kind enough and generous to offer to &ldquo;sponsor&rdquo; the cost of AWS. I don&rsquo;t feel comfortable accepting money while the future of Windmill isn&rsquo;t any clearer.&#160;<a href="#fnref:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Tue, 29 Oct 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>3 months off Twitter</title>
        <link>https://qnoid.com/2019/10/29/Social-Media.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/10/29/Social-Media.html</guid>
        <description><![CDATA[<p>It has been about 3 months since I have deleted my Twitter account. I had been an avid user for 10 years.</p>
<p>I don&rsquo;t miss it and I am happier.</p>
<p>At the time it felt important. I could reach out to others and others could reach out. I was &ldquo;in the know&rdquo;.</p>
<p>I am enjoying the focus. No one seems to be missing &ldquo;qnoid&rdquo; either.</p>
<p>It&rsquo;s all good!</p>
]]></description>
        <pubDate>Tue, 29 Oct 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Taking back control of my life&#39;s narrative</title>
        <link>https://qnoid.com/2019/10/03/Control.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/10/03/Control.html</guid>
        <description><![CDATA[<blockquote>
<p><em>This is a deeply personal post. It is a way for me to process, come to terms with, move forward and take back control of my life. I don&rsquo;t have any advice to offer or lessons to teach yet. I am still caught into this. I don&rsquo;t know how this story ends.</em></p>
</blockquote>
<p>I was raised by a single mother.</p>
<p>Born in the eighties. My mother was a hairdresser, running her own beauty salon just around the corner from a single bedroom flat where we both lived, in Athens. She was just 21 when she gave birth.</p>
<p>I grew up being quite independent. I had my own keys to the flat. I used to come back from primary school, an eight minutes walk, eat food mom had prepared for me, watch TV, study for school, study English with a private teacher, draw cartoon covers, use a computer.</p>
<p>Mom was working 6 days a week. When I wasn&rsquo;t at home alone, I would be spending time with my best friend next door or at the beauty salon. I remember asking her to give me a &ldquo;perm&rdquo; hairstyle like everyone else.</p>
<p><strong>These are memories I have; I was also told differently.</strong></p>
<hr>
<p>My &ldquo;parents&rdquo; separated when I was 4. My &ldquo;father&rdquo; used to pick me up after school in the evenings when my mother was working.</p>
<p>My mom had stayed good friends with him after they separated. He was living just a couple of blocks away from my mom. I could visit him whenever I wanted.</p>
<p>He is the one that bought me my first computer at the age of 8.</p>
<p>I never felt close to him. He was rarely around. He never advised me, gave me guidance, showed much affection or interest, took me to the park, parent me.</p>
<p>I don&rsquo;t remember much of him at that age.</p>
<p>As a teenager and through adulthood, our relationship was no different. I had conversations with friends about it in an effort to understand. What was their relationship like with their dad? They would tell me how their father isn&rsquo;t that close to them either. How they would argue or not share much affection.</p>
<p>Still, their answers, reasoning and life didn&rsquo;t look the same to me like how I was feeling. I could tell they had a father figure. At the age of 35 I told the man, in tears, that he had been absent for all my life. That I needed him to be there for me. I got no reaction at all.</p>
<p>A few months later, the universe would conspire to reveal the truth.</p>
<hr>
<p>It had been less than a year since my engagement had broken down and now I had been dealt this hand. I was technically living in Edinburgh at the time. I had <a href="https://qnoid.com/2019/09/17/Connection-reset-by-peer.html#main">quit</a> my last job and had been <a href="https://qnoid.com/2015/02/25/The-price-of-freedom.html#main">on the move</a> for close to 6 months. Savings were running out so I decided to <a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html#main">move to London</a>.</p>
<p>In the years that followed, every time I would be back in Greece, I would share with friends what little I knew. They wouldn&rsquo;t act surprised as if they knew something more. It felt like being in <a href="https://en.wikipedia.org/wiki/The_Truman_Show">The Truman Show</a>. I just couldn&rsquo;t deal with what curveball the universe had just thrown at me.</p>
<p>In a twist of fate I ended <a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">back in Athens</a> almost 3 years later. I don&rsquo;t know how I managed to pull whatever strength I had <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">left in me</a>. It was fucking hard. I decided to confront this man and face reality.</p>
<p>Thirty-eight years later, the truth had finally come to light.</p>
<p><strong>This man wasn&rsquo;t my father.</strong></p>
<hr>
<p>I never met my father, neither had a father figure in my life. I was raised by women.</p>
<p>My mother.</p>
<p><img src="/images/2019/10/03/mom.jpg" alt=""></p>
<p>My <a href="https://qnoid.com/2015/12/09/To-be-celebrated-as-a-human.html#main">grandma</a>.</p>
<p><img src="/images/2019/10/03/grandma.jpg" alt=""></p>
<p>My godmother.</p>
<p><img src="/images/2019/10/03/nona.jpg" alt=""></p>
<p>By all the women coming to the beauty salon, telling me stories, showing me affection. By all the women looking after me when I was sick or had to spend an evening with when mom was away.</p>
<hr>
<p>A man&rsquo;s lie for close to 40 years, that he was willing to take with him to the grave, defined what turn my life would take right at the minute I was born. At 02:10 that fateful Monday summer morning in 1980.</p>
<p>I am not the type to second guess or have regrets about my choices in life. Still, I can&rsquo;t help but think how different my life would have been.</p>
<p>This is a choice that someone else made about what path my life should take. I had no say in this. This was not a choice I made. To this day, I am still <a href="https://qnoid.com/2019/09/24/Respect-the-baby-steps.html#main">facing the repercussions</a>.</p>
<p>At the age of ten, my mom had her second marriage which lasted for four years.</p>
<p>My stepdad was a bully.-</p>
<p><img src="/images/2019/10/03/me.png" alt=""></p>
]]></description>
        <pubDate>Thu, 03 Oct 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Respect the baby steps</title>
        <link>https://qnoid.com/2019/09/24/Respect-the-baby-steps.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/09/24/Respect-the-baby-steps.html</guid>
        <description><![CDATA[<blockquote>
<p>&ldquo;Respect the baby steps.&rdquo; - Dimitra</p>
</blockquote>
<p>I have gotten used to having to deal with big changes that are happening in my life.</p>
<p>In the begining, those changes were dealt like a deck of cards. Until I started embrasing them. I have become the orchestrator. I am not afraid of change. I even get a kick out of it. I swallow change.</p>
<p>These are a few<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> highlights of change.</p>
<p>I left Greece when I was 18 to study in Sunderland, UK. It was a planned, coordinated move. I wanted to study computing after all. My girlfriend at the time, had already been there for a year. It was meant to be an easy move. Two months into it, we had a falling-out. I made the choice to move out.</p>
<p><img src="/images/2019/09/24/sunderland.png" alt="">
<em>Saint Peter&rsquo;s Campus, Sunderland University</em></p>
<p>I dealt with it. Packed my stuff. Talked to the students&rsquo; union. Made financial arrangements. Within a few days I was living in a new flat in different university halls. It was a traumatising experience but I took it in stride.</p>
<p>Three years later, I decided to take a placement year at CERN. My British peers were reluctant to leave the UK. To me it was yet another country to live in. I flew in Geneva. Since there was no direct bus from the airport to the campus, I had to get off at Route de Meyrin.</p>
<p>I remember, standing at a bus stop, in the middle of the night, thinking that if something was to go horribly wrong<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>, it would take days before anyone found out. I was all alone and hadn&rsquo;t met anyone personally yet.</p>
<p>With the aid of a secretary, I got an upfront payment and found a place to stay in Saint-Genis-Pouilly. About halfway through the tenancy, I moved to Ferney-Voltaire. I had to and I just did.</p>
<p><img src="/images/2019/09/24/cern.png" alt="">
<em>CERN campus, 2001 - 2002</em></p>
<p>In May of 2010 while living in Greece, I got an offer to join an Edinburgh based startup for 4 months. Within a day, I had accepted and booked tickets. 3 days later I had a suitcase packed, locked the door to my flat and left.</p>
<p>People were left wondering:</p>
<blockquote>
<p>&ldquo;Are you moving back to the UK now or what?&rdquo;.</p>
</blockquote>
<p>I didn&rsquo;t know the answer. All I knew was that I had a job for 4 months. I ended up living and working in Edinburgh for 5 years.</p>
<p><img src="/images/2019/09/24/edinburgh.png" alt=""></p>
<p>In October of 2014, my engagement broke down. At the time, I was visiting Greece when I realised I had to find temporary accomodation in Edinburgh to stay and be back at work just a few days later. In just over 2 weeks I had completely changed my life!</p>
<p>Let me spell this out. I flew in Edinburgh, stayed in temporary housing while going to work every morning, did viewings, got out of a hairy situation, found a flat, made arrangements to move in, got my personal belongings and moved in to my new place. I did it all within 17 days! I even made sure to have internet on day 1. 🤷🏽‍♂️</p>
<p><img src="/images/2019/09/24/flat.png" alt="">
<em>First night at the new flat</em></p>
<p>On the last week of July 2015, after 6 months of <a href="https://qnoid.com/2015/02/25/The-price-of-freedom.html#main">failing to take control of my life</a>, I decided it was time to move to London. To kick me into overdrive, I simply booked a one way train ticket to <a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html#main">King’s Cross</a> and said to myself:</p>
<blockquote>
<p>&ldquo;You are going to London in 5 days. Deal with it!&rdquo;.</p>
</blockquote>
<p>I gave notice to the landlord, arranged for a moving company, packed 5 boxes and left without having a job lined up. One month later, I started working for <a href="https://www.soldo.com">Soldo</a>. The office at the time was near Baker Street and I had found a flat just 20 minutes away on foot, in London. It was bonkers!</p>
<p><img src="/images/2019/09/24/london.png" alt="">
<em>Leaving on a one way ticket to London</em></p>
<p>Fast forward in December 2017 I moved to Australia. A few months in I had to <a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">retreat to Greece</a>. All in the midst of building <a href="https://qnoid.com/2019/09/06/Apple-Developer.html#main">Windmill</a>. You get the deal by now.</p>
<hr>
<blockquote>
<p>I do not respect the baby steps.</p>
</blockquote>
<p>I do not appreciate what it takes to carry each of those big changes. I do not sit to think how difficult it is to take those steps. I brush them to the side. I don&rsquo;t think much of them. As far as I am concerned. I just need to do whatever needs to be done to go from A to B. Get on with it and move on. That&rsquo;s what I have been doing. That&rsquo;s what I am good at, I guess.</p>
<p><a href="https://qnoid.com/2019/08/01/Despair.html#main">About 2 months ago</a> I started going to therapy. In the past weeks I had to face my worst fears. Having to deal with feelings and suppressed emotions that I have never dealt with in the past is terrifying.</p>
<p>I have also decided to exit <a href="https://qnoid.com/2019/06/24/Windmill-enters-egg.html#main">egg</a> so that I can focus on what matters.</p>
<p>This brings the biggest change in my life. It is long, tough and requires an even greater fortitude. I have to recognise and accept the effort each step will take. To pace myself.</p>
<p>To respect the baby steps.</p>
<p>✊🏽👶🏽🦶🏽</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>There are plenty, plenty more.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>It&rsquo;s laughable to think of it now. This is Switzerland after all. I remember the front page story of a local newspaper that read &ldquo;Mini market robbed!&rdquo;. Oh, the horror.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Tue, 24 Sep 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Kiva</title>
        <link>https://qnoid.com/2019/09/21/KIVA.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/09/21/KIVA.html</guid>
        <description><![CDATA[<p>Back in 2015, as a birthday present, I got a <a href="https://www.kiva.org/gifts/kiva-cards">Kiva gift card</a>. It&rsquo;s one of the best gifts I have ever received.</p>
<p>Kiva allows you to micro-loan people around the world that are at a financial disadvantage.</p>
<blockquote>
<p>A family in Dushanbe, Tajikistan to help pay their daughter&rsquo;s tuition.</p>
</blockquote>
<blockquote>
<p>A farmer in Kaduna, Nigeria to help them increase yields.</p>
</blockquote>
<blockquote>
<p>A group in Prey Veng, Cambodia to help buy a water filter to provide safe drinking water.</p>
</blockquote>
<blockquote>
<p>A shop owner in Sembabule, Uganda to buy more stock to sell.</p>
</blockquote>
<p>I have to admit, at first I found it overwhelming and difficult to decide. There are so many people that could use whatever little help I could provide. How do I make a choice? What country? What cause? Who needs it the most?</p>
<p>I still don&rsquo;t know how to answer this. I&rsquo;d just tell you to pick one to get you started. Maybe you can relate to the person and their struggle. Maybe you want to tip the scale in <a href="https://www.gatesfoundation.org/goalkeepers/report/2019-report/progress-indicators/gender-equality/">gender inequality</a>. Maybe you want to <a href="https://www.gatesfoundation.org/goalkeepers/report/2019-report/progress-indicators/poverty/">help people get out of poverty</a> first. Maybe <a href="https://www.gatesfoundation.org/goalkeepers/report/2019-report/progress-indicators/education/">education is important</a> to you.</p>
<p>I suggest you start with a short period loan (8 months or less) that <a href="https://www.kiva.org/lend?lenderTerm=0,8&amp;sortBy=expiringSoon">with your contribution will be fulfilled</a>. That way you will see the results of your micro-loan come to fruition sooner.</p>
<p>Regardless, you will no doubt help people in need and make the world a little bit better in the process.</p>
<p>It&rsquo;s amazing how many people you can help over time starting with just a small fund that you relend. I started with $50 and over time I have built up the micro-fund to $150. With that amount of money I have been able to finance 21 loans at a total of $700 over the years.</p>
<p>Next time you have the chance to buy a birthday present to someone consider offering them a Kiva gift card instead. It can change their life and the life of others.</p>
<blockquote>
<p>Greetings from Tanzania! Thank you for supporting Jackson, a hard working retailer at his own retailer shop with a loan. I&rsquo;m pleased to inform you that he is doing extremely well and with the loan received, Jackson used the loan to buy food items, detergents, soft drinks, few stationary items, plastic bags, slippers, and utensils . He used the additional profit to pay his loan dues, school fees, covered household expenses such as water bills and electricity and reinvested for his business to grow. Jackson is very grateful for the loan and thankful to everyone who had supported him.</p>
</blockquote>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://www.gatesfoundation.org/goalkeepers/report/2019-report">Examining inequality. How geography and gender stack the deck for (or against) you.</a> - Bill &amp; Melinda Gates, The goalkeepers report 2019.</li>
</ul>
]]></description>
        <pubDate>Sat, 21 Sep 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Reasons I have resigned, quit or was let go of a job.</title>
        <link>https://qnoid.com/2019/09/17/Connection-reset-by-peer.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/09/17/Connection-reset-by-peer.html</guid>
        <description><![CDATA[<p>I thought I&rsquo;d share this. I get the feeling, we don&rsquo;t talk openly about it. Not that we should. Quite the opposite. Why share then? I hope people will see that leaving a role is part of life and there is nothing more to it.</p>
<p>I believe it&rsquo;s inappropriate to ask this question, it won&rsquo;t get you any meaningful answers and it may lead to awkward conversations and I do mean as part of an interview.</p>
<p>So here are some of the reasons:</p>
<ul>
<li>No room for personal development and future growth.</li>
<li>Not a good culture fit.</li>
<li>Politics, corporate structure, didn&rsquo;t care enough at that point.</li>
<li>Change in technical direction, management style that meant engineering would have a lesser role. Wasn&rsquo;t willing to go down that path.</li>
<li>Not supported enough, change in business priorities.</li>
<li>The writing on the wall lead 3 people to resign in the same week.</li>
<li>Wasn&rsquo;t commited enough or &ldquo;loyal&rdquo; to the company, I think?</li>
</ul>
]]></description>
        <pubDate>Tue, 17 Sep 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>An Apple Developer for 10 years</title>
        <link>https://qnoid.com/2019/09/06/Apple-Developer.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/09/06/Apple-Developer.html</guid>
        <description><![CDATA[<p><img src="/images/2019/09/06/apple.png" alt=""></p>
<p>Back in September of 2009, I was let got of a role as a Java Developer. I had come to Athens looking for a job a few months prior. Instead of looking for another role, I decided to move back to Crete.</p>
<p>At that time, Stanford University was running &ldquo;<a href="https://web.stanford.edu/class/cs193p/cgi-bin/drupal/">CS 193P iPhone Application Development</a>&rdquo; on iTunes U. I took the opportunity to invest in learning what seemed like the future. I was just an avid Mac and iPhone owner for some time.</p>
<p><img src="/images/2019/09/06/CS193P.png" alt=""></p>
<p>Up until that moment I had been a Java Developer with a Web focus. Backend to frontend. An iPhone app was unlike anything I had seen on the web. I think, at that time, the most impressive website I had come across was Google Maps and its use of <a href="https://en.wikipedia.org/wiki/Ajax_%28programming%29">AJAX</a>. It was jaw dropping.</p>
<p>Still, compared to the predominantly stateless nature of a website, <a href="https://qnoid.com/2013/06/13/On-mobile.html#main">building an app for the iPhone</a> enabled me to better express my creativity and build a better experience with less effort as a developer. The user experience possible was immensely better to what I could come up by building a web app.</p>
<p>I remember working on an assignment as part of the curriculum created by <a href="https://twitter.com/edog1203">Evan Doll</a> and <a href="https://twitter.com/accannis">Alan Cannistraro</a> at Stanford. It was a single view app where you could draw a polygon shape. If memory serves me well, the only control was a slider to define the number of angles. As you moved the slider with the touch of your finger, you could instantly see the shape morphing from a triangle, to a square, to a pentagon, a hexagon etc. This interactivity and responsiveness at the palm of your hand felt insanely exciting at the time. I was hooked!</p>
<p>In May 2010 I moved to Edinburgh, Scotland. Even though I was working full time as a Java Developer, I wanted to be an Apple Developer<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>! In my spare time I was working on <a href="https://qnoid.com/2013/08/11/On-sacrifices.html#main">verylargebox</a>. A mobile app that enabled local store owners to share their products with anyone in the city.</p>
<video controls playsinline preload="metadata">
 <source src="/images/2019/09/06/verylergebox.mov" type="video/mp4" />
</video>
<p>In June 2011, I landed my first role as an iOS Developer even though I wasn&rsquo;t really hired based on what I could do as one. It was an entry level role, still it put a smile on my face. I could finally have an Apple Developer section on my resume!</p>
<blockquote>
<p>Fun fact: I subscribed to <a href="https://iosdevweekly.com">iOS Dev Weekly</a> on the 24th of October 2012 and it was already at Issue 65!</p>
</blockquote>
<p>In July 2013, I released verylargebox as a free app. I finally had my very own iPhone app on the App Store, I was proud!</p>
<p><img src="/images/2019/09/06/verylargebox.jpeg" alt=""></p>
<p>Even though I never pursued verylargebox as a business idea, it raised my status as an Apple Developer. I had an app! I felt like I was part of the Apple community.</p>
<p><img src="/images/2019/09/06/verylargebox.png" alt=""></p>
<p>Soon after, I joined Tesco Bank where I was responsible for the technical delivery of Tesco Bank Mobile Banking on the iPhone.</p>
<p>As an Apple Developer, 2014 was special. I traveled to NSConf at Leicester where both Evan Doll and Alan Cannistraro would be there. This was an opportunity to personally meet and greet the people that nudged me to become an Apple Developer.</p>
<p><img src="/images/2019/09/06/nsconf.jpg" alt=""></p>
<p>My bond with Apple as a developer grew stronger and stronger. With every interaction and exposure, I became more involved with the people, more invested in the technology, more attached to Apple.</p>
<p><img src="/images/2019/09/06/dave.png" alt=""></p>
<p>The same year, I won the WWDC lottery and got a chance to meet in person some of the developers at Apple that I have been interacting with on Twitter.</p>
<p><img src="/images/2019/09/06/joar.png" alt=""></p>
<p>I also remember witnessing the winners of Apple Design Awards and dreaming of the day I could develop an app worthy of an award.</p>
<p><img src="/images/2019/09/06/wwdc.png" alt=""></p>
<p>It was around that time, in 2014, when the idea of Windmill popped into my head. At Tesco Bank, I had hacked together a <a href="https://www.youtube.com/watch?v=1Vbn7vd7EWY">continuous delivery pipeline</a> using Jenkins and Apple&rsquo;s <a href="https://qnoid.com/2019/03/13/iOS-automation-the-current-state-of-affairs.html#main">Command Line Tools</a> and I thought there must be a better way to do this.</p>
<video controls playsinline preload="metadata">
 <source src="/images/2019/09/06/windmill.mov" type="video/mp4" />
</video>
<blockquote>
<p>One of the very early iterations of Windmill. Notice, how this is only a menu bar item. Humble beginnings as an Apple Developer for the Mac.</p>
</blockquote>
<p>Of course, I had a full time job at the time. I could only afford to work nights and weekends. Still, I pushed through. With every line of code written, with every technical note read, with every WWDC video watched, I made progress.</p>
<video controls playsinline preload="metadata">
 <source src="/images/2019/09/06/windmill.m4v" type="video/mp4" />
</video>
<p>Years passed. I moved to London. The year was 2016, <a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html#main">I had just left my job</a> and I was <a href="https://qnoid.com/2016/12/01/Thinking-of-quitting-the-software-industry.html#main">thinking of quitting the software industry</a> too.</p>
<p>Still, <a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">I had Windmill to carry me forward</a>. In 2017, I decided it was time to commit to it full time. In September of the same year, I took a leap of faith and jumped into the unknown, being all poetic.</p>
<p>In the years that followed, I had to move from the U.K., to Australia, to Greece. <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">It was shitty and tough</a>.</p>
<p>In between all that (and a lot more on a personal level; not the post to disclose) one thing stayed consistent. My <a href="https://windmill.qnoid.com/changelog">dedication to see Windmill through</a> and in the process take control of my life and destiny.</p>
<p><img src="/images/2019/09/06/windmill.png" alt=""></p>
<p>I pushed long and hard to get Windmill on the iPhone out. I <a href="https://qnoid.com/2019/01/17/User-Accounts.html#main">started working on it</a> in January 2019 and submitted it to Apple at the end of May. It was <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">rejected</a>.</p>
<p>Windmill on the iPhone was a way for me to finally start making a living after 2 years of not making a salary and almost a year since my savings have been depleted.</p>
<p>I haven&rsquo;t done any progress since Apple rejected Windmill.</p>
<p>I am definitely experiencing a <a href="https://hbr.org/2019/07/when-passion-leads-to-burnout">burnout</a>, still there seems to be something more at play that I&rsquo;ve been trying to explain.</p>
<p>Every time I make an effort to think how to overcome this hurdle and continue with the development of Windmill, my brain switches off.</p>
<p>You see, Windmill as I envision it, is more than just a Mac app. Literally and figuratively speaking. It&rsquo;s hard to put this into words, no matter how much I try. It&rsquo;s a vision after all. My dent in the universe.</p>
<blockquote>
<p>Windmill is on a mission to make continuous delivery of iPhone apps ubiquitous and accessible to developers and businesses.</p>
</blockquote>
<p>I don&rsquo;t feel motivated knowing what is possible will be subpar, constrained, unwelcome, unappreciated and on the bad side of Apple. I feel crippled as an Apple Developer to make the best of all available platforms and technologies.</p>
<blockquote>
<p>On a personal level, Windmill allows me to have freedom of expression, be creative and pursue excellence.</p>
</blockquote>
<p>To some extend this a cautionary tale about falling in love with a brand when an organisation is behind it. When the needs of the business precede those of the individual. Still, there is more. In the case of Apple and its developers, this is about our livelihood.</p>
<p>For Apple, this was just an app that was submitted, went through due process and was rejected. For me, this is a moment in time that will define what turn my life takes next.</p>
<p>Thinking back to that September of 2009 when life set me on a path to become an Apple Developer. It feels like that path is ending.-</p>
<p><img src="/images/2019/09/06/apple.jpg" alt=""></p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>I would really like to thank <a href="https://andy.xyz">Andrew Williams</a> who really supported me in my early efforts as an Apple Developer. You have been an inspiration Andy.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Fri, 06 Sep 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Anxiety looks different in men (The Wall Street Journal)</title>
        <link>https://qnoid.com/2019/08/13/Anxiety-Looks-Different-in-Men.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/08/13/Anxiety-Looks-Different-in-Men.html</guid>
        <description><![CDATA[<p>Source: <a href="https://www.wsj.com/articles/anxiety-looks-different-in-men-11564494352?mod=rsswn">Anxiety Looks Different in Men</a> By <a href="https://twitter.com/andreaapetersen">Andrea Petersen</a></p>
<blockquote>
<p>When a man explodes in anger over something seemingly insignificant, he may appear like just a jerk. But he could be anxious.</p>
</blockquote>
<blockquote>
<p>Anxious “men may present as loose cannons, but they are worriers,” says Kevin Chapman, a clinical psychologist in Louisville, Ky. “Aggression tends to be more socially acceptable to many men than anxiety.”</p>
</blockquote>
<blockquote>
<p>In general, men are less likely to receive treatment for mental health issues. “We’ve been socialized from a very young age to see emotional vulnerability as a weakness,” says Michael Addis, a professor of psychology and director of the Men’s Well-Being Research Group at Clark University in Worcester, Mass. “Seeking help is seen as a sign of weakness as well,” for some men.</p>
</blockquote>
<h2 id="how-to-help">How to Help</h2>
<blockquote>
<p>—Be compassionate. Don’t view him as being stubborn, see him as a human being who is struggling with a heavy burden of expectations.</p>
</blockquote>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">Anxiety And Depression</a></li>
</ul>
]]></description>
        <pubDate>Tue, 13 Aug 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Anthony Bourdain - Parts Unknown</title>
        <link>https://qnoid.com/2019/08/12/Antony-Bourdain-Parts-Unknown.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/08/12/Antony-Bourdain-Parts-Unknown.html</guid>
        <description><![CDATA[<p>Have restarted watching <a href="https://explorepartsunknown.com">Parts Unknown</a>.</p>
<p>Antony&rsquo;s narration alongside the superb editing and direction of the show is so immersive that I am immediately transported to the place where he is at.</p>
<p>Antony&rsquo;s genuine curiosity alongside the background research on both the history and the present of a city provides an incredible insight into its political circumstances and people&rsquo;s daily lives.</p>
<p>From Koreatown in Los Angeles to Detroit and Mississippi Delta, south to Mexico City, across the Atlantic Ocean to Libya, north to Russia, east to Punjab, further into Hong Kong and Tokyo, his contribution in learning more about the world is immense.</p>
<p>Teaching us to be open by default, tolerant, curious, caring, respectful to other cultures. Inviting us to travel more, not as tourists but as inquiring minds looking to expand our view of the world. To learn from each other simply by having a conversation while eating together.</p>
<p>I believe it is a show where everyone can learn from and should watch in their lifetime. I don&rsquo;t know what it takes for a Television show to be preserved in the <a href="https://www.loc.gov">Library of Congress</a> but I really think that Parts Unknown should be preserved for its significance and importance.</p>
<p><a href="https://en.wikipedia.org/wiki/Anthony_Bourdain">Anthony</a>, I dearly miss you. <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">Wish I could have saved you</a>.</p>
<blockquote>
<p>Chapter One.</p>
<p>To fall in love with Asia is one thing.<br>
To fall in love in Asia is another.<br>
Both have happened to me.</p>
<p>The Star Ferry to Kowloon at night.<br>
Lights of Hong Kong behind me.<br>
It&rsquo;s a gift, a dream, a curse.</p>
<p>The best thing, the happiest thing, yet also the loneliest thing in the world.</p>
</blockquote>
<iframe width="100%" height="300" scrolling="no" frameborder="no" allow="autoplay" src="https://w.soundcloud.com/player/?url=https%3A//api.soundcloud.com/tracks/453177519&color=%23ff5500&auto_play=false&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true&visual=true"></iframe>]]></description>
        <pubDate>Mon, 12 Aug 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Brain drain</title>
        <link>https://qnoid.com/2019/08/06/Brain-drain.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/08/06/Brain-drain.html</guid>
        <description><![CDATA[<p>I left Greece in May of 2010. I didn&rsquo;t leave because of the <a href="https://en.wikipedia.org/wiki/Greek_government-debt_crisis">crisis</a> which neither had been felt at the time nor people knew how destructive it would be or how long it would last.</p>
<p>I left because of the archaic work mentality and ethos, the lack of options, progress and professionalism. I left because it didn&rsquo;t feel like Greece wanted to change or wanted someone like me<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> to help bring change.</p>
<p>In March of 2018 <a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">fate brought me back</a>. <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">Hard times followed</a> but somehow I managed to endure.</p>
<p>By the end of September of 2018 my savings had been depleted and I didn&rsquo;t want my partner to carry all the load. In the months that followed, before I decided to start the work on <a href="https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html#main">Windmill on the iPhone</a>, I reached out to organisations that were either hiring for a role I could apply (e.g. iPhone Developer) or thought I could contribute in some other capacity.</p>
<p>Here is one of the messages I sent at the time. I have removed a few details to preserve the anonymity of the individuals/companies.</p>
<blockquote>
<p>My name is Markos and I have a software engineering background.</p>
<p>I have been at the helm of Tesco Bank and Soldo to bring organisational change and deliver their iPhone apps.</p>
<p>I have recently moved to Athens from London and I am looking to get involved in the startup ecosystem with the goal of providing aid based on my experience and expertise.</p>
<p>I would love to have a coffee and meet personally in order to explore this further.</p>
<p>I am looking forward to hearing from you.</p>
</blockquote>
<p>Every single one responded. I followed up by emailing <a href="/static/Curriculum%20vitae.pdf">my CV</a> to give even more insight into my background. A couple of them never responded after that.</p>
<p>Those who did respond, we arranged to meet. It became clear that unless there was an open, available role, there wasn&rsquo;t much need for me. One of the responses I got went even further than that.</p>
<ul>
<li>&ldquo;I don&rsquo;t know you and you have no LinkedIn.&rdquo;</li>
</ul>
<p>Here is another experience from applying and interviewing as an iPhone Developer.</p>
<ul>
<li>&ldquo;Why do you want to work as an iPhone Developer?&rdquo;</li>
<li>&ldquo;I am a software engineer. This is part of my skillset and expertise.&rdquo;</li>
<li>&ldquo;Yes but. You are overqualified.&rdquo;</li>
</ul>
<p>That is not the first time I am hearing this alongside the &ldquo;You don&rsquo;t look like a developer.&rdquo;, which would be funny if it wasn&rsquo;t stereotypical.</p>
<p>In another interview, I was confronted with what I would mildly call a hiring process from the past. Questions where in rapid fire mode.</p>
<ul>
<li>&ldquo;Where do you see yourself in 5 years?&rdquo;</li>
<li>&ldquo;What is something you are proud of?&rdquo;</li>
<li>&ldquo;What are you bringing to the table?&rdquo;</li>
<li>&ldquo;Why do you want to work for us?&rdquo;</li>
</ul>
<p>With very little room left for a discussion in-between. Impersonal, prejudicial, biased and formulaic.</p>
<p>When I finally got the opportunity to have a dialogue, (&ldquo;We&rsquo;ve got 10 minutes left if you want to ask any questions.&rdquo;) I challenged by asking the tough questions only to get generic, hollow responses back and PR speak that pat themselves in the back.</p>
<p>For the past few years, there has been all this talk in Greece around the brain drain. It so happens that I am here after all these years. Equipped with skills, carrying the experience, bringing in the knowledge and for what it&rsquo;s worth, <a href="http://windmill.qnoid.com">developing a product</a>. What are some of the reasons to keep staying in Greece?</p>
<p>What is the proposal that Greece makes? Where are the opportunities? How do Greeks find them? Why should Greek emigrants come back?</p>
<p>Maybe this needs to be a coordinated effort between the state and the private sector. A combination of sponsorship, campaigning, incentives at the state level and opportunities, contributions, assessment done at the private level.</p>
<p>Greece as a country, alongside organisations and individuals need to understand that they must be willing to change and be ready to fight for, be challenged, do their homework, adapt and give way to Greek emigrants if they want to reverse the brain drain.</p>
<p><strong>Just doing some thinking out loud,</strong> having been back for over a year now.</p>
<h2 id="related">Related</h2>
<ul>
<li><a href="http://www.ekathimerini.com/242399/article/ekathimerini/news/lack-of-meritocracy-still-driving-brain-drain">Lack of meritocracy still driving brain drain</a></li>
<li><a href="http://www.ekathimerini.com/242022/article/ekathimerini/community/young-greeks-unwilling-to-return">Young Greeks unwilling to return</a></li>
<li><a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html#main">Timing&rsquo;s A Bitch</a></li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>I left Greece as soon as I finished high school to study Information Technology at Sunderland University in the UK. I spent 1 year working at CERN in Geneva during my placement year. I even started working in the UK after I finish my studies. I decided to return to Greece in 2003, I wanted to live, contribute, shape and be part of its future.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Tue, 06 Aug 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Stavros Niarchos Foundation Cultural Center</title>
        <link>https://qnoid.com/2019/08/05/Stavros-Niarchos-Foundation-Cultural-Center.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/08/05/Stavros-Niarchos-Foundation-Cultural-Center.html</guid>
        <description><![CDATA[<blockquote>
<p>A multifunctional, environmentally sustainable center of education, arts, sports and recreation.</p>
</blockquote>
<p>The <a href="https://www.snfcc.org/en/stavros-niarchos-foundation">Stavros Niarchos Foundation</a> - <a href="https://www.snfcc.org/en/snfcc/meet-the-snfcc">Cultural Center</a>, based in Athens is home to the <a href="https://www.snfcc.org/en/greek-national-opera-0">Greek National Opera</a> and <a href="https://www.snfcc.org/en/national-library-greece">the National Library of Greece</a>.</p>
<p>You might have come across it when <a href="https://www.youtube.com/watch?v=8ImaVqGyogc">Obama gave a speech about Democracy</a> on his last trip as <a href="https://www.youtube.com/watch?v=ct_54shfkuA">the President of the United States in Greece</a> during his last days in office.</p>
<p>For all of August, there are <a href="https://www.snfcc.org/en/events/guided-tours-snfcc/4975">Guided Tours at the SNFCC</a>.</p>
<p>Even if you have visited the SNFCC, the guided tour will give you an oral history of its origins, backstory, architecture as well as backstage access to the Greek National Opera.</p>
<p>I decided to take the tour and came out inspired, elevated and joyful.</p>
<p>A few notable insights.</p>
<p>The Culture Center itself runs on solar energy that covers 100% of its consumption during the summer and 20% during the winter.</p>
<p>In the National Library, there are about 800K books available with an overall capacity of 2 Million.</p>
<p>Also accessible to the public are,</p>
<ul>
<li>Two fully equipped audio recording studios.</li>
<li>One fully equipped studio for shooting, recording and editing video.</li>
<li>Reading rooms.</li>
<li>Available space for researchers to study, publish and digitise any archives.</li>
<li>Desk space. Extremely busy during exam reading season.</li>
<li>A computer hall.</li>
</ul>
<p>At the Greek National Opera,</p>
<ul>
<li>The main stage is 16x16 meters.</li>
<li>Each seat has a screen to show subtitles in English, in Greek, with more coming. The screen is aligned with the viewer and the stage for optimal reading!</li>
<li>There are 3 additional stages of the same size that move in and out of the main area to support multiple plays in a single day.</li>
<li>There is an &ldquo;alternative stage&rdquo; room that can be reconfigured on demand to host a variety of music events.</li>
<li>There is a room for ballet practice.</li>
<li>A soundproof room for choirs.</li>
<li>A room to accommodate and record an orchestra.</li>
</ul>
<p>There are many many more tidbits that you can learn <a href="https://www.snfcc.org/en/events/guided-tours-snfcc/4975">on the tour</a> so I won&rsquo;t spoil everything here.</p>
<p>Until the end of August, there is also a Photo Exhibition in honour of <a href="https://en.wikipedia.org/wiki/Yannis_Behrakis">Yannis Behrakis</a> who only recently passed away. I urge you to visit that too. His photographic journey is incredibly moving, powerful and topical.-</p>
<p><a href="https://www.snfcc.org/en/events/apw-eyewitness-yannis-behrakis-exhibition-extended-until-3108/4430">APW: Eyewitness / Yannis Behrakis: Exhibition</a></p>
<p><img src="/images/2019/08/05/IMG_0949.png" alt="">
<img src="/images/2019/08/05/IMG_0950.png" alt="">
<img src="/images/2019/08/05/IMG_0951.png" alt="">
<img src="/images/2019/08/05/IMG_0952.png" alt=""></p>
]]></description>
        <pubDate>Mon, 05 Aug 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Despair</title>
        <link>https://qnoid.com/2019/08/01/Despair.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/08/01/Despair.html</guid>
        <description><![CDATA[<p>For the past 3 weeks, there is a growing feeling of despair. I feel powerless, I feel like it&rsquo;s meaningless to fight for the life I want to have, I feel like there is little support to help me push through and the obstacles just keep coming.</p>
<p>For the past 3 weeks, I&rsquo;ve been in limbo.</p>
<p>I decided to shut down Twitter after 10 years. The last few months I have been gradually tweeting less and never kept more than 30 days of tweets on my timeline.</p>
<p>It was the last remaining social media presence<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>. It&rsquo;s been over a year since I deleted Facebook and Instagram.</p>
<p>Social media has become more and more hideous to the point that it makes me feel like shit. I don&rsquo;t need this. There is a plethora of reporting done by major publishers and research if you need to understand more.</p>
<p>Personally speaking, this idea of social status (followers, likes and shit) along with the lack of social cues only leads to more entitlement and less courtesy. Let me put it differently.</p>
<p><strong>On social media, you don&rsquo;t know anyone long or good enough to be shitty. So take your vile behaviour and go take a breather before you start attacking.</strong></p>
<p><a href="https://qnoid.com/2016/03/28/Diversity-and-Inclusion.html#main">I&rsquo;ve had it</a>. I prefer the safety and comfort of my website. The discussions that can be done across people&rsquo;s blogs and the personal, private, thoughtful relationship I can have over email one-on-one.</p>
<p>It doesn&rsquo;t help that as society we are absolutely fucking clueless on how to deal with people that are <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">mentally struggling</a> and I&rsquo;ve been struggling in the past 3 weeks, again.</p>
<p>A few days back, I can&rsquo;t remember where now, I think it was an interview of Tarantino, he said something along these lines.</p>
<blockquote>
<p>We don&rsquo;t push people when they have twisted their ankle. We don&rsquo;t go up to them telling to move on. Why do we do that with people that are struggling mentally? Why do we push them?</p>
</blockquote>
<p>I am really naive as a person. I take everything that people tell me at face value. I believe everything I see. I don&rsquo;t have a hidden agenda and I tend to believe that people do not need to have one either. Why would you if you can just be honest? Fear.</p>
<p>Right now, I am at a loss. I don&rsquo;t know how to move forward in my life. It&rsquo;s coming up to <a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">2 years since I left London</a>, I have been <a href="https://qnoid.com/2016/12/01/Thinking-of-quitting-the-software-industry.html#main">disappointed so much by the software industry</a> and <a href="/software-engineer">I have heavy doubts</a> there is a business out there where I can professionally and personally grow, find purpose, work among great people and be me all at the same time.-</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>I also used to have LinkedIn and had it deleted years ago. &ldquo;I was told&rdquo; I need to have a presence for &ldquo;business development&rdquo;, so I opted to create the account again recently. Jeez.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Thu, 01 Aug 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Where is Windmill on the iPhone?</title>
        <link>https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/07/29/Windmill-on-the-iPhone.html</guid>
        <description><![CDATA[<p><em>Approximately 10&rsquo; minutes reading time.</em></p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/07/29/windmill.mp4" type="video/mp4" />
</video>
<p><a href="https://qnoid.com/2019/03/15/Moving-the-needle.html#main">Moving the needle</a></p>
<blockquote>
<p>I am hearing from the developer community there is a broader concern around the restrictions and the limitation on the tools Apple provides and allows.
I want to kick-off a discussion about this to address these shortcomings. How should Apple enable developers to improve on the tooling for the iOS development ecosystem? I&rsquo;d love to hear your thoughts.</p>
</blockquote>
<p>Some of the questions to get the conversation going:</p>
<ul>
<li>How are existing developer tools limited when building for Apple Platforms?</li>
<li>Are you using a 3rd party developer tool and why?</li>
<li>Did you feel the need to build a developer tool, why?</li>
<li>How should Apple improve on its tooling and resources made available to developers?</li>
<li>Do you think iOS should have a dedicated &ldquo;Developer Tools&rdquo; section?</li>
</ul>
<p>I will add what you’re saying below. Please mention <a href="https://twitter.com/windmill_io">@windmill_io</a> to help me track your responses.</p>
<blockquote>
<p>I wish Apple were better at collaborating with the developer community, instead of just controlling it. If Apple stopped trying to do everything itself, focused on just building a great platform, and let us solve our own problems, everyone would win.</p>
</blockquote>
<ul>
<li><a href="https://twitter.com/ashfurrow/status/1155856796554166273">Ash Furrow 🏳️‍🌈</a></li>
</ul>
<blockquote>
<p>Apple should be in the business of fostering creative solutions to lots of different problems instead of shutting them out.</p>
</blockquote>
<ul>
<li><a href="https://jsorge.net/2019/07/29/where-is-windmill-on-iphone">Jared Sorge</a></li>
</ul>
<blockquote>
<p>Let’s see if planting the seed of making the language and some frameworks open source can grow into a more open ecosystem of tooling. The closeness of Xcode is one of the things that annoys me the most.</p>
</blockquote>
<ul>
<li><a href="https://twitter.com/pedropbuendia/status/1156169932087992322">Pedro</a></li>
</ul>
<blockquote>
<p>I don’t understand all the issues here, I admit, but I start by thinking that useful developer tools should be allowed on the App Store.</p>
</blockquote>
<ul>
<li><a href="https://micro.inessential.com/2019/07/29/windmill-for-iphone.html">Brent Simmons</a></li>
</ul>
<blockquote>
<p>Apple’s loss ultimately when people stop innovating for their platforms</p>
</blockquote>
<ul>
<li><a href="https://twitter.com/_sa_s/status/1155822028068405248">Sven A. Schmidt</a></li>
</ul>
<h2 id="table-of-contents">Table of Contents</h2>
<div class="toc">
<ul>
<li><a href="#Introduction">Introduction</a></li>
<li><a href="#Rejected">Rejected</a></li>
<li><a href="#I_understand">I understand</a></li>
<li><a href="#I_don't_understand">I don&rsquo;t understand</a></li>
<li><a href="#Reconciliation">Reconciliation</a></li>
<li><a href="#One_more_thing">One more thing</a></li>
<li><a href="#A_call_for_discussion">A call for discussion</a></li>
</ul>
</div>
<h2 id="a-nameintroductionaintroduction"><a name="Introduction"></a>Introduction</h2>
<p><a href="https://windmill.qnoid.com/iphone">Windmill on the iPhone</a> allows an organisation with an iPhone app under development to make that app available for distribution on any devices they own, as documented in the <a href="https://help.apple.com/deployment/ios/#/apda0e3426d7">iOS Deployment Reference</a>.</p>
<p>It makes use of <a href="https://developer.apple.com/programs/whats-included">ad-hoc distribution</a> to make it <a href="https://www.youtube.com/watch?v=Hiej50wpBIg">dead easy to get started</a> as a small- to medium-size business, with app distribution to half a dozen or so devices, while progressing towards TestFlight.</p>
<p>It allows businesses to distribute their app <strong>continuously</strong> while still in development, at regular time intervals, on demand, or as a reaction.</p>
<ul>
<li>As individual contractors, it enables them to show progress to a client offsite and deploy bug fixes, at will, in time-critical moments.</li>
<li>As part of a team, it enables them to have nightly builds to get daily feedback from a product owner.</li>
<li>As part of an organisation, it enables them to have weekly meetings with the business and marketing team to do a demo, discuss, and plan next week’s development.</li>
</ul>
<p><img src="/static/2019/07/29/distribution.png" alt=""></p>
<p><a href="https://windmill.qnoid.com/mac">Windmill on the Mac</a> continuously monitors the codebase, as made available in a git repository, so that every time a developer pushes a code change, it ensures the app still works. A developer starts using it as soon as they start working on an iPhone app.</p>
<p>It runs on Apple hardware that the organisation owns, on their premises. Therefore, it does not expect them to hand over their Apple Credentials, Distribution Certificate, Private Key, and Provisioning Profile, making it more secure than systems asking developers to hand these files over and keep them stored on their behalf.</p>
<p>Windmill can scale up to a platform where an organisation runs multiple instances of Windmill on the Mac on the available hardware to <a href="https://windmill.qnoid.com/blog/Windmill-Introducing-Workflow.html">define a workflow</a> and enforce security requirements.</p>
<p>An organisation in a small office with 2 developers and 1 product owner would have each developer running Windmill on their development Mac monitoring their respective feature branch, as well as an instance of Windmill running on a dedicated Mac mini monitoring the master branch.</p>
<p>This way, each developer gets feedback on their own codebase while the Mac mini holds the Distribution Certificate and Private Key to distribute releases and report on merges. This allows an organisation to have an overall view, a shared knowledge and centralised security on their app. Does the app compile? Are tests available and passing? Can the app be installed on a device? Can we release on the App Store?</p>
<h2 id="a-namerejectedarejected"><a name="Rejected"></a>Rejected</h2>
<p>Unfortunately, Apple has firmly rejected Windmill on the iPhone. Windmill on the Mac does not seem to have Apple&rsquo;s blessing either.</p>
<p>To Apple&rsquo;s credit, they did take their time evaluating Windmill on the iPhone and Windmill overall.</p>
<p>Windmill on the iPhone was in Review for over 20 work days and an additional 5 after I sent an eight-page “Letter of Appeal” to the App Review Team with the following:</p>
<ul>
<li>An overarching description that explains what Windmill does, <strong>why I think it’s useful for developers</strong>, why it does not violate the App Store Guidelines and Apple Developer Program License Agreement, and <strong>how Apple benefits</strong> by approving Windmill.</li>
<li>The <strong>security considerations</strong> and <strong>implementation details</strong> that went into Windmill, <strong>for full transparency</strong> in an effort to make Apple feel comfortable about Windmill.</li>
<li>In detail, why I believe Windmill complies with the App Store Review Guidelines and the Apple Developer Program License Agreement.</li>
<li>Some thoughts on how the Mac and the iPhone are governed by two very distinct sets of rules and how the App Store on iOS does not even have a dedicated &ldquo;Developer Tools&rdquo; section.</li>
</ul>
<p>I have been on a call with the App Review Team at Apple twice. I was told that Windmill on the iPhone is “not acceptable” to be on the App Store. Additionally, taking a “holistic” look at Windmill I was told that “conceptually” it is in violation of the Apple Developer Program License Agreement.</p>
<p>I also emailed an Apple Developer Tools Evangelist asking for help to find a way forward with Windmill and for some course correction to be done. That was more than 2 weeks ago. I haven&rsquo;t received a reply.</p>
<p>It&rsquo;s been really hard to come to terms with this. I fought really hard for Windmill.</p>
<p>I both understand where Apple is coming from and I don’t.</p>
<h3 id="update">Update</h3>
<p>I was reminded of one very specific reason that I was given too.</p>
<p><strong>Guideline 5.2.5 - Legal - Intellectual Property</strong></p>
<blockquote>
<p>YOUR APP IS TOO SIMILAR TO TESTFLIGHT, WHICH CREATES A MISLEADING ASSOCIATION WITH APPLE PRODUCTS. WE ENCOURAGE YOU TO REVIEW YOUR APP CONCEPT AND EVALUATE WHETHER YOU CAN INCORPORATE DIFFERENT CONTENT AND FEATURES TO BRING IT INTO COMPLIANCE WITH THE APP STORE REVIEW GUIDELINES.</p>
</blockquote>
<h2 id="a-namei_understandai-understand"><a name="I_understand"></a>I understand</h2>
<p>Apple seems to take issue with the fact that Windmill is meant to be used for development, in-house, but Windmill on the iPhone was meant to be made available on the App Store.</p>
<p><strong>More importantly</strong>. Apple took the stance that the <a href="https://developer.apple.com/library/archive/technotes/tn2339/_index.html">Command Line Tools Package</a> is only meant to be used by developers in-house and <strong>not</strong> by 3rd parties to provide support for continuous integration systems - continuous delivery in the case of Windmill.</p>
<p>Before you gasp, <strong>here is the nuance</strong> as I understand it<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>.</p>
<p>Apple takes issue that Windmill makes it effortless for developers to create a distribution mechanism for their apps outside the control of Apple and the safety of the App Store and TestFlight.</p>
<blockquote>
<p>Hosting of pre-release software through means outside of the app store and facilitating developers to use their certificate, provisioning profile to do so is not permitted.</p>
</blockquote>
<p>Even though ad-hoc distribution is limited, Windmill imposes strong security requirements and is designed for in-house use only.</p>
<p>After all, Windmill is available to every developer. Not just organisations with the know-how. Its mission is to make continuous delivery of iPhone apps ubiquitous and accessible to developers and businesses in an effort to improve consistency, a high level of understanding and agreement across the industry.</p>
<p>It doesn’t seem to matter what Windmill is designed to be used for but  <strong>what it could be used for</strong>. It is precisely why Apple had to say that the <a href="https://developer.apple.com/library/archive/technotes/tn2339/_index.html">Command Line Tools Package</a> is only meant to be used by developers alone.</p>
<blockquote>
<p>Xcode command line tools are only provided by Apple to developers to automate building, testing and distributing their app.</p>
</blockquote>
<p>Had an organisation built Windmill for internal use, distribution would be under their control, used exclusively for their apps, and operating in their internal network.</p>
<p>Windmill on the iPhone would probably be built and distributed using an Enterprise Certificate, internally to the employees of the organisation or using ad-hoc distribution. In this case, it wouldn’t matter since it’s internal to the organisation.</p>
<p>Even Xcode Server, Apple&rsquo;s home grown offering to in-house continuous integration and distribution comes bundled with a web server, &ldquo;where you and members of your development team can <strong>use a web browser to</strong> view the status of bot integrations and <strong>download assets and products</strong>.&rdquo; See <a href="https://developer.apple.com/library/archive/documentation/IDEs/Conceptual/xcode_guide-continuous_integration/">Monitor and Manage Bots</a>.</p>
<h2 id="a-namei_dont_understandai-dont-understand"><a name="I_don't_understand"></a>I don&rsquo;t understand</h2>
<p>Windmill does not operate outside of the boundaries as defined by Apple.</p>
<ul>
<li>It expects that an organisation is registered with the Apple Developer Program.</li>
<li>It expects an installation of the tools in any development Mac where Windmill is used. <strong>Windmill itself does not come bundled</strong> with the <a href="https://developer.apple.com/library/archive/technotes/tn2339/_index.html">Command Line Tools Package</a>.</li>
<li>It manages signing based on the Apple Developer Team of the developer, organisation.</li>
<li>It uses whatever Distribution Certificate and Provisioning Profile is managed by Xcode.</li>
<li>It is limited by ad-hoc distribution device limits.</li>
</ul>
<p>Windmill could not be used to distribute apps to the public, circumventing TestFlight and the App Store anymore than a developer can do today without Windmill or using existing services that offer ad-hoc distribution on the web.</p>
<p>Windmill plays by every Apple rule. It does not ask a for Apple credentials. It does not manage signing outside of Xcode. It does not ask for the private key and distribution certificate. It does everything that a developer could do today, with better security and privacy than an equivalent service on the cloud. There is <a href="https://www.macstadium.com/ios-devops-survey">a whole industry</a> providing automation and distribution as a service for Apple platforms on the web.</p>
<p>Windmill may be the only third-party native macOS continuous delivery app available on Apple platforms but it probably comes   last in offering such a service to developers.</p>
<h2 id="a-namereconciliationareconciliation"><a name="Reconciliation"></a>Reconciliation</h2>
<p>I wish Windmill on the Mac was also on the App Store. Reviewed, approved, endorsed and recommended by Apple. The decision to build Windmill on macOS and iOS has become a liability.</p>
<p>With Windmill, I effectively asked Apple to weigh in on the matter and Apple has decided that the risk far outweighs the benefits that Windmill has compared to existing offerings outside the Apple ecosystem.</p>
<p>It is possible that Windmill can only live within the confines of the <a href="https://developer.apple.com/business/distribute/">Apple Business Manager</a> with Windmill on the iPhone as a <a href="https://www.coletiv.com/blog/distribute-custom-b2b-ios-app">Custom App</a>. Which does not help fulfil its mission.</p>
<blockquote>
<p>Collectively as an iOS community, we have spent an insane amount of time and put an immense amount of effort in automating the delivery of our apps by writing flaky scripts in bash using Jenkins, reverse engineering the Xcode project file format, writing blog posts with our findings.
Yet we are none the wiser and have barely made a dent. - <a href="https://qnoid.com/2019/03/13/iOS-automation-the-current-state-of-affairs.html#main">iOS Automation - The Current State of Affairs</a></p>
</blockquote>
<p>I completely misread the situation with Apple. It does not make it any easier that Apple has a tendency to be overly protective of the ecosystem. I understand why, I just wish Apple had embraced Windmill.</p>
<p><a href="https://qnoid.com/2019/06/24/Windmill-enters-egg.html#main">I had made plans</a> to take Windmill even further, beyond distribution, onto other Apple platforms. Now, I am not sure what I can do while Apple stays silent.</p>
<h2 id="a-nameone_more_thingaone-more-thing"><a name="One_more_thing"></a>One more thing</h2>
<p>Windmill is the culmination of the experience I have accumulated as a developer over the past 15 or so years. On top of that, it took months of research and development on the Mac, on the server, and on the iPhone, paying great attention to the user experience as well as security and privacy that would not and cannot be made possible without deeply integrating with Apple’s tools, platforms and services.</p>
<p>I can&rsquo;t help but feel disappointed and highly discouraged after all <a href="https://windmill.qnoid.com/changelog">the work I&rsquo;ve put</a> in improving the tooling available to developers.</p>
<p>I would like to express my deepest gratitude to everyone at the <a href="http://seattlexcoders.org">Seattle Xcoders</a> group. They have been very supportive all this time when I struggled mentally and needed them the most.</p>
<p>Thank you Brent, Jared, Tom, Tim, Marc, Jeff for providing invaluable feedback, improving this post significantly in the process.</p>
<p>Special thanks to Daniel Jalkut.</p>
<h2 id="a-namea_call_for_discussionaa-call-for-discussion"><a name="A_call_for_discussion"></a>A call for discussion</h2>
<p>Beyond the personal and financial setback this is causing me, I am hearing from the developer community there is a broader concern around the restrictions and the limitation on the tools Apple provides and allows.</p>
<p>I want to kick-off a discussion about this to address these shortcomings. How should Apple enable developers to improve on the tooling for the iOS development ecosystem? I&rsquo;d love to hear your thoughts.</p>
<h2 id="a-namerelatedarelated"><a name="Related"></a>Related</h2>
<ul>
<li><a href="https://qnoid.com/2020/07/30/windmill.html#main">Over a year since Apple gave me an ultimatum on Windmill</a></li>
<li><a href="https://www.coletiv.com/blog/distribute-custom-b2b-ios-app">Distributing Custom B2B iOS Apps privately</a></li>
<li><a href="https://developer.apple.com/business/">Build great business apps on iOS.</a></li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Apple didn&rsquo;t really explain their reasoning.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Mon, 29 Jul 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Windmill enters egg</title>
        <link>https://qnoid.com/2019/06/24/Windmill-enters-egg.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/06/24/Windmill-enters-egg.html</guid>
        <description><![CDATA[<p><em>Approximately 3&rsquo; minutes reading time</em></p>
<p>Back in March, I decided to attend an open day organised by <a href="https://www.theegg.gr/el">egg</a>. It is a business incubator, operating in Athens with a mission to encourage, support and promote entrepreneurship, primarily targeting Greeks, living in Greece.</p>
<p>I am happy to announce that <a href="https://windmill.qnoid.com">Windmill</a> has been accepted to join egg!</p>
<p>Ever since the inception of Windmill, I have been adamant on what path I prefer<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> following. I want to bootstrap Windmill into a sustainable business. That is, with the exception of a business loan, receive no outside investment in return of equity or follow a traditional &ldquo;startup&rdquo; path to grow the business.</p>
<p>In the midst of building <a href="https://windmill.qnoid.com/blog/Windmill-on-the-iPhone-goes-into-beta.html">Windmill on the iPhone</a>, I decided to apply<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> to egg. I meticulously went through the website, <a href="https://www.youtube.com/user/theegggr">watched talks</a> given by the egg staff and business partners in an effort to understand its culture and attitude towards starting a business.</p>
<p>I was drawn to egg primarily for evangelising sensibility in starting a business as well as for appearing genuine in helping Greeks looking to build a future in Greece. Still, I wanted to make sure this was a good fit for Windmill going forward.</p>
<p>Here is what egg offers and how I believe it can help.</p>
<ul>
<li>Office space. Even though I have created a dedicated office space at home, the isolation has been tough to endure. I am looking to benefit from the discussions, interactions and a sense of belonging to everyone else there. For reference, every year about 25 businesses operate within egg.</li>
<li>Mentorship. As part of your tenure, you are assigned a mentor. At this stage, it is not clear who this mentor will be or their expertise. Still, having someone dedicated where you can refer to in an effort to bootstrap your business can prove really useful.</li>
<li>Business Bootcamp. You receive about 100 hours of training in Marketing, Business and Finance. This structured education will no doubt help solidify some of my limited understanding.</li>
<li>Opportunities. Being part of a business incubator is bound to create opportunities in business, marketing, potential partnerships etc. I will certainly be keeping my eyes peeled.</li>
<li>Support. Last but not least, you do get access to accounting and legal services as well as help with incorporating. No doubt I could be doing all this outside of egg, still I have enough on my plate already so I would rather not have to figure it out on my own.</li>
<li>Once you have incorporated, there could be an option to get a business loan in favourable terms. This will come in handy, primarily for hiring as well as marketing and advertising services.</li>
</ul>
<p><a href="https://qnoid.com/2019/01/07/Nothing-but-a-dream.html#main">Back in 2017</a>, when I decided to leave London and give Windmill a fair chance, I wanted to spend about a year to see if it made any business sense pursuing it.</p>
<p>I never would have imagined the possibility of running a business in Greece, yet here I am.</p>
<p>Windmill has come <a href="https://windmill.qnoid.com/changelog/">a long way</a> and receiving an offer to join egg is yet another validating step.</p>
<p>I have a good feeling about this.</p>
<p><img src="/images/2019/06/24/profile.jpg" alt=""></p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>I don&rsquo;t hold a business degree and have no prior experience in starting a business. At this early stage, I am not even sure if it&rsquo;s possible and depending on what the growth of Windmill looks like, I may not have a choice. That doesn&rsquo;t change the fact that my strong preference is to bootstrap Windmill into a sustainable, viable, private company.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>I had to submit a business plan, do a public presentation, create a pitch deck and do a 5 minutes Q&amp;A with a panel before getting to an offer. Thank you <a href="https://twitter.com/mattfarrugia">Matt Farrugia</a> for reviewing and guiding me through this.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Mon, 24 Jun 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Swift 5.0.x String Performance</title>
        <link>https://qnoid.com/2019/05/16/Swift-5.0.x-String-Performance.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/05/16/Swift-5.0.x-String-Performance.html</guid>
        <description><![CDATA[<p>Turns out, in Swift 5.0.x, <code>String(utf8String:)</code> and <code>String(bytes:encoding:)</code> are not &ldquo;optimised&rdquo; compared to <code>String(validatingUTF8:)</code>.</p>
<blockquote class="twitter-tweet" data-conversation="none" data-dnt="true"><p lang="en" dir="ltr">Which String initializer are you using, specifically?<br><br>String(utf8String:) is a Foundation extension and looking at the commit history, it wasn’t optimized to avoid bridging until 5.1 (commit a088e1322495).<br><br>String(validatingUTF8:) should be a ton faster in 5.0.x.</p>&mdash; David Smith (@Catfish_Man) <a href="https://twitter.com/Catfish_Man/status/1128934439096971264?ref_src=twsrc%5Etfw">May 16, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
<p>In other words. In Swift 5.0.x, any <code>String.append(:)</code> calls can potentially take a performance hit.</p>
<blockquote class="twitter-tweet" data-conversation="none" data-dnt="true"><p lang="en" dir="ltr">It’s a bridged NSString, so in the current model either reserveCapacity or the actual append will have to convert to a native Swift String, which will (in 5.0.x) incur O(n) CFStringGetCharacterAtIndex calls for some specific types of NSString.</p>&mdash; David Smith (@Catfish_Man) <a href="https://twitter.com/Catfish_Man/status/1128926802485768192?ref_src=twsrc%5Etfw">May 16, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
<p>Similarly, any <code>NSTextView.string.append(:)</code> operations will also suffer.</p>
<p>This is what that performance hit looks like in my case, where a <a href="https://developer.apple.com/documentation/dispatch/dispatchsourceread"><code>DispatchSourceRead</code></a> is feeding a <code>NSTextView</code> every time there are bytes available to read.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">fileDescriptor</span> <span class="p">=</span> <span class="n">fileHandleForReading</span><span class="p">.</span><span class="n">fileDescriptor</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">readSource</span> <span class="p">=</span> <span class="n">DispatchSource</span><span class="p">.</span><span class="n">makeReadSource</span><span class="p">(</span><span class="n">fileDescriptor</span><span class="p">:</span> <span class="n">fileDescriptor</span><span class="p">,</span> <span class="n">queue</span><span class="p">:</span> <span class="kc">self</span><span class="p">.</span><span class="n">queue</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="n">readSource</span><span class="p">.</span><span class="n">setEventHandler</span> <span class="p">{</span> <span class="p">[</span><span class="kr">weak</span> <span class="n">readSource</span> <span class="p">=</span> <span class="n">readSource</span><span class="p">]</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="kd">let</span> <span class="nv">data</span> <span class="p">=</span> <span class="n">readSource</span><span class="p">?.</span><span class="n">data</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nv">estimatedBytesAvailableToRead</span> <span class="p">=</span> <span class="nb">Int</span><span class="p">(</span><span class="n">data</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="c1">//before: var buffer = [UInt8](repeating: 0, count: estimatedBytesAvailableToRead)</span>
</span></span><span class="line"><span class="cl">            <span class="kd">var</span> <span class="nv">buffer</span> <span class="p">=</span> <span class="p">[</span><span class="nb">CChar</span><span class="p">](</span><span class="n">repeating</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="bp">count</span><span class="p">:</span> <span class="n">estimatedBytesAvailableToRead</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nv">bytesRead</span> <span class="p">=</span> <span class="n">Darwin</span><span class="p">.</span><span class="n">read</span><span class="p">(</span><span class="n">fileDescriptor</span><span class="p">,</span> <span class="p">&amp;</span><span class="n">buffer</span><span class="p">,</span> <span class="n">estimatedBytesAvailableToRead</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">            Making sure that the buffer ends with a 0 since the bytes read are not guaranteed to.
</span></span></span><span class="line"><span class="cl"><span class="cm">            `String(validatingUTF8:)` has a requirement that the &#34;cString is A pointer to a null-terminated UTF-8 code sequence.&#34;
</span></span></span><span class="line"><span class="cl"><span class="cm">            */</span>
</span></span><span class="line"><span class="cl">            <span class="n">buffer</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> 
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="c1">//https://twitter.com/Catfish_Man/status/1128934439096971264</span>
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="n">bytesRead</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">,</span> <span class="kd">let</span> <span class="nv">availableString</span> <span class="p">=</span> <span class="nb">String</span><span class="p">(</span><span class="n">validatingUTF8</span><span class="p">:</span> <span class="n">buffer</span><span class="p">)</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">            <span class="p">(</span><span class="n">completion</span> <span class="p">??</span> <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">).</span><span class="n">async</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="kc">self</span><span class="p">.</span><span class="n">output</span><span class="p">(</span><span class="n">part</span><span class="p">:</span> <span class="n">availableString</span><span class="p">,</span> <span class="bp">count</span><span class="p">:</span> <span class="n">availableString</span><span class="p">.</span><span class="n">utf8</span><span class="p">.</span><span class="bp">count</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span></span></span></code></pre></div>
<p><img src="/static/2019/05/16/performance_before.png" alt=""></p>
<p>Use <code>NSTextView.textStorage.append(:)</code> and convert your <code>String</code> to an <code>NSAttributedString</code> using <code>NSAttributedString(string:)</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="c1">//before: textView.string.append(output)</span>
</span></span><span class="line"><span class="cl"><span class="n">textView</span><span class="p">.</span><span class="n">textStorage</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">NSAttributedString</span><span class="p">(</span><span class="n">string</span><span class="p">:</span><span class="n">output</span><span class="p">))</span></span></span></code></pre></div>
<p>This is what the performance looks like after the code change.</p>
<p><img src="/static/2019/05/16/performance_after.png" alt=""></p>
<p>Couldn&rsquo;t be more grateful for <a href="https://twitter.com/Catfish_Man">David Smith</a> responding to my request as well as <a href="https://twitter.com/krzyzanowskim">Marcin Krzyzanowski</a> and <a href="https://twitter.com/pgor">Paul Goracke</a> for nudging me to take a look at <code>NSTextStorage</code>.</p>
<p>This had the potential to be a huge time sink.</p>
<p><a href="https://swift.org/blog/5-1-release-process/">Swift 5.1</a> will be released sometime after March 18, 2019.</p>
<p>.-</p>
<h2 id="update">Update</h2>
<p>Started noticing some crashes on <code>String(validatingUTF8:)</code> with a <code>Fatal error: UnsafeMutablePointer.initialize overlapping range</code> <strong>when using it with an</strong> <code>UnsafePointer&lt;CChar&gt;</code>. Instead using the implementation as defined in the <a href="https://developer.apple.com/documentation/swift/string/1641706-init"><code>Discussion</code></a> under the <code>String</code> documentation. Will report back.</p>
<h2 id="update-2">Update 2</h2>
<p>Re the <code>Fatal error: UnsafeMutablePointer.initialize overlapping range</code>. I hate having bad code around, even if it&rsquo;s bad sample code. It&rsquo;s been a learning experience for sure.</p>
<p><code>String(validatingUTF8:)</code> has a requirement that the <a href="https://github.com/apple/swift/blob/6636815568efa8af5a62bbd68d585691d981a82b/stdlib/public/core/CString.swift#L88">&ldquo;cString is A pointer to a null-terminated UTF-8 code sequence.&rdquo;</a>. This code on the other hand makes no guarantees that this will be the case.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nv">buffer</span> <span class="p">=</span> <span class="p">[</span><span class="nb">CChar</span><span class="p">](</span><span class="n">repeating</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="bp">count</span><span class="p">:</span> <span class="n">estimatedBytesAvailableToRead</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">bytesRead</span> <span class="p">=</span> <span class="n">Darwin</span><span class="p">.</span><span class="n">read</span><span class="p">(</span><span class="n">fileDescriptor</span><span class="p">,</span> <span class="p">&amp;</span><span class="n">buffer</span><span class="p">,</span> <span class="n">estimatedBytesAvailableToRead</span><span class="p">)</span></span></span></code></pre></div>
<p>Sure, it initialises the character array with 0 (i.e. null<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>) but <code>read</code> may fill that array and not end with a 0.</p>
<p>Back to the <code>String(validatingUTF8:)</code> initialiser. If you look at the source, it uses <a href="https://github.com/apple/swift/blob/4dcea1cad18035109ec602da27e5285d7c1b2f2f/stdlib/public/core/Unicode.swift#L137"><code>UTF8._nullCodeUnitOffset(in:)</code></a> which &ldquo;Is an equivalent of <code>strlen</code> for C-strings&rdquo; which gets the length of the string (based on the presence of a null terminating character of course, we are going deep in C now). I was guessing that <code>strlen</code> takes a trip down memory lane© looking for that null terminating character and ends up way beyond an &ldquo;acceptable&rdquo; length. What is acceptable you say?</p>
<p>For that we have to take a look at the source code of <a href="https://github.com/apple/swift/blob/95a15d12bdc01ec392d01fdd6126f68cdd16aa42/stdlib/public/core/UnsafePointer.swift#L827"><code>UnsafePointer</code></a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">func</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">from</span> <span class="n">source</span><span class="p">:</span> <span class="nb">UnsafePointer</span><span class="p">&lt;</span><span class="n">Pointee</span><span class="p">&gt;,</span> <span class="bp">count</span><span class="p">:</span> <span class="nb">Int</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">_debugPrecondition</span><span class="p">(</span><span class="bp">count</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s">&#34;UnsafeMutablePointer.initialize with negative count&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="n">_debugPrecondition</span><span class="p">(</span><span class="nb">UnsafePointer</span><span class="p">(</span><span class="kc">self</span><span class="p">)</span> <span class="o">+</span> <span class="bp">count</span> <span class="o">&lt;=</span> <span class="n">source</span> <span class="o">||</span>  <span class="n">source</span> <span class="o">+</span> <span class="bp">count</span> <span class="o">&lt;=</span> <span class="nb">UnsafePointer</span><span class="p">(</span><span class="kc">self</span><span class="p">),</span>
</span></span><span class="line"><span class="cl">        <span class="s">&#34;UnsafeMutablePointer.initialize overlapping range&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">Builtin</span><span class="p">.</span><span class="n">copyArray</span><span class="p">(</span>
</span></span><span class="line"><span class="cl">  <span class="n">Pointee</span><span class="p">.</span><span class="kc">self</span><span class="p">,</span> <span class="kc">self</span><span class="p">.</span><span class="n">_rawValue</span><span class="p">,</span> <span class="n">source</span><span class="p">.</span><span class="n">_rawValue</span><span class="p">,</span> <span class="bp">count</span><span class="p">.</span><span class="n">_builtinWordValue</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="c1">// This builtin is equivalent to:</span>
</span></span><span class="line"><span class="cl"><span class="c1">// for i in 0..&lt;count {</span>
</span></span><span class="line"><span class="cl"><span class="c1">//   (self + i).initialize(to: source[i])</span>
</span></span><span class="line"><span class="cl"><span class="c1">// }</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>So I decided to take the red pill, go down the rabbit hole and see for myself.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="k">for</span> <span class="n">i</span> <span class="k">in</span> <span class="mf">1.</span><span class="p">..</span><span class="mi">100_000</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nv">buffer</span> <span class="p">=</span> <span class="p">[</span><span class="nb">CChar</span><span class="p">](</span><span class="n">repeating</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="bp">count</span><span class="p">:</span> <span class="mi">4096</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">string</span> <span class="p">=</span> <span class="n">OverlappingRange</span><span class="p">(</span><span class="n">validUTF8</span><span class="p">:</span><span class="n">buffer</span><span class="p">).</span><span class="n">string</span>
</span></span><span class="line"><span class="cl">    <span class="bp">print</span><span class="p">(</span><span class="n">string</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Welcome to the Matrix<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>.-</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/05/16/matrix.mp4" type="video/mp4" />
</video>
<p>&ldquo;Remember&hellip;all I&rsquo;m offering is the truth. Nothing more.&rdquo;</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Brought back the memories of learning C++ back at the University on a Borland C++ editor.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>One run took 2 seconds for the <code>UnsafeMutablePointer.initialize overlapping range</code> but that wasn&rsquo;t very exciting.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Thu, 16 May 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>A series of steps</title>
        <link>https://qnoid.com/2019/05/07/A-series-of-steps.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/05/07/A-series-of-steps.html</guid>
        <description><![CDATA[<p><em>Approximately 9&rsquo; minutes reading time</em></p>
<blockquote>
<p>This post expects that you are familiar with object lifecycles, closures, functional programming, memory management, asynchronous execution, <code>URLSession</code> and <code>Process</code> in the Swift language and the Mac/iOS SDK.</p>
</blockquote>
<h2 id="update">Update</h2>
<p><strong>11 May 2019</strong>, added <a href="#Custom_Operator">custom operator</a> and a reference to <a href="https://github.com/apple/swift-evolution/blob/0c36ce83b6b6bd61a63fa048554fb3e5a9f01ad9/proposals/0253-callable.md">SE-0253</a>.</p>
<h2 id="table-of-contents">Table of Contents</h2>
<div class="toc">
<ul>
<li><a href="#Introduction">Introduction</a></li>
<li><a href="#Prefix">Prefix</a></li>
<li><a href="#Baby_Steps">Baby Steps</a></li>
<li><a href="#Error_Handling">Error Handling</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
<li><a href="#Sample_Project">Sample Project</a></li>
<li><a href="#Feedback">Feedback</a></li>
<li><a href="#Acknowledgements">Acknowledgements</a></li>
</ul>
</div>
<h2 id="a-nameintroductiona-introduction"><a name="Introduction"></a> Introduction</h2>
<p>The backbone of <a href="https://windmill.qnoid.com/mac">Windmill on the Mac</a> is a series of steps<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>, that execute serially.</p>
<blockquote>
<p>Checkout -&gt; Build -&gt; Test -&gt; Archive -&gt; Export</p>
</blockquote>
<p>A few things to note.</p>
<ul>
<li><strong>The output of one step may act as the input to the next.</strong></li>
<li>A step executes asynchronously.</li>
<li>Each step must be successful before the next one is taken.</li>
<li>Steps only make forward progress. If one step fails, the whole series is considered to have failed and no more steps are taken.</li>
<li>The implementation of each step may differ. e.g. one step might be launching a <a href="https://developer.apple.com/documentation/foundation/process"><code>Process</code></a>, another one might start a <a href="https://developer.apple.com/documentation/foundation/urlsession"><code>URLSession</code></a>.</li>
</ul>
<blockquote>
<p>The problem domain may sound familiar<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> to that the <a href="https://developer.apple.com/documentation/foundation/operation"><code>NSOperation</code></a> and <a href="https://developer.apple.com/documentation/foundation/operationqueue"><code>NSOperationQueue</code></a> solve. Apple has an excellent WWDC talk describing how powerful and useful can be in the context of dependencies; See <a href="https://developer.apple.com/videos/play/wwdc2015/226/">Advanced NSOperations</a>.</p>
</blockquote>
<p>Windmill, <strong>does not</strong> make use of <code>NSOperations</code> for the following, arguably subjective reasons.</p>
<ul>
<li>I wanted a more refined control over object lifecycles; i.e. what dependencies/relationships a step has, what arguments it needs to run, what it expects as an input.</li>
<li>I wanted the concepts of a step, success, output/input, optional next step to be prominent and part of the API design.</li>
<li>I wanted steps to have low coupling. Being able to reuse a step and create a different series of steps.</li>
<li>I wanted a step to allocate memory lazily as part of its execution rather than as part of its allocation.</li>
<li>I wanted the relationship between steps to look like it&rsquo;s &ldquo;modelled&rdquo; at compile time.</li>
<li>I wanted less of an architecture and more of a design pattern.</li>
<li>I wanted an abstraction that is &ldquo;lightweight&rdquo; rather than another execution layer on top of launching a process and/or making an HTTP request.</li>
</ul>
<p>Let&rsquo;s take a step back.</p>
<h2 id="a-nameprefixa-prefix"><a name="Prefix"></a> Prefix</h2>
<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="p">#</span><span class="o">!/</span><span class="n">bin</span><span class="o">/</span><span class="n">swift</span>
</span></span><span class="line"><span class="cl"><span class="kd">import</span> <span class="nc">Foundation</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="s">&#34;Hello World!&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">process</span> <span class="p">=</span> <span class="nb">Process</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">process</span><span class="p">.</span><span class="n">launchPath</span> <span class="p">=</span> <span class="s">&#34;/bin/echo&#34;</span>
</span></span><span class="line"><span class="cl"><span class="n">process</span><span class="p">.</span><span class="n">arguments</span> <span class="p">=</span> <span class="p">[</span><span class="n">message</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="n">process</span><span class="p">.</span><span class="n">launch</span><span class="p">()</span></span></span></code></pre></div>
<a href="/static/2019/05/07/echo.swift"><code>echo.swift</code></a> <em>You can use <code>swift echo.swift</code> in the command line to run it.</em></p>
<p>The code above prints the message <code>&quot;Hello World!&quot;</code> asynchronously.</p>
<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="p">#</span><span class="o">!/</span><span class="n">bin</span><span class="o">/</span><span class="n">swift</span>
</span></span><span class="line"><span class="cl"><span class="kd">import</span> <span class="nc">Foundation</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">group</span> <span class="p">=</span> <span class="n">DispatchGroup</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="n">group</span><span class="p">.</span><span class="n">enter</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">session</span> <span class="p">=</span> <span class="n">URLSession</span><span class="p">.</span><span class="n">shared</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="s">&#34;SGVsbG8gV29ybGQh&#34;</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nv">request</span> <span class="p">=</span> <span class="n">URLRequest</span><span class="p">(</span><span class="n">url</span><span class="p">:</span> <span class="n">URL</span><span class="p">(</span><span class="n">string</span><span class="p">:</span> <span class="s">&#34;https://httpbin.org/base64/</span><span class="si">\(</span><span class="n">message</span><span class="si">)</span><span class="s">&#34;</span><span class="p">)</span><span class="o">!</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="n">request</span><span class="p">.</span><span class="n">httpMethod</span> <span class="p">=</span> <span class="s">&#34;GET&#34;</span>
</span></span><span class="line"><span class="cl"><span class="n">request</span><span class="p">.</span><span class="n">addValue</span><span class="p">(</span><span class="s">&#34;text/html&#34;</span><span class="p">,</span> <span class="n">forHTTPHeaderField</span><span class="p">:</span> <span class="s">&#34;accept&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">session</span><span class="p">.</span><span class="n">dataTask</span><span class="p">(</span><span class="n">with</span><span class="p">:</span> <span class="n">request</span><span class="p">)</span> <span class="p">{</span> <span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">response</span><span class="p">,</span> <span class="n">error</span><span class="p">)</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">    <span class="k">guard</span> <span class="kd">let</span> <span class="nv">response</span> <span class="p">=</span> <span class="n">response</span> <span class="k">as</span><span class="p">?</span> <span class="n">HTTPURLResponse</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="bp">preconditionFailure</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">switch</span> <span class="p">(</span><span class="n">response</span><span class="p">.</span><span class="n">statusCode</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">case</span> <span class="mi">200</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="kd">let</span> <span class="nv">data</span> <span class="p">=</span> <span class="n">data</span><span class="p">,</span> <span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="nb">String</span><span class="p">(</span><span class="n">data</span><span class="p">:</span> <span class="n">data</span><span class="p">,</span> <span class="n">encoding</span><span class="p">:</span> <span class="p">.</span><span class="n">utf8</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="bp">print</span><span class="p">(</span><span class="n">message</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">default</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="bp">print</span><span class="p">(</span><span class="s">&#34;failure&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">group</span><span class="p">.</span><span class="n">leave</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="p">}.</span><span class="n">resume</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">result</span> <span class="p">=</span> <span class="n">group</span><span class="p">.</span><span class="n">wait</span><span class="p">(</span><span class="n">timeout</span><span class="p">:</span> <span class="p">.</span><span class="n">now</span><span class="p">()</span> <span class="o">+</span> <span class="mi">10</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="bp">print</span><span class="p">(</span><span class="n">result</span><span class="p">)</span></span></span></code></pre></div>
<a href="/static/2019/05/07/get.swift"><code>get.swift</code></a> <em>You can use <code>swift get.swift</code> in the command line to run it.</em></p>
<p>The code above makes an asynchronous HTTP GET request to decode a base64 message.</p>
<p>Let&rsquo;s see how the code samples above would typically be used in an app. A <code>Base64Service</code> which might look familiar with what you find in the &ldquo;network layer&rdquo;.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">class</span> <span class="nc">Base64Service</span>  <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">typealias</span> <span class="n">DecodeCompletionHandler</span> <span class="p">=</span> <span class="p">(</span><span class="n">Result</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="nb">Void</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">session</span><span class="p">:</span> <span class="n">URLSession</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">init</span><span class="p">(</span><span class="n">session</span><span class="p">:</span> <span class="n">URLSession</span> <span class="p">=</span> <span class="n">URLSession</span><span class="p">.</span><span class="n">shared</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">session</span> <span class="p">=</span> <span class="n">session</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">func</span> <span class="nf">decode</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">DispatchQueue</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">,</span> <span class="n">encoded</span> <span class="n">message</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">completionHandler</span><span class="p">:</span> <span class="p">@</span><span class="n">escaping</span> <span class="n">Base64Service</span><span class="p">.</span><span class="n">DecodeCompletionHandler</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="kd">var</span> <span class="nv">request</span> <span class="p">=</span> <span class="n">URLRequest</span><span class="p">(</span><span class="n">url</span><span class="p">:</span> <span class="n">URL</span><span class="p">(</span><span class="n">string</span><span class="p">:</span> <span class="s">&#34;https://httpbin.org/base64/</span><span class="si">\(</span><span class="n">message</span><span class="si">)</span><span class="s">&#34;</span><span class="p">)</span><span class="o">!</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">request</span><span class="p">.</span><span class="n">httpMethod</span> <span class="p">=</span> <span class="s">&#34;GET&#34;</span>
</span></span><span class="line"><span class="cl">        <span class="n">request</span><span class="p">.</span><span class="n">addValue</span><span class="p">(</span><span class="s">&#34;text/html&#34;</span><span class="p">,</span> <span class="n">forHTTPHeaderField</span><span class="p">:</span> <span class="s">&#34;accept&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="n">session</span><span class="p">.</span><span class="n">dataTask</span><span class="p">(</span><span class="n">with</span><span class="p">:</span> <span class="n">request</span><span class="p">)</span> <span class="p">{</span> <span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">response</span><span class="p">,</span> <span class="n">error</span><span class="p">)</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="kd">let</span> <span class="nv">response</span> <span class="p">=</span> <span class="n">response</span> <span class="k">as</span><span class="p">?</span> <span class="n">HTTPURLResponse</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="bp">preconditionFailure</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">            <span class="k">switch</span> <span class="p">(</span><span class="n">response</span><span class="p">.</span><span class="n">statusCode</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">case</span> <span class="mi">200</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="kd">let</span> <span class="nv">data</span> <span class="p">=</span> <span class="n">data</span><span class="p">,</span> <span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="nb">String</span><span class="p">(</span><span class="n">data</span><span class="p">:</span> <span class="n">data</span><span class="p">,</span> <span class="n">encoding</span><span class="p">:</span> <span class="p">.</span><span class="n">utf8</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="p">(</span><span class="n">queue</span> <span class="p">??</span> <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">).</span><span class="n">async</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                        <span class="n">completionHandler</span><span class="p">(.</span><span class="n">success</span><span class="p">(</span><span class="n">message</span><span class="p">:</span> <span class="n">message</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">                    <span class="p">}</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="k">default</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">                <span class="p">(</span><span class="n">queue</span> <span class="p">??</span> <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">).</span><span class="n">async</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="n">completionHandler</span><span class="p">(.</span><span class="n">failure</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}.</span><span class="n">resume</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>An <code>EchoService</code> type.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">class</span> <span class="nc">EchoService</span>  <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">typealias</span> <span class="n">EchoCompletionHandler</span> <span class="p">=</span> <span class="p">(</span><span class="n">Result</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="nb">Void</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">func</span> <span class="nf">echo</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">DispatchQueue</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">,</span> <span class="n">message</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">completionHandler</span><span class="p">:</span> <span class="p">@</span><span class="n">escaping</span> <span class="n">EchoService</span><span class="p">.</span><span class="n">EchoCompletionHandler</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">process</span> <span class="p">=</span> <span class="nb">Process</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="n">process</span><span class="p">.</span><span class="n">launchPath</span> <span class="p">=</span> <span class="s">&#34;/bin/echo&#34;</span>
</span></span><span class="line"><span class="cl">        <span class="n">process</span><span class="p">.</span><span class="n">arguments</span> <span class="p">=</span> <span class="p">[</span><span class="n">message</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="n">process</span><span class="p">.</span><span class="n">terminationHandler</span> <span class="p">=</span> <span class="p">{</span> <span class="n">process</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nv">isSuccess</span> <span class="p">=</span> <span class="n">process</span><span class="p">.</span><span class="n">terminationStatus</span> <span class="p">==</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="p">(</span><span class="n">queue</span> <span class="p">??</span> <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">).</span><span class="n">async</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="n">isSuccess</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="n">completionHandler</span><span class="p">(.</span><span class="n">success</span><span class="p">(</span><span class="n">message</span><span class="p">:</span> <span class="n">message</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="n">completionHandler</span><span class="p">(.</span><span class="n">failure</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">process</span><span class="p">.</span><span class="n">launch</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>The <code>Base64Service</code> can be used like so:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">base64Service</span> <span class="p">=</span> <span class="n">Base64Service</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">encoded</span> <span class="p">=</span> <span class="s">&#34;SGVsbG8gV29ybGQh&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">base64Service</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="n">encoded</span><span class="p">:</span> <span class="n">encoded</span><span class="p">)</span> <span class="p">{</span> <span class="n">result</span> <span class="k">in</span> 
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>The <code>EchoService</code> can be used like so:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echoService</span> <span class="p">=</span> <span class="n">EchoService</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="s">&#34;Hello World&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">echoService</span><span class="p">.</span><span class="n">echo</span><span class="p">(</span><span class="n">message</span><span class="p">:</span> <span class="n">message</span><span class="p">)</span> <span class="p">{</span> <span class="n">result</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">	
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Run-of-the-mill so far.</p>
<p>With both services at hand, we want to be able to use them so that given an encoded message, we can:</p>
<ol>
<li>Decode the message.</li>
<li>On success, echo the decoded message.</li>
</ol>
<p>Let&rsquo;s see how that would look.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echoService</span> <span class="p">=</span> <span class="n">EchoService</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">base64Service</span> <span class="p">=</span> <span class="n">Base64Service</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">base64Service</span><span class="p">.</span><span class="n">decode</span><span class="p">(</span><span class="n">encoded</span><span class="p">:</span> <span class="s">&#34;SGVsbG8gV29ybGQh&#34;</span><span class="p">)</span> <span class="p">{</span> <span class="n">result</span> <span class="k">in</span> 
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">guard</span> <span class="k">case</span> <span class="p">.</span><span class="n">success</span><span class="p">(</span><span class="kd">let</span> <span class="nv">message</span><span class="p">)</span> <span class="p">=</span> <span class="n">result</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">echoService</span><span class="p">.</span><span class="n">echo</span><span class="p">(</span><span class="n">message</span><span class="p">:</span> <span class="n">message</span><span class="p">)</span> <span class="p">{</span> <span class="kc">_</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<h2 id="a-namebaby_stepsababy-steps"><a name="Baby_Steps"></a>Baby Steps</h2>
<p>Now that we have a better sense of what we are working with, let&rsquo;s break it down.</p>
<blockquote>
<p>The output of one step may act as the input to the next.</p>
</blockquote>
<p><img src="/static/2019/05/07/echoService.png" alt=""></p>
<p>Notice how the <code>message</code> argument to the <code>EchoService#echo(queue:message:)</code> travels from the <strong>successful result</strong> of the <code>Base64Service</code>.</p>
<p>The <code>message</code> is the &ldquo;output&rdquo; of the <code>Base64Service</code> and the &ldquo;input&rdquo; to the <code>EchoService</code>. In that sense, you can think of an <code>InputOutput</code> type as a key/value storage that can be used to pass data between steps. Similar to how the <a href="https://developer.apple.com/documentation/foundation/notificationcenter"><code>NotificationCenter</code></a> uses the <a href="https://developer.apple.com/documentation/foundation/notificationcenter/1410608-post"><code>userInfo</code></a> whenever it posts a <code>Notification</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">InputOutput</span> <span class="p">=</span> <span class="p">[</span><span class="n">AnyHashable</span> <span class="p">:</span> <span class="nb">Any</span><span class="p">]</span></span></span></code></pre></div>
<p>From that, the definition of a step is trivial.</p>
<blockquote>
<p>Steps only make forward progress.</p>
</blockquote>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">Step</span> <span class="p">=</span> <span class="p">(</span><span class="kc">_</span> <span class="n">io</span><span class="p">:</span> <span class="n">InputOutput</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">Swift</span><span class="p">.</span><span class="nb">Void</span></span></span></code></pre></div>
<p>Let&rsquo;s look at the implementation of the <code>EchoStep</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">import</span> <span class="nc">Foundation</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">EchoStep</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kr">weak</span> <span class="kd">var</span> <span class="nv">echoService</span><span class="p">:</span> <span class="n">EchoService</span><span class="p">?</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">func</span> <span class="nf">make</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">DispatchQueue</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">,</span> <span class="n">next</span><span class="p">:</span> <span class="n">Step</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">Step</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span> <span class="n">io</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="n">io</span><span class="p">[</span><span class="s">&#34;message&#34;</span><span class="p">]</span> <span class="k">as</span><span class="p">?</span> <span class="nb">String</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="bp">preconditionFailure</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="kc">self</span><span class="p">.</span><span class="n">echoService</span><span class="p">?.</span><span class="n">echo</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">queue</span><span class="p">,</span> <span class="n">message</span><span class="p">:</span> <span class="n">message</span><span class="p">)</span> <span class="p">{</span> <span class="n">result</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">                <span class="k">guard</span> <span class="k">case</span> <span class="p">.</span><span class="n">success</span><span class="p">(</span><span class="kd">let</span> <span class="nv">message</span><span class="p">)</span> <span class="p">=</span> <span class="n">result</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="k">return</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">                <span class="n">next</span><span class="p">?([</span><span class="s">&#34;message&#34;</span><span class="p">:</span><span class="n">message</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Think of the <code>EchoStep</code> as merely a type that creates a <code>Step</code> that echoes a message and also defines its input/output. It has an <code>EchoService</code> as a dependency but does not own it since the lifecycle of the <code>EchoService</code><sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> is not directly related to the step execution.</p>
<p>Look closely at the <code>EchoStep#make(queue:next:)</code> implementation which returns a <code>Step</code> and think back to its type alias.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">Step</span> <span class="p">=</span> <span class="p">(</span><span class="kc">_</span> <span class="n">io</span><span class="p">:</span> <span class="n">InputOutput</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">Swift</span><span class="p">.</span><span class="nb">Void</span></span></span></code></pre></div>
<p>It returns a function, that accepts a single <code>InputOutput</code> type as its input and has no return statement. It expects the <code>io</code> argument to have a &ldquo;message&rdquo; value.</p>
<p>Equally, notice how the <code>Step</code>, passes it&rsquo;s output to the <code>next</code> step, which in this case is the message it echoed. It&rsquo;s important to understand that the <code>InputOutput</code> type is a short lived instance only meant to be used in creating the step. It is not meant to be long lived, passed throughout the whole series of steps or as a global variable where every input/output is kept there.</p>
<p>This is how you would create a new <code>EchoStep</code> and use it</p>
<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echoService</span> <span class="p">=</span> <span class="n">EchoService</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echoStep</span> <span class="p">=</span> <span class="n">EchoStep</span><span class="p">(</span><span class="n">echoService</span><span class="p">:</span> <span class="n">echoService</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echo</span> <span class="p">=</span> <span class="n">echoStep</span><span class="p">.</span><span class="n">make</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">message</span> <span class="p">=</span> <span class="s">&#34;Hello World!&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="n">echo</span><span class="p">([</span><span class="s">&#34;message&#34;</span><span class="p">:</span><span class="n">message</span><span class="p">])</span></span></span></code></pre></div>
<em><code>EchoStep</code></em>, <a href="/static/2019/05/07/A-series-of-steps.zip"><code>A-series-of-steps.playground</code></a></p>
<p>There is one more thing.</p>
<blockquote>
<p>Each step must be successful before the next one is taken.</p>
</blockquote>
<p>Notice how the <code>EchoStep#make(queue:next:)</code> above accepts an optional next <code>Step</code> type that only calls on the condition of a successful callback.</p>
<p>With that in mind, let&rsquo;s define a new type <code>SuccessfulStep</code>, which creates a &ldquo;successful&rdquo; <code>Step</code> and optionally passes the next one.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">SuccessfulStep</span> <span class="p">=</span> <span class="p">(</span><span class="kc">_</span> <span class="n">next</span><span class="p">:</span> <span class="n">Step</span><span class="p">?)</span> <span class="p">-&gt;</span> <span class="n">Step</span></span></span></code></pre></div>
<p>This type will become useful later as part of building a series of steps. For now, take a look at the <code>DecodeStep</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">struct</span> <span class="nc">DecodeStep</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kr">weak</span> <span class="kd">var</span> <span class="nv">base64Service</span><span class="p">:</span> <span class="n">Base64Service</span><span class="p">?</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">func</span> <span class="nf">make</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">DispatchQueue</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">,</span> <span class="n">next</span><span class="p">:</span> <span class="n">Step</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">Step</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span> <span class="n">io</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="kd">let</span> <span class="nv">encoded</span> <span class="p">=</span> <span class="n">io</span><span class="p">[</span><span class="s">&#34;message&#34;</span><span class="p">]</span> <span class="k">as</span><span class="p">?</span> <span class="nb">String</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="bp">preconditionFailure</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="kc">self</span><span class="p">.</span><span class="n">base64Service</span><span class="p">?.</span><span class="n">decode</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">queue</span><span class="p">,</span> <span class="n">encoded</span><span class="p">:</span> <span class="n">encoded</span><span class="p">)</span> <span class="p">{</span> <span class="n">result</span> <span class="k">in</span> 
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="k">case</span> <span class="p">.</span><span class="n">success</span><span class="p">(</span><span class="kd">let</span> <span class="nv">message</span><span class="p">)</span> <span class="p">=</span> <span class="n">result</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="n">next</span><span class="p">?([</span><span class="s">&#34;message&#34;</span><span class="p">:</span> <span class="n">message</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">func</span> <span class="nf">successful</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">DispatchQueue</span><span class="p">?</span> <span class="p">=</span> <span class="kc">nil</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">SuccessfulStep</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">{</span> <span class="n">next</span> <span class="k">in</span> 
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">self</span><span class="p">.</span><span class="n">make</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="n">queue</span><span class="p">,</span> <span class="n">next</span><span class="p">:</span> <span class="n">next</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Focus on the <code>DecodeStep#successful(queue:) -&gt; SuccessfulStep</code>. This function accepts every argument the <code>#make</code> one does, except the next <code>Step</code>.</p>
<p>The <code>#successful</code> function is useful to better express a series of steps. It&rsquo;s best demonstrated in auto-completion.</p>
<p><img src="/static/2019/05/07/screenshot.png" alt=""></p>
<p>Notice how <code>DecodeStep(base64Service: base64Service).successful()</code> defines a <code>SuccessfulStep</code>. It does not create one. This allows you to defer passing the next <code>Step</code> until after you have created it. Alternatively, you would have to write the code backwards, starting with creating the echo <code>Step</code> first.</p>
<p>Keep in mind that this is still the creation phase. Nothing is executed until you take the <code>series</code> step and call it with an  <code>InputOutput</code> parameter.</p>
<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="n">series</span><span class="p">([</span><span class="s">&#34;message&#34;</span><span class="p">:</span><span class="s">&#34;SGVsbG8gV29ybGQh&#34;</span><span class="p">])</span></span></span></code></pre></div>
<em><code>DecodeStep</code></em>, <a href="/static/2019/05/07/A-series-of-steps.zip"><code>A-series-of-steps.playground</code></a></p>
<blockquote>
<p>Try passing an invalid base64 encoded String and see what happens.</p>
</blockquote>
<p>Now that we can chain a series of <code>DecodeStep</code>, let&rsquo;s use them to decode a twice encoded base64 String.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">base64Service</span> <span class="p">=</span> <span class="n">Base64Service</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echoService</span> <span class="p">=</span> <span class="n">EchoService</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">decodeOnce</span> <span class="p">=</span> <span class="n">DecodeStep</span><span class="p">(</span><span class="n">base64Service</span><span class="p">:</span> <span class="n">base64Service</span><span class="p">).</span><span class="n">successful</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">decodeTwice</span> <span class="p">=</span> <span class="n">DecodeStep</span><span class="p">(</span><span class="n">base64Service</span><span class="p">:</span> <span class="n">base64Service</span><span class="p">).</span><span class="n">successful</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">echo</span> <span class="p">=</span> <span class="n">EchoStep</span><span class="p">(</span><span class="n">echoService</span><span class="p">:</span> <span class="n">echoService</span><span class="p">).</span><span class="n">make</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">series</span><span class="p">:</span><span class="n">Step</span> <span class="p">=</span> <span class="n">decodeOnce</span><span class="p">(</span><span class="n">decodeTwice</span><span class="p">(</span><span class="n">echo</span><span class="p">))</span>
</span></span><span class="line"><span class="cl"><span class="n">series</span><span class="p">([</span><span class="s">&#34;message&#34;</span><span class="p">:</span><span class="s">&#34;U0dWc2JHOGdWMjl5YkdRaA==&#34;</span><span class="p">])</span></span></span></code></pre></div>
<p>One thing you may be struggling with is how the heck does this line of code work?</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">series</span><span class="p">:</span><span class="n">Step</span> <span class="p">=</span> <span class="n">decodeOnce</span><span class="p">(</span><span class="n">decodeTwice</span><span class="p">(</span><span class="n">echo</span><span class="p">))</span></span></span></code></pre></div>
<p>Especially if you are not already familiar with functional programming. It&rsquo;s ok! Let&rsquo;s go through this.</p>
<p>The <code>decodeOnce</code> instance is a function (a <code>SuccessfulStep</code>). Once you call it, (i.e. <code>decodeOnce(...)</code> it resolves to a <code>Step</code>, that step is the one the <code>DecodeStep</code> makes. So the <code>series</code> instance is a <code>Step</code> function that you can call. (I have specifically declared its type so that this is clear.)</p>
<p>The <code>decodeTwice</code> instance is also a <code>SuccessfulStep</code>, once you call it, it resolves to a <code>Step</code> also made by the <code>DecodeStep</code>. It&rsquo;s the <code>next</code> step in the series.</p>
<p>Finally, the <code>echo</code> instance is a <code>Step</code> (also a function). It&rsquo;s the second <code>next</code> step in the series.</p>
<h2 id="a-nameerror_handlingaerror-handling"><a name="Error_Handling"></a>Error handling</h2>
<p>You may have noticed that throughout the code, there isn&rsquo;t much error handling. This was done on purpose since I wanted to focus on the design pattern of steps.</p>
<p>Having said that, you can easily incorporate error handling either through a delegate and/or notifications.</p>
<p>As an example, consider the following:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="k">guard</span> <span class="k">case</span> <span class="p">.</span><span class="n">success</span><span class="p">(</span><span class="kd">let</span> <span class="nv">message</span><span class="p">)</span> <span class="p">=</span> <span class="n">result</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kc">self</span><span class="p">.</span><span class="n">delegate</span><span class="p">?.</span><span class="n">failure</span><span class="p">(</span><span class="n">error</span><span class="p">:</span> <span class="n">StepError</span><span class="p">.</span><span class="n">failed</span><span class="p">(</span><span class="s">&#34;decode&#34;</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<blockquote>
<p><a href="https://twitter.com/mattt">Mattt</a> has an excellent article on Error<sup id="fnref:4"><a href="#fn:4" class="footnote-ref" role="doc-noteref">4</a></sup></p>
</blockquote>
<h2 id="a-nameconclusionaconclusion"><a name="Conclusion"></a>Conclusion</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">InputOutput</span> <span class="p">=</span> <span class="p">[</span><span class="n">AnyHashable</span> <span class="p">:</span> <span class="nb">Any</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">SuccessfulStep</span> <span class="p">=</span> <span class="p">(</span><span class="kc">_</span> <span class="n">next</span><span class="p">:</span> <span class="n">Step</span><span class="p">?)</span> <span class="p">-&gt;</span> <span class="n">Step</span>
</span></span><span class="line"><span class="cl"><span class="kd">typealias</span> <span class="n">Step</span> <span class="p">=</span> <span class="p">(</span><span class="kc">_</span> <span class="n">io</span><span class="p">:</span> <span class="n">InputOutput</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">Swift</span><span class="p">.</span><span class="nb">Void</span></span></span></code></pre></div>
<p>As long as you remember these 3 types, you can apply this pattern across your codebase.</p>
<p><a href="https://twitter.com/windmill_io/status/1121799068336803842">Windmill 3.0</a> also uses it to distribute an export efficiently, securely and in a performant upload that requires 3 steps.</p>
<p>There is also nothing preventing you from combining async with sync steps.</p>
<h2 id="a-namesample_projectasample-project"><a name="Sample_Project"></a>Sample Project</h2>
<p><a href="https://github.com/qnoid/A-Series-Of-Steps">Source on GitHub</a></p>
<h2 id="a-namefeedbackafeedback"><a name="Feedback"></a>Feedback</h2>
<p>Would be nice if instead of brackets, it was possible to define a <strong>custom operator</strong>. However, as far as I know, that requires an explicit type instead of a typealias. If you have a suggestion, please let me know and will update this post.</p>
<h3 id="a-namecustom_operatora-custom-operator"><a name="Custom_Operator"></a> Custom Operator</h3>
<p>Here it is using an explicit type. Effectively, you wrap a function in a struct type, rather than simply create a typealias of the function. This way, you can also define a custom operator. In our case, that would be a <code>SuccesfulStep</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kr">infix</span> <span class="kd">operator</span> <span class="o">--&gt;</span><span class="p">:</span> <span class="n">AssignmentPrecedence</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">public</span> <span class="kd">struct</span> <span class="nc">SuccessfulStep</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">success</span><span class="p">:</span> <span class="p">(</span><span class="kc">_</span> <span class="n">next</span><span class="p">:</span> <span class="n">Step</span><span class="p">?)</span> <span class="p">-&gt;</span> <span class="n">Step</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="n">call</span><span class="p">(</span><span class="kc">_</span> <span class="n">next</span><span class="p">:</span> <span class="n">Step</span><span class="p">?)</span> <span class="p">-&gt;</span> <span class="n">Step</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">success</span><span class="p">(</span><span class="n">next</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">extension</span> <span class="nc">SuccessfulStep</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">static</span> <span class="kd">func</span> <span class="o">--&gt;</span> <span class="p">(</span><span class="n">success</span><span class="p">:</span> <span class="n">SuccessfulStep</span><span class="p">,</span> <span class="n">next</span><span class="p">:</span> <span class="p">@</span><span class="n">escaping</span> <span class="n">Step</span><span class="p">)</span> <span class="p">-&gt;</span> <span class="n">Step</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">success</span><span class="p">.</span><span class="n">call</span><span class="p">(</span><span class="n">next</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>I just came across Daniel Steinberg&rsquo;s talk, <a href="https://youtu.be/J5T0iRih-D0?list=WL&amp;t=892">You&rsquo;re doing it wrong</a> in which he mentions the <a href="https://github.com/apple/swift-evolution/blob/0c36ce83b6b6bd61a63fa048554fb3e5a9f01ad9/proposals/0253-callable.md#bound-closures">Swift Evolution Proposal 0253 - Introduce callables</a> which <a href="https://github.com/apple/swift/pull/24299">is coming</a>.
AFAICS, effectively you will be able to call a struct type as if it is a function. Which makes the struct <code>SuccesfulStep</code> retain it&rsquo;s nature as if it was a typealias! Here is how a series of steps now looks inspired by <a href="https://twitter.com/cocoawithlove">Matt Gallagher</a> release of <a href="https://www.cocoawithlove.com/blog/introducing-cwlviews.html">CwlViews</a>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">series</span> <span class="p">=</span> <span class="n">decode</span> <span class="o">--&gt;</span> <span class="n">echo</span></span></span></code></pre></div>
<p>and</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nv">series</span> <span class="p">=</span> <span class="n">decodeFirst</span> <span class="o">--&gt;</span> <span class="n">decondSecond</span> <span class="o">--&gt;</span> <span class="n">echo</span></span></span></code></pre></div>
<p>I have also updated the <a href="https://github.com/qnoid/A-Series-Of-Steps/commit/d90b263d77018aa2019633ddbe51c9e9fa1e48e1">source code</a>.</p>
<p>Would also be nice if there was some type safety for the <code>InputOutput</code> arguments as well as its &ldquo;type&rdquo; required for each step.-</p>
<h2 id="a-nameacknowledgementsaacknowledgements"><a name="Acknowledgements"></a>Acknowledgements</h2>
<ul>
<li><a href="https://twitter.com/chriseidhof">Chris Eidhof</a>, <a href="https://twitter.com/danielboedewadt">Daniel Eggert</a>, and <a href="https://twitter.com/floriankugler">Florian Kugler</a> for the wonderful <a href="https://www.objc.io/books/functional-swift/">Functional Swift</a> book. It&rsquo;s been extremely helpful while trying to get my head around functional programming.</li>
<li><a href="https://twitter.com/dimsumthinking">Daniel H Steinberg</a> for his amazing insight and sharing of knowledge. His <a href="https://vimeo.com/124349158">Somewhere Between Tomorrowland and Frontierland - Daniel Steinberg</a> talk was an eye opener.</li>
<li><a href="https://httpbin.org">httpbin.org</a></li>
<li><a href="https://cryptii.com">cryptii</a></li>
</ul>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>In practice there are more steps than these. For this post, I&rsquo;ll keep it simple by focusing on the user facing ones.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>NSHipster has an intro to <a href="https://nshipster.com/nsoperation/"><code>NSOperation</code></a>&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>Most likely the <code>echoService</code> is owned by a <code>UIViewController</code> or at the very least, it is a leaf in its memory graph. Most likely, you don&rsquo;t want to take the echo step (i.e. <code>self.echoService?.echo</code>) if, say, the <code>UIView</code> to display the message has been deallocated.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:4">
<p><a href="https://nshipster.com/swift-foundation-error-protocols">Localized​Error, Recoverable​Error, Custom​NSError</a>&#160;<a href="#fnref:4" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Tue, 07 May 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Climate &lt;strike&gt;Change&lt;/strike&gt; Emergency</title>
        <link>https://qnoid.com/2019/04/13/Climate-Change.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/04/13/Climate-Change.html</guid>
        <description><![CDATA[<p><em>Approximately 5&rsquo; minutes reading time</em></p>
<p>Excellent articles by The New York Times on the Climate Issue of April 9, 2019.</p>
<ul>
<li><a href="https://www.nytimes.com/interactive/2019/04/09/magazine/climate-change-politics-economics.html">The Problem With Putting a Price on the End of the World</a></li>
<li><a href="https://www.nytimes.com/interactive/2019/04/09/magazine/climate-change-peru-law.html">Climate Change Could Destroy His Home in Peru. So He Sued
an Energy Company in Germany.</a></li>
</ul>
<p>The first one is about economics and policy in relation to climate change.
The second is about law, ethics and capitalism.</p>
<p>I found them both fascinating, especially the second one. In an alternate universe, I practice law as an attorney and have a background in philosophy.</p>
<p>Here are my takeaways. Market economics like <a href="https://en.wikipedia.org/wiki/Price_elasticity_of_demand">&ldquo;Price elasticity of demand&rdquo;</a> might make sense in theory, but in practice may not work as expected. Even more so when used in an effort to bring social change.</p>
<blockquote>
<p>When a product becomes more expensive, people use less of it. Carbon pricing is an elegant mechanism by which market economics can work on behalf of the climate rather than against it.
But if the idea’s straightforwardness is its great economic advantage, it has also proved to be its political flaw. Energy, for utilities and transportation, is a major cost of living. And across the industrialized world, the middle class and the poor have been struggling with slow income growth.</p>
</blockquote>
<p>The <a href="https://en.wikipedia.org/wiki/Yellow_vests_movement">Yellow vests movement</a>, still ongoing, is a prime example of social unrest in response to carbon tax. In a financially strained society, people perceived the carbon tax as unjust rather than being persuaded to look for cheaper alternatives to warm their house and drive their cars.</p>
<blockquote>
<p>The question is whether any policy is both big enough to matter and popular enough to happen.</p>
</blockquote>
<p>Arizona, Michigan and Nevada tried to rally people behind clean energy while at the same time putting the responsibility squarely on energy companies. The goal was to incentivise people to opt for clean energy while at the same time making renewables more profitable for businesses through the use of performance standards. Keep the last part in mind; off to Peru.</p>
<blockquote>
<p>On Dec. 13, 1941, a piece broke off a hanging glacier and fell into Palcacocha, creating a great wave that overwhelmed a natural dam and sent a flood surging toward Huaraz, a provincial capital in the Peruvian Andes, about 14 miles below. A third of the city was destroyed and at least 1,800 people were killed.</p>
</blockquote>
<p>Since then, the government has posted guardians to watch the lake, measuring water levels, reporting on avalanches etc. due to the risk of flooding. In the meantime, local farmers that depend on the lake have concerns over the diminishing clean water.</p>
<blockquote>
<p>“I depend, in every sense, on the mountain,” he told me. “It is everything.”</p>
</blockquote>
<p>A man named Saúl Luciano Lliuya, &ldquo;who had never left his country&rdquo;, took it upon himself to travel to Germany and file a lawsuit against an energy company for sharing some of the responsibility. The &ldquo;crazy&rdquo; thing is that this German energy company does not operate in Peru nor there is evidence that is directly responsible for the ice melting. Still, the lawsuit is about the impact its operations have on the climate on a global scale!</p>
<blockquote>
<p>Beginning in the 1990s, courts began to find tobacco companies liable for the health effects of cigarette smoking, even though smokers used their products willingly and even though the first 800 or so lawsuits against the companies failed.</p>
</blockquote>
<p>Back then, the tobacco industry in its defence claimed that people made a choice to smoke hence it can&rsquo;t be held responsible. Eventually, a subpoena to turn over internal documents proved that companies knew smoking was harmful. In an effort to maximise profits, appease shareholders and stay afloat, individuals practiced the art of deceit.</p>
<p>Today, this is one of the arguments energy companies are making too. People choose how to warm their homes and drive their cars. But do they, when income inequality is so prevalent in societies today?</p>
<blockquote>
<p>And when New York City filed suit against BP and others, the companies responded that the city, because of its use of the oil industry’s products in its own police cars and garbage trucks and so on, shouldn’t be able to sue because it had what’s known as “unclean hands.” If everyone is at fault, the argument goes, no one can be held responsible.</p>
</blockquote>
<p>The same argument you&rsquo;ll hear from a kid caught eating a cookie from the jar, pointing the finger back at you exclaiming &ldquo;You made them!&rdquo;</p>
<blockquote>
<p>But the parallels aren’t perfect. Unlike tobacco, energy companies have argued, the existence of the fossil-fuel economy has provided considerable advantages to society.</p>
</blockquote>
<p>Except when energy companies lobby for coal, crude oil, fracking in an effort to keep existing profits, unless compelled by law to do otherwise. Think back to the campaign on clean energy and regulation based on performance standards.</p>
<blockquote>
<p>That companies actively prevented the development of alternative energy sources and the regulation of carbon-intensive ones, thus politically and economically propping up a polluting system. “It’s incorrect to say that there’s a strong public demand for fossil fuels,” Sher, the plaintiffs’ lawyer, told me. “What we have is a desire for energy.”</p>
</blockquote>
<p>Markets may decide on the price of goods and services. Individuals may act out of self-interest causing harm and resulting in people&rsquo;s death but as long as morals guide us and justice prevails, I am hopeful for the future. <a href="http://americanradioworks.publicradio.org/features/prestapes/mlk_speech.html">&ldquo;The arc of the moral universe is long, but it bends toward justice.&rdquo;-</a></p>
<h2 id="related">Related</h2>
<ul>
<li><a href="https://ia.net/topics/ethics-and-ethics">“Ethics” and Ethics by Oliver Reichenstein</a></li>
<li><a href="https://scholar.harvard.edu/sandel/publications/what-money-cant-buy-moral-limits-markets">What Money Can&rsquo;t Buy: The Moral Limits of Markets by Michael J. Sandel</a></li>
</ul>
]]></description>
        <pubDate>Sat, 13 Apr 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Moving the needle</title>
        <link>https://qnoid.com/2019/03/15/Moving-the-needle.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/03/15/Moving-the-needle.html</guid>
        <description><![CDATA[<p><em>Approximately 3&rsquo; minutes reading time</em></p>
<p><img src="/images/2019/03/15/2120308540_bdc5d060df_z.png" alt=""></p>
<p>For the past few months, I have been working on Windmill 3.0 which enables <a href="https://windmill.qnoid.com/mac/">Windmill on the Mac</a> to publish your iOS app.</p>
<p>Effectively, every time you make a code change, Windmill will also publish your app so that you can install it <a href="https://windmill.qnoid.com/iphone/">on your iPhone</a>.</p>
<p>This feature requires a subscription and a <a href="https://qnoid.com/2019/01/17/User-Accounts.html#main">Windmill account</a>.</p>
<p><strong>I wanted to make this as streamlined and integrated as possible.</strong></p>
<p>Here are the requirements.</p>
<ul>
<li>There shouldn&rsquo;t be a strong ordering between creating an account and purchasing a subscription.</li>
<li>A subscription enables publishing and listing of apps.</li>
<li>As long as a subscription is active, publishing and listing of apps must be enabled.</li>
<li>Access to publish and list apps must be protected by an access token.</li>
<li>The access token must have the same security requirements as any. Being cryptographically secure, have an expiry date, able to revoke it, not reused across clients.</li>
<li>The number of steps required to create an account, subscribe and gain access to publish and list apps should be kept at a minimum.</li>
<li>A user should be involved as little as possible and only where and when required.</li>
<li>No <a href="https://qnoid.com/2014/02/22/Why-arent-we-password-free-yet.html#main">user passwords</a>!</li>
<li>Anonymous.</li>
</ul>
<p>And an important limitation.</p>
<ul>
<li>Windmill on the Mac is not sandboxed<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> therefore it cannot use <code>StoreKit</code> to purchase or restore a subscription.</li>
</ul>
<p>I won&rsquo;t go into the technical details in this post.</p>
<p>For now I&rsquo;ll just say you need to have done a ton of background reading, gained a great deal of knowledge and experience using both Apple&rsquo;s platforms and SDKs, as well as</p>
<p>at a high level,</p>
<ul>
<li>a <a href="https://qnoid.com/2019/02/26/Primitive-testing-of-a-REST-API-in-bash.html#main">REST API</a>,</li>
<li><a href="https://tools.ietf.org/html/rfc7519">JSON Web Token(s)</a></li>
<li><a href="https://developer.apple.com/documentation/cloudkit">CloudKit Notifications and Subscriptions</a>.</li>
</ul>
<p>at the low level,</p>
<ul>
<li><a href="https://developer.apple.com/documentation/dispatch">Grand Central Dispatch</a></li>
<li><a href="https://developer.apple.com/documentation/foundation/notifications">Notifications</a></li>
<li><a href="https://docs.swift.org/swift-book/LanguageGuide/Properties.html#ID262">Property Observers</a></li>
<li><a href="https://developer.apple.com/documentation/security">Keychain and Secure Storage</a>.</li>
</ul>
<p>Suffice to say that it takes a well coordinated software engineering dance that I had to choreograph every turn across the App Store, mobile, server and the desktop.</p>
<p>I almost cried seeing it work for the first time.</p>
<p><img src="/images/2019/03/15/IMG_4771.jpg" alt=""></p>
<p>What I have to show you is what it looks like to the end user.</p>
<p>Here is Windmill on the iPhone. I have just added an <code>SKPayment</code> into the <code>SKPaymentQueue</code> and about to approve the purchase.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/03/15/windmill_on_the_iPhone_Purchase_Subscription.mp4" type="video/mp4" />
</video>
<p><em>The listed app you see is because I have already been a subscriber in the past and already have one app published.</em></p>
<p>Nothing &ldquo;special&rdquo;. One thing to keep in mind. At this point the user may or may have not signed in to their iCloud account. Assuming that they have, here is what happens next.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/03/15/windmill_publishing.mp4" type="video/mp4" />
</video>
<p>Windmill on the Mac is notified that a valid subscription exists. Based on this &ldquo;claim&rdquo;, it acquires an access token and starts publishing<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>.</p>
<p>That&rsquo;s it! There is nothing more before or after. Seriously. When the user first opens the app, here is what they see.</p>
<p><img src="/images/2019/03/15/launch.png" alt=""></p>
<p>There is no step to create an account. Just a nudge to log in and turn iCloud Drive on.</p>
<p><img src="/images/2019/03/15/welcome.png" alt=""></p>
<p>Here is what the account screen shows for a subscribed user.</p>
<p><img src="/images/2019/03/15/account.png" alt=""></p>
<p>I am very proud of this.-</p>
<p><img src="/images/2019/03/15/Apple-WWDC-2019-03142019.jpg" alt="Write code. Blow minds."></p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>As of right now I don&rsquo;t even know if it is possible, what it would take or whether it makes sense. As an indie developer I simply can&rsquo;t afford it in both time and resources.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>There is one more precondition based on the specification of Windmill. The &ldquo;export&rdquo; stage must have been successful. If the &ldquo;export&rdquo; stage hasn&rsquo;t run yet, Windmill will effectively wait before it starts publishing.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Fri, 15 Mar 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>iOS automation - the current state of affairs</title>
        <link>https://qnoid.com/2019/03/13/iOS-automation-the-current-state-of-affairs.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/03/13/iOS-automation-the-current-state-of-affairs.html</guid>
        <description><![CDATA[<p><em>Approximately 10&rsquo; minutes reading time</em></p>
<blockquote>
<p><a href="https://silverhammermba.github.io/blog/about/">Maxwell Anselm</a> writing about <a href="https://silverhammermba.github.io/blog/2019/03/12/slowlane">Life in the slow lane</a>.</p>
</blockquote>
<p>I want to take this opportunity to say why I believe going back to Jenkins alongside writing and maintaining scripts is a step backwards, re-iterate what the goal of Windmill is and what has been guiding its development.</p>
<p>Before I go into the details, I do wholeheartedly understand where Maxwell (among others in my mind) is coming from. I have been an iOS Developer since 2009 and in the past I too have used Jenkins (with bash scripts) to automate the delivery of iOS apps. For the record, I have also used Xcode Bots and Buddybuild. I have never used fastlane; I am just familiar with it.</p>
<h2 id="building-from-the-command-line-with-xcode">Building from the Command Line with Xcode</h2>
<p>As it stands, if you want to build (test, export, archive, etc.) an Xcode project, you have to use Xcode&rsquo;s command-line tools. I believe this is great!</p>
<ul>
<li>It demonstrates that Apple is keen on providing developer tools beyond an editor and a simulator and hopes you can help with that. It tells me it&rsquo;s been listening to the voice of the community to support continuous integration systems.</li>
<li>It puts the responsibility to develop and maintain the command-line tools squarely on Apple. We should cherish, embrace and encourage Apple to do this. Apple is better positioned to know what&rsquo;s coming, build to specification and provide support for developers in a timely fashion.</li>
</ul>
<p>I have witnessed the progress Apple has made which, to me, demonstrates commitment.</p>
<ul>
<li><code>xcodebuild</code> has unified Xcode actions providing consistency and interoperability between them. Back in 2014, you had to use <code>xcrun PackageApplication</code> to export an IPA. Today <code>xcodebuild -exportArchive -archivePath xcarchivepath -exportPath destinationpath -exportOptionsPlist path</code> mirrors Xcode&rsquo;s workflow and is compatible with <code>xcodebuild archive</code>.</li>
<li>Apple strives for feature parity across Xcode and its command-line tools. e.g. <a href="https://developer.apple.com/documentation/security/notarizing_your_app_before_distribution/customizing_the_notarization_workflow?language=objc">You can notarize your app from the command line</a>.</li>
<li>Sessions on automation and command-line tools are part of WWDC. e.g. <a href="https://developer.apple.com/videos/play/wwdc2017/403/">What&rsquo;s New in Signing for Xcode and Xcode Server</a></li>
<li>Apple writes documentation like the <a href="https://developer.apple.com/library/archive/technotes/tn2339/_index.html">Technical Note TN2339</a> and drops hints on what the command-line tools are there for.</li>
</ul>
<blockquote>
<p>Note: build-for-testing and test-without-building provide support for continuous integration systems. - &ldquo;<em>Building from the Command Line with Xcode FAQ, Updated: 2017-06-19</em>&rdquo;</p>
</blockquote>
<p>That&rsquo;s not to say that Apple gets everything right. I too have fought with and found running tests from the command-line to be unreliable. Having to restart the <code>CoreSimulatorService</code> as a result. Windmill is prone to this too.</p>
<p>I won&rsquo;t claim to know what&rsquo;s at fault here. I do believe Apple knows it reflects bad on them. Xcode <strong>engineers are working on this</strong> after all. Plus, it puts every tool that relies on them in a bad light.</p>
<h2 id="dependencies">Dependencies</h2>
<blockquote>
<p>Windmill relies heavily on existing conventions as set by Apple and aims to establish a best practice on how to automate building, testing and distributing apps. At this stage, what Windmill is able to achieve and to what extent is defined by Apple. There is no way around it. This is a conscious decision. To pretend otherwise would be to rely on reverse engineering, side effects, undocumented features and observable behaviours. For bringing that basic level of automation it should be enough. - &ldquo;<a href="https://windmill.qnoid.com/blog/Announcing-Windmill.html">Announcing Windmill</a>&rdquo;</p>
</blockquote>
<p>With that in mind, I made the conscious decision to build Windmill with Xcode&rsquo;s command-line tools and those tools alone<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>.</p>
<p>It&rsquo;s unfortunate that as of today we can&rsquo;t completely rely on <code>xcodebuild</code> to provide automation for Xcode projects. It is precisely for this reason why we need to keep giving feedback to Apple so that it can continue developing and supporting the command-line tools.</p>
<p>For example, it is not possible to know whether an Xcode project has a test target (i.e. has tests to run) until you have tried to run those tests. In other words, you have to run <code>xcodebuild test-without-building</code>, trap the error by querying the exit code and &ldquo;assume&rdquo; the project has no tests.</p>
<p>For Windmill, I had to write a <code>ProcessManager</code><sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup> that executes a <a href="https://developer.apple.com/documentation/foundation/process"><code>Process</code></a> and can recover from an error code.</p>
<p>Another example is when the output of <code>xcrun simctl list devices --json</code> changed, effectively being <a href="https://github.com/Carthage/Carthage/issues/2691">unable to find the available iOS simulators</a>.</p>
<p>This is what Apple had to say:</p>
<blockquote>
<p>While we try to not be unnecessarily disruptive, the format of that output is subject to change over time as features are added and we need to adjust it.</p>
</blockquote>
<p>Which is fine! As long as changes like this are better communicated, documented, formally specified, deprecated and retired like any API.</p>
<h2 id="reliability">Reliability</h2>
<p>Which brings us to reliability and Maxwell&rsquo;s strong argument against fastlane or any automation tool built on top of Xcode&rsquo;s command-line tools for that matter.</p>
<blockquote>
<p>Seeing this stuff makes me nervous, because I worry that fastlane is doing a bunch of extra work that</p>
</blockquote>
<ul>
<li>at best, I don’t care about or</li>
<li>at worst, is going to cause problems that I have to fix (don’t laugh, read on…)&quot;</li>
</ul>
<p>The <code>-showBuildSettings</code> tells you what <code>deployment target</code> a project is or what its <code>product</code> name is. It helps finding the correct simulator to use since <code>xcodebuild</code> requires you to specify what <code>destination</code> to use with <code>build-for-testing</code>.</p>
<p>Xcode reads all of that from the project file under &ldquo;Build Settings&rdquo; and defaults to a <code>scheme</code> (or a <code>target</code>) and gives you a list of simulators appropriate for your project. <code>xcodebuild</code> is a command-line tool after all and Xcode is a GUI app.</p>
<p>Still, why should Maxwell care about all of this? As far as he is concerned <strong>he does know</strong> what scheme to build for his project and what destination (i.e. simulator) to test against.</p>
<p>It is true that when you build a tool for the many, you do need to accommodate for cases that go beyond the needs of the one. This rings more true when you build an automation tool that has to be reliable, predictable, consistent across environments and configurations.</p>
<p>To pick the correct device to build and test for that means being able to do so across Xcode installations and upgrades, removal of simulators, changes in the deployment target of your app, etc than merely choosing what destination may be valid right now.</p>
<p>Establishing a process that automates all aspects of the delivery of your app for quality assurance in order to save time, money and effort demands more than simply knowing what scheme to build your project with; as you may have witnessed in an effort to ditch, in this case, fastlane.</p>
<p>More importantly, it is about making continuous delivery ubiquitous, accessible, understood by everyone in your team so that together you can progress further.</p>
<p>Collectively as an iOS community, we have spent an insane amount of time and put an immense amount of effort in automating the delivery of our apps by writing flaky scripts in bash using Jenkins, reverse engineering the Xcode project file format, writing blog posts with our findings.</p>
<p>Yet we are none the wiser and have barely made a dent.</p>
<p>Yes, some of it is not critical or essential to any one of us as individuals but working on and having a tool that has these goals in mind will lead to a better tool for everyone in the long run. It will allow us to move on to whatever the next challenge in delivering iOS apps is.</p>
<h2 id="complexity">Complexity</h2>
<blockquote>
<p>&ldquo;I felt like I had to babysit it every day, constantly diagnosing whether build or test failures were legitimate. Consequently the rest of my team never trusted it.&rdquo; - <em>Maxwell Anselm, Life in the slow lane</em></p>
</blockquote>
<p>When <a href="https://windmill.qnoid.com/blog/Announcing-Windmill.html">Windmill first came out</a>, it didn&rsquo;t surface any errors so you had to go through the logs to find out what went wrong. In this regard, it was no better than a bare-bone Jenkins installation showing you the log of a build job. As a developer, you had to manually go through the output of <code>xcodebuild</code> to figure out what went wrong.</p>
<p>Since Windmill is a developer tool, developers were eager to debug it! &ldquo;If only I could see what command Windmill is running, I can try and replicate the issue&rdquo;.</p>
<p>You see, I knew right then<sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> that Windmill was failing to live up to its mission. You shouldn&rsquo;t have to debug Windmill!</p>
<p>Since version 2.0, Windmill mirrors the Xcode log. <code>xcodebuild</code> does not provide a formatted output so I had to build it and actively maintain it for each release. This costs time, effort and it&rsquo;s not streamlined to Xcode upgrades. Still, I am willing to pay that price for Windmill to deliver on its promise.</p>
<p>I have put an insane amount of effort and time to make sure <a href="https://windmill.qnoid.com/mac/">Windmill mirrors Xcode&rsquo;s behaviour</a> so that when Windmill fails it does in the exact same way as Xcode.</p>
<p>Windmill has a long way to go before it can be the tool I envision. As an example, right now Windmill is reactive only to code changes.</p>
<p>If a distribution certificate expires, Windmill will surface that error the next time you commit a code change rather than at the time it expires or even better, warn you in advance.</p>
<h2 id="why-use-anything-else-but-xcodebuild">Why use anything else but xcodebuild?</h2>
<p>People don&rsquo;t realise how much time they have spent installing, building, maintaining, communicating, debugging their way to, at the very least, automate building and testing their iOS app until they decide they&rsquo;ve had enough.</p>
<p>In Maxwell case, his post on <a href="https://silverhammermba.github.io/blog//2018/08/03/osx-jenkins">Distributed iOS builds with Jenkins</a> was in Aug 3, 2018 and &ldquo;Life in the slow lane&rdquo; in Mar 12, 2019.</p>
<p>Speaking for Windmill, I have taken the strong stance to build it on the following premise.</p>
<ul>
<li>Have a native, macOS app with an unparalleled user experience in an effort to make continuous delivery accessible.</li>
<li>Lean on and don&rsquo;t stray away from Xcode&rsquo;s command-line tools provided functionality.</li>
<li>Don&rsquo;t resort to hacks to make Apple&rsquo;s command-line tools work.</li>
<li>Rely on the macOS SDK and macOS toolchain. e.g. <a href="https://developer.apple.com/documentation/foundation/propertylistserialization">PropertyListSerialization</a> to convert a property list to and from several serialized formats.</li>
<li>Link to Apple&rsquo;s documentation and encourage developers to have an understanding of how things work where necessary.</li>
<li>Minimise the use of informal contracts, i.e. parsing of standard output.</li>
<li>Don&rsquo;t overstep any boundaries, i.e. Xcode&rsquo;s ability to manage automatic signing.</li>
<li>Embrace Xcode&rsquo;s provided functionality, i.e. store archives in the Organiser.</li>
<li>Don&rsquo;t create abstractions on top of existing concepts, e.g. what an archive is on iOS.</li>
<li>Mirror and match Xcode behaviour to provide consistency across, e.g. how build errors and test failures are surfaced and communicated.</li>
<li>Be a good citizen on macOS as a native app.</li>
</ul>
<p>That&rsquo;s not to say that Windmill is 100% foolproof. See its <a href="https://windmill.qnoid.com/changelog">version history</a>.</p>
<p>Still, what Windmill offers today, even at <a href="https://windmill.qnoid.com/blog/Windmill-2.0.html">version 2.0</a>, is of great value, especially if you all you need is a basic level of automation while developing your app.</p>
<p>In the end, I have made the decision to place my faith in Apple by building a native macOS app with Xcode&rsquo;s command-line tools and invest so much in the <a href="https://windmill.qnoid.com/iphone/">Apple ecosystem</a>. Until Apple comes up with something better.-</p>
<p>PS. I am using Windmill on macOS while developing Windmill on the iPhone and I am loving it! There is a chance of bias.<br>
PPS. If you want to be part of the Windmill on the iPhone beta, sometime in the unknown future, please send me an email at <code>qnoid@windmill.io</code>.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Windmill does depend on other macOS tools like python and awk as a necessary evil where <code>xcodebuild</code> falls short as well as frameworks like <code>ObjectiveGit</code> and <code>Alamofire</code> at the application level.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>Let me know if you have an interest in this for your macOS app and I will put the time aside to publish the source code alongside some documentation on how to use it.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>I knew this was a limitation of Windmill 1.0 at the time and had plans on addressing it in Windmill 2.0.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Wed, 13 Mar 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Standing on the shoulders of giants</title>
        <link>https://qnoid.com/2019/03/06/Standing-on-the-shoulders-of-giants.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/03/06/Standing-on-the-shoulders-of-giants.html</guid>
        <description><![CDATA[<p><a href="https://github.com/Alamofire/Alamofire/graphs/contributors">Alamofire</a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">        <span class="k">return</span> <span class="n">sessionManager</span><span class="p">.</span><span class="n">upload</span><span class="p">(</span><span class="n">multipartFormData</span><span class="p">:</span> <span class="p">{</span> <span class="n">multipartFormData</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">            <span class="n">multipartFormData</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">export</span><span class="p">.</span><span class="n">url</span><span class="p">,</span> <span class="n">withName</span><span class="p">:</span> <span class="s">&#34;ipa&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="n">multipartFormData</span><span class="p">.</span><span class="n">append</span><span class="p">(</span><span class="n">export</span><span class="p">.</span><span class="n">manifest</span><span class="p">.</span><span class="n">url</span><span class="p">,</span> <span class="n">withName</span><span class="p">:</span> <span class="s">&#34;plist&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">},</span> <span class="n">with</span><span class="p">:</span> <span class="n">urlRequest</span><span class="p">,</span> <span class="n">queue</span><span class="p">:</span> <span class="kc">self</span><span class="p">.</span><span class="n">queue</span><span class="p">,</span> <span class="n">encodingCompletion</span><span class="p">:</span> <span class="p">{</span> <span class="n">result</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="k">switch</span> <span class="n">result</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">case</span> <span class="p">.</span><span class="n">success</span><span class="p">(</span><span class="kd">let</span> <span class="nv">upload</span><span class="p">,</span> <span class="kc">_</span><span class="p">,</span> <span class="kc">_</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">                <span class="n">upload</span><span class="p">.</span><span class="n">validate</span><span class="p">().</span><span class="n">responseData</span><span class="p">(</span><span class="n">queue</span><span class="p">:</span> <span class="kc">self</span><span class="p">.</span><span class="n">queue</span><span class="p">)</span> <span class="p">{</span> <span class="n">response</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">                    <span class="k">switch</span> <span class="p">(</span><span class="n">response</span><span class="p">.</span><span class="n">result</span><span class="p">,</span> <span class="n">response</span><span class="p">.</span><span class="n">result</span><span class="p">.</span><span class="n">value</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="k">case</span> <span class="p">(.</span><span class="n">failure</span><span class="p">(</span><span class="kd">let</span> <span class="nv">error</span><span class="p">),</span> <span class="kc">_</span><span class="p">):</span>
</span></span><span class="line"><span class="cl">                        <span class="k">switch</span> <span class="n">error</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                        <span class="k">case</span> <span class="kd">let</span> <span class="nv">error</span> <span class="k">as</span> <span class="n">AFError</span> <span class="k">where</span> <span class="n">error</span><span class="p">.</span><span class="n">isResponseSerializationError</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">                            <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">.</span><span class="n">async</span><span class="p">{</span>
</span></span><span class="line"><span class="cl">                                <span class="n">completion</span><span class="p">(</span><span class="kc">nil</span><span class="p">,</span> <span class="kc">nil</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                            <span class="p">}</span>
</span></span><span class="line"><span class="cl">                        <span class="k">case</span> <span class="kd">let</span> <span class="nv">error</span> <span class="k">as</span> <span class="n">AFError</span> <span class="k">where</span> <span class="n">error</span><span class="p">.</span><span class="n">isResponseValidationError</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">                            <span class="k">switch</span> <span class="p">(</span><span class="n">error</span><span class="p">.</span><span class="n">responseCode</span><span class="p">,</span> <span class="n">response</span><span class="p">.</span><span class="n">data</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                            <span class="k">case</span> <span class="p">(</span><span class="mi">401</span><span class="p">,</span> <span class="kd">let</span> <span class="nv">data</span><span class="p">?):</span>
</span></span><span class="line"><span class="cl">                                <span class="k">if</span> <span class="kd">let</span> <span class="nv">response</span> <span class="p">=</span> <span class="nb">String</span><span class="p">(</span><span class="n">data</span><span class="p">:</span> <span class="n">data</span><span class="p">,</span> <span class="n">encoding</span><span class="p">:</span> <span class="p">.</span><span class="n">utf8</span><span class="p">),</span> <span class="kd">let</span> <span class="nv">reason</span> <span class="p">=</span> <span class="n">SubscriptionError</span><span class="p">.</span><span class="n">UnauthorisationReason</span><span class="p">(</span><span class="n">rawValue</span><span class="p">:</span> <span class="n">response</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                                    <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">.</span><span class="n">async</span><span class="p">{</span>
</span></span><span class="line"><span class="cl">                                        <span class="n">completion</span><span class="p">(</span><span class="kc">nil</span><span class="p">,</span> <span class="n">SubscriptionError</span><span class="p">.</span><span class="n">unauthorised</span><span class="p">(</span><span class="n">reason</span><span class="p">:</span><span class="n">reason</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">                                    <span class="p">}</span>
</span></span><span class="line"><span class="cl">                                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                                    <span class="n">DispatchQueue</span><span class="p">.</span><span class="n">main</span><span class="p">.</span><span class="n">async</span><span class="p">{</span>
</span></span><span class="line"><span class="cl">                                        <span class="n">completion</span><span class="p">(</span><span class="kc">nil</span><span class="p">,</span> <span class="n">SubscriptionError</span><span class="p">.</span><span class="n">unauthorised</span><span class="p">(</span><span class="n">reason</span><span class="p">:</span> <span class="kc">nil</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">                                    <span class="p">}</span>
</span></span><span class="line"><span class="cl">                                <span class="p">}</span></span></span></code></pre></div>
]]></description>
        <pubDate>Wed, 06 Mar 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>A life filled with music</title>
        <link>https://qnoid.com/2019/03/06/A-life-filled-with-music.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/03/06/A-life-filled-with-music.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/kN0SVBCJqLs" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>I can recall that eye-opening feeling paired with excitement from discovering my music library all over again.</p>
<p>I had an iPhone 3G when I bought my first iPod Classic. For the first time I was able to carry with me all my iTunes Music library.</p>
<p>Every song I listened to was a trip down memory lane oozing with emotion.</p>
<p>Walking on top of Wearmouth Bridge on a cold winter night in Sunderland, listening to a Blind Guardian cover of Dio&rsquo;s Don&rsquo;t Talk To Strangers.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/J3DlQi9YCXg" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Spending Easter with a loved one in Coventry listening to Brian May.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/rNa5kRX45tg" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Dancing to Found An Angel at The Palace Night Club on Newcastle Road.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/xFEQYseUNWs" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Feeling haunted by Eminem - Stan ft Dido.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/H5jXCTn_BS8" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Crying to Angels by Robbie Williams.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/luwAMFcc2f8" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Being melancholic to Street Spirit by Radiohead.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/LCJblaUkkfc" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>Music spoke to me, made me cry, comforted me, filled me with joy, caused me to reflect.</p>
<p>I have been a subscriber to Spotify since 2009. Music is more accessible than ever yet it sits in the background. It has lost its impact.</p>
<p>In an effort to increase play time (i.e. revenue) music services have lost touch with what role music plays.</p>
<p>You feel (want to feel) happy? Here is a &ldquo;Happy Hits&rdquo; playlist.
Are you at the gym? Here is a &ldquo;Motivational&rdquo; playlist.
Want to retreat to yourself? Here is a &ldquo;Sad Songs&rdquo; playlist.</p>
<p>This isn&rsquo;t about owning versus streaming music. It&rsquo;s not about albums vs playlists. This is about feeling connected to music. This is about &ldquo;owning&rdquo; a music library that reflects, encompasses, enriches life. Your life.-</p>
]]></description>
        <pubDate>Wed, 06 Mar 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Greek residency as a European citizen</title>
        <link>https://qnoid.com/2019/03/05/Greek-residency-as-a-European-citizen.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/03/05/Greek-residency-as-a-European-citizen.html</guid>
        <description><![CDATA[<p>Today I learned from an <a href="https://www.lynnroulo.com/meet-our-community/jacob-manolas/">immigration lawyer</a> (Recommended!) that as a European citizen to be formally recognised as a resident in Greece (i.e. that is if you plan on staying for longer than 3 months) you must:</p>
<ul>
<li>have health insurance, either private or the European health card (e.g. for a UK Citizen, <a href="https://www.gov.uk/european-health-insurance-card">Apply for a European Health Insurance Card</a>)</li>
<li>have proof of permanent residence in Greece</li>
<li>have four, thousand euro (€4000) in a bank account, readily available for withdrawal.</li>
</ul>
<p>That is, so as not be considered an illegal(?) immigrant.<br>
That is, to call Greece home.<br>
That is, in the European Union where ”free movement and residence rights” exist.</p>
<p><a href="https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=LEGISSUM:l33152">EU freedom of movement and residence</a></p>
<p>Based on the “Directive 2004/38/EC”, EU countries could may well ask you to leave or even deport you after 3 months. As far as I can see, the only reason they might not is purely on good faith among them.</p>
<p>To my mind, the European Union must be more integrated.-</p>
]]></description>
        <pubDate>Tue, 05 Mar 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Primitive testing of a REST API in bash</title>
        <link>https://qnoid.com/2019/02/26/Primitive-testing-of-a-REST-API-in-bash.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/02/26/Primitive-testing-of-a-REST-API-in-bash.html</guid>
        <description><![CDATA[<p>I have been developing the Windmill REST API using <a href="https://docs.oracle.com/javaee/7/tutorial/jaxrs.htm">JAX-RS</a> and wanted a very basic, lightweight way to ensure the API hasn&rsquo;t <a href="https://en.wikipedia.org/wiki/Regression_testing">regressed</a>.</p>
<p>I have been using <a href="https://curl.haxx.se/docs/manpage.html">curl</a> to quickly check the API anyway so I thought I&rsquo;d take it a step further.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"><span class="cp">#!/bin/bash
</span></span></span><span class="line"><span class="cl"><span class="cp"></span>
</span></span><span class="line"><span class="cl"><span class="nb">set</span> -e
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="k">function</span> assertTrue<span class="o">()</span>
</span></span><span class="line"><span class="cl"><span class="o">{</span>
</span></span><span class="line"><span class="cl"><span class="k">if</span> <span class="o">[</span> <span class="si">${</span><span class="nv">1</span><span class="si">}</span> -eq <span class="si">${</span><span class="nv">2</span><span class="si">}</span> <span class="o">]</span><span class="p">;</span> <span class="k">then</span>
</span></span><span class="line"><span class="cl"><span class="nb">echo</span> *SUCCESS*
</span></span><span class="line"><span class="cl"><span class="k">else</span>
</span></span><span class="line"><span class="cl"><span class="nb">echo</span> <span class="s2">&#34;*FAILURE* expected: </span><span class="si">${</span><span class="nv">1</span><span class="si">}</span><span class="s2"> actual: </span><span class="si">${</span><span class="nv">2</span><span class="si">}</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nb">exit</span> <span class="m">1</span>
</span></span><span class="line"><span class="cl"><span class="k">fi</span>
</span></span><span class="line"><span class="cl"><span class="o">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">echo</span> <span class="s2">&#34;Given valid subscription access; Assert GET exports 200 OK&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nv">HTTP_CODE</span><span class="o">=</span><span class="k">$(</span><span class="nb">set</span> -x<span class="p">;</span>curl -s -o /dev/null -w <span class="s2">&#34;%{http_code}&#34;</span> https://api.windmill.io/account/qnoid/exports -H <span class="s2">&#34;Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpc1ZhbGlkIn0.rqED0v7meSp72MBaeQtyXce3S_dJoh_eo6iIV2Rpt3s&#34;</span><span class="k">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">set</span> +x<span class="p">;</span>assertTrue <span class="m">200</span> <span class="s2">&#34;</span><span class="si">${</span><span class="nv">HTTP_CODE</span><span class="si">}</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">echo</span> <span class="s2">&#34;Given invalid subscription access; Assert GET exports 401 Unauthorized&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nv">HTTP_CODE</span><span class="o">=</span><span class="k">$(</span><span class="nb">set</span> -x<span class="p">;</span>curl -s -o /dev/null -w <span class="s2">&#34;%{http_code}&#34;</span> https://api.windmill.io/account/qnoid/exports -H <span class="s2">&#34;Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpc1ZhbGlkIn0.3zjr4euU206esZpd0w6Au4o5qYk4ydiuAKXE6SClUaw&#34;</span><span class="k">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nb">set</span> +x<span class="p">;</span>assertTrue <span class="m">401</span> <span class="s2">&#34;</span><span class="si">${</span><span class="nv">HTTP_CODE</span><span class="si">}</span><span class="s2">&#34;</span></span></span></code></pre></div>
<p>Which gives the following output</p>
<pre><code>Given valid subscription access; Assert GET exports 200 OK
++ curl -s -o /dev/null -w &quot;%{http_code}&quot; https://api.windmill.io/account/qnoid/exports -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpc1ZhbGlkIn0.rqED0v7meSp72MBaeQtyXce3S_dJoh_eo6iIV2Rpt3s'
*SUCCESS*

Given invalid subscription access; Assert GET exports 401 Unauthorized
++ curl -s -o /dev/null -w &quot;%{http_code}&quot; https://api.windmill.io/account/qnoid/exports -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpc1ZhbGlkIn0.3zjr4euU206esZpd0w6Au4o5qYk4ydiuAKXE6SClUaw'
*SUCCESS*
</code></pre>
<p>In case of a failure, execution stops right away with the following output</p>
<pre><code>Given valid subscription access; Assert GET exports 200 OK
++ curl -s -o /dev/null -w &quot;%{http_code}&quot; https://api.windmill.io/account/qnoid/exports -H 'Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpc1ZhbGlkIn0.rqED0v7meSp72MBaeQtyXce3S_dJoh_eo6iIV2Rpt3s'
*FAILURE* expected: 200 actual: 401
</code></pre>
<p>It&rsquo;s very primitive and not hardened but it should work in the meantime.-</p>
]]></description>
        <pubDate>Tue, 26 Feb 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to replace the `rootViewController` of the `UIWindow` in iOS</title>
        <link>https://qnoid.com/2019/02/15/How_to_replace_the_-rootViewController-_of_the_-UIWindow-_in_iOS.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/02/15/How_to_replace_the_-rootViewController-_of_the_-UIWindow-_in_iOS.html</guid>
        <description><![CDATA[<p><em>Approximately 11&rsquo; minutes reading time</em></p>
<blockquote>
<p>This is an advanced topic. It requires extensive background knowledge and experience. Unless you feel confident with what&rsquo;s being discussed here, consider and be mindful of intricacies and unknown unknowns when implementing presentation transitions, state preservation and restoration on iOS.</p>
</blockquote>
<h2 id="errata">Errata</h2>
<p><strong>18 February 2019</strong>, commit &ldquo;<a href="https://github.com/qnoid/rootViewController/commit/7d3cccf2a447833bd0908e4e0c34fd9685c1c88b">7d3cccf</a>&rdquo;</p>
<ul>
<li>The <code>RootViewController</code> had its Container View as a subview rather than being the view. Though technically is allowed, in this case it is not a requirement.</li>
<li>The <span style="word-wrap: break-word;"><code>RootViewController.viewDidLayoutSubviews()</code> used to call <code>self.transition(from:to:)</code> which in certain layouts it leads to an unwanted animation. Instead, it now uses <code>self.switch(source:destination:)</code> to position its child view controller.</li>
</ul>
<h2 id="table-of-contents">Table of Contents</h2>
<div class="toc">
<ul>
<li><a href="#Introduction">Introduction</a></li>
<li><a href="#View_Controllers_Presentation_and_transitions">View Controllers’ Presentation and transitions</a></li>
<li><a href="#State_Preservation_and_Restoration">State Preservation and Restoration</a></li>
<li><a href="#Container_View_controller">Container View Controller</a></li>
<li><a href="#Considerations">Considerations</a></li>
<li><a href="#Conclusion">Conclusion</a></li>
<li><a href="#Sample_Project">Sample Project</a></li>
<li><a href="#References">References</a></li>
<li><a href="#Related">Related</a></li>
</ul>
</div>
<h2 id="a-nameintroductionaintroduction"><a name="Introduction"></a>Introduction</h2>
<p>Have you ever needed to build an app that:</p>
<ul>
<li>expects the user to go through a lengthy registration process then land on a &ldquo;home screen&rdquo;?</li>
<li>has an extensive tutorial that the user can go through before they start using the app?</li>
<li>goes through a series of on boarding screens, possibly keeping track of user progress?</li>
</ul>
<p><img src="/images/2019/02/15/registration.png" alt="Registration Flow"></p>
<p>In the above example, once the user has gone through registration, you want to discard every view controller involved in the sequence as well as replacing the <code>rootViewController</code> with a new <code>UIViewController</code> that comes after registration.</p>
<p><img src="/images/2019/02/15/mainViewController.png" alt="Main View Controller"></p>
<p>Notice how <strong>there is no use case</strong> where the user can navigate back to registration. There is no &ldquo;Back&rdquo; or &ldquo;Dismiss&rdquo; button in the <code>MainViewController</code> that can act as the root. For that reason, you should consider it best practise to discard any <code>UIViewController</code>s and their respective views so as to bring overall memory usage down and establish a new baseline when a user has registered.</p>
<h2 id="a-nameview_controllers_presentation_and_transitionsaview-controllers-presentation-and-transitions"><a name="View_Controllers_Presentation_and_transitions"></a>View Controllers&rsquo; Presentation and transitions</h2>
<p>Let&rsquo;s start with firing a <code>Notification</code> when the user selects &ldquo;Done&rdquo;.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">class</span> <span class="nc">DoneViewController</span><span class="p">:</span> <span class="n">UIViewController</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="kd">static</span> <span class="kd">let</span> <span class="nv">NotificationDone</span> <span class="p">=</span> <span class="n">NSNotification</span><span class="p">.</span><span class="n">Name</span><span class="p">(</span><span class="n">rawValue</span><span class="p">:</span> <span class="s">&#34;Done&#34;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="kr">@IBAction</span> <span class="kd">func</span> <span class="nf">didTouchUpInsideDone</span><span class="p">(</span><span class="kc">_</span> <span class="n">sender</span><span class="p">:</span> <span class="nb">Any</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">		<span class="n">NotificationCenter</span><span class="p">.</span><span class="k">default</span><span class="p">.</span><span class="n">post</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="n">DoneViewController</span><span class="p">.</span><span class="n">NotificationDone</span><span class="p">,</span> <span class="n">object</span><span class="p">:</span> <span class="kc">nil</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">	<span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Since the <code>AppDelegate</code> holds a reference to the <code>UIWindow</code> and by extension the <code>rootViewController</code>, it can act as an observer. Upon firing, it merely sets the <code>rootViewController</code> property to the new one.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">func</span> <span class="nf">application</span><span class="p">(</span><span class="kc">_</span> <span class="n">application</span><span class="p">:</span> <span class="n">UIApplication</span><span class="p">,</span> <span class="n">didFinishLaunchingWithOptions</span> <span class="n">launchOptions</span><span class="p">:</span> <span class="p">[</span><span class="n">UIApplication</span><span class="p">.</span><span class="n">LaunchOptionsKey</span><span class="p">:</span> <span class="nb">Any</span><span class="p">]?)</span> <span class="p">-&gt;</span> <span class="nb">Bool</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="n">NotificationCenter</span><span class="p">.</span><span class="k">default</span><span class="p">.</span><span class="n">addObserver</span><span class="p">(</span><span class="kc">self</span><span class="p">,</span> <span class="n">selector</span><span class="p">:</span><span class="k">#selector</span><span class="p">(</span><span class="n">done</span><span class="p">(</span><span class="n">notification</span><span class="p">:)),</span><span class="n">name</span><span class="p">:</span><span class="n">DoneViewController</span><span class="p">.</span><span class="n">NotificationDone</span><span class="p">,</span><span class="n">object</span><span class="p">:</span> <span class="kc">nil</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">	
</span></span><span class="line"><span class="cl">	<span class="k">return</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="kr">@objc</span> <span class="kd">func</span> <span class="nf">done</span><span class="p">(</span><span class="n">notification</span><span class="p">:</span> <span class="n">Notification</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="kd">let</span> <span class="nv">storyboard</span> <span class="p">=</span> <span class="n">UIStoryboard</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">&#34;Main&#34;</span><span class="p">,</span> <span class="n">bundle</span><span class="p">:</span> <span class="n">Bundle</span><span class="p">(</span><span class="k">for</span><span class="p">:</span> <span class="n">type</span><span class="p">(</span><span class="n">of</span><span class="p">:</span> <span class="kc">self</span><span class="p">)))</span>
</span></span><span class="line"><span class="cl">	<span class="kc">self</span><span class="p">.</span><span class="n">window</span><span class="p">?.</span><span class="n">rootViewController</span> <span class="p">=</span> <span class="n">storyboard</span><span class="p">.</span><span class="n">instantiateInitialViewController</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Let&rsquo;s see how that looks.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/first_attempt.mp4" type="video/mp4" />
</video>
<p>Notice how there is no transition between the <code>DoneViewController</code> and the <code>MainViewController</code>. This plays a far more important role that it currently seems as you&rsquo;ll see later. Let&rsquo;s peak behind the scenes on the view hierarchy.</p>
<p><img src="/images/2019/02/15/first_attempt_view_hierarchy.png" alt="First Attempt View Hierarchy"></p>
<p>Even though the code replaces the <code>rootViewController</code> for the window, notice how the <code>DoneViewController</code> is still in the view hierarchy under a <code>UITransitionView</code> seemingly owned by the <code>UIWindow</code>. Here is a close look at the memory graph.</p>
<p><img src="/images/2019/02/15/first_attempt_memory_graph.png" alt="First Attempt Memory Graph"></p>
<p>It looks like the <code>RegisterViewController</code> and all of its children are still very much present. Let&rsquo;s try something else now. Before replacing the <code>rootViewController</code>, use a presentation transition to present the view controller we are interested in.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kr">@objc</span> <span class="kd">func</span> <span class="nf">done</span><span class="p">(</span><span class="n">notification</span><span class="p">:</span> <span class="n">Notification</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">storyboard</span> <span class="p">=</span> <span class="n">UIStoryboard</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">&#34;Main&#34;</span><span class="p">,</span> <span class="n">bundle</span><span class="p">:</span> <span class="n">Bundle</span><span class="p">(</span><span class="k">for</span><span class="p">:</span> <span class="n">type</span><span class="p">(</span><span class="n">of</span><span class="p">:</span> <span class="kc">self</span><span class="p">)))</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">guard</span> <span class="kd">let</span> <span class="nv">viewController</span> <span class="p">=</span> <span class="n">storyboard</span><span class="p">.</span><span class="n">instantiateInitialViewController</span><span class="p">()</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">presentedViewController</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">window</span><span class="p">?.</span><span class="n">rootViewController</span><span class="p">?.</span><span class="n">presentedViewController</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="n">presentedViewController</span><span class="p">?.</span><span class="n">present</span><span class="p">(</span><span class="n">viewController</span><span class="p">,</span> <span class="n">animated</span><span class="p">:</span> <span class="kc">true</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">window</span><span class="p">?.</span><span class="n">rootViewController</span> <span class="p">=</span> <span class="n">viewController</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>From <span style="word-wrap: break-word;"><a href="https://developer.apple.com/documentation/uikit/uiviewcontroller/1621380-present"><code>UIViewController.present(_:animated:completion:)</code></a></span>, emphasis mine.</p>
<blockquote>
<p>In a horizontally regular environment, the view controller is presented in the style specified by the modalPresentationStyle property. <strong>In a horizontally compact environment, the view controller is presented full screen by default.</strong></p>
</blockquote>
<p>Since an iPhone, in <strong><a href="https://developer.apple.com/library/archive/featuredarticles/ViewControllerPGforiPhoneOS/TheAdaptiveModel.html#//apple_ref/doc/uid/TP40007457-CH19-SW4">portrait</a></strong>, is a horizontally compact environment, &ldquo;<a href="https://developer.apple.com/documentation/uikit/uimodalpresentationstyle/fullscreen">the views belonging to the presenting view controller are removed after the presentation completes</a>.&rdquo; In this case, the <code>presentedViewController</code> (i.e. the <code>DoneViewController</code>) becomes the <code>presentingViewController</code> to the <code>MainViewController</code>, hence the <code>DoneViewController</code> will be removed from the view hierarchy.</p>
<p><img src="/images/2019/02/15/second_attempt_view_hierarchy.png" alt="Second Attempt View Hierarchy"></p>
<p>The view hierarchy indeed shows only the <code>MainViewController</code> present. Still, the <code>UITransitionView</code> should give you a clue as to what to expect in the memory graph.</p>
<p><img src="/images/2019/02/15/second_attempt_memory_graph.png" alt="Second Attempt Memory Graph"></p>
<p>The <code>DoneViewContoller</code> is still very much allocated. The <code>RegisterViewController</code> as well as all of the <code>UIViewController</code> instances are also allocated (not seen in the screenshot). Finally, let&rsquo;s dismiss the whole view hierarchy, as part of presenting the <code>MainViewController</code>, before replacing the <code>rootViewController</code>.</p>
<p>From <span style="word-wrap: break-word;"><a href="https://developer.apple.com/documentation/uikit/uiviewcontroller/1621505-dismiss"><code>UIViewController.dismiss(animated:completion:)</code></a></span>, emphasis mine.</p>
<blockquote>
<p>If you present several view controllers in succession, thus building a stack of presented view controllers, calling this method on a view controller lower in the stack <strong>dismisses its immediate child view controller and all view controllers above that child on the stack</strong>.</p>
</blockquote>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kr">@objc</span> <span class="kd">func</span> <span class="nf">done</span><span class="p">(</span><span class="n">notification</span><span class="p">:</span> <span class="n">Notification</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">storyboard</span> <span class="p">=</span> <span class="n">UIStoryboard</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">&#34;Main&#34;</span><span class="p">,</span> <span class="n">bundle</span><span class="p">:</span> <span class="n">Bundle</span><span class="p">(</span><span class="k">for</span><span class="p">:</span> <span class="n">type</span><span class="p">(</span><span class="n">of</span><span class="p">:</span> <span class="kc">self</span><span class="p">)))</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">guard</span> <span class="kd">let</span> <span class="nv">viewController</span> <span class="p">=</span> <span class="n">storyboard</span><span class="p">.</span><span class="n">instantiateInitialViewController</span><span class="p">()</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">presentedViewController</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">window</span><span class="p">?.</span><span class="n">rootViewController</span><span class="p">?.</span><span class="n">presentedViewController</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="n">presentedViewController</span><span class="p">?.</span><span class="n">present</span><span class="p">(</span><span class="n">viewController</span><span class="p">,</span> <span class="n">animated</span><span class="p">:</span> <span class="kc">true</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">window</span><span class="p">?.</span><span class="n">rootViewController</span><span class="p">?.</span><span class="n">dismiss</span><span class="p">(</span><span class="n">animated</span><span class="p">:</span> <span class="kc">false</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kc">self</span><span class="p">.</span><span class="n">window</span><span class="p">?.</span><span class="n">rootViewController</span> <span class="p">=</span> <span class="n">viewController</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Here is the view hierarchy; no <code>UITransitionView</code> in the window.</p>
<p><img src="/images/2019/02/15/third_attempt_view_hierarchy.png" alt="Third Attempt View Hierarchy"></p>
<p>And here is the memory graph.</p>
<p><img src="/images/2019/02/15/third_attempt_memory_graph.png" alt="Third Attempt Memory Graph"></p>
<p>Well, that looks promising. Let&rsquo;s see how it looks. The video on the right gives you a freeze frame.</p>
<video controls playsinline preload="metadata" style="float: left">
 <source src="/video/2019/02/15/third_attempt.mp4" type="video/mp4" />
</video>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/third_attempt_freeze_frame.mp4" type="video/mp4" />
</video>
<p>What&rsquo;s happening here? In an effort to remove every <code>UIViewController</code> from the view hierarchy and memory graph, the code completely ignores the presentation. The <code>present</code> and <code>dismiss</code> calls are happening independently and on separate <strong>transition contexts</strong>.</p>
<p>Let&rsquo;s break it down.</p>
<ul>
<li>The <code>DoneViewController</code> is presenting, modally, the <code>MainViewController</code>. At the end, the <code>DoneViewController</code> is removed from the view hierarchy and deallocated.</li>
<li>The <code>rootViewController</code> (i.e. <code>RegisterViewController</code>) dismisses the <code>UINavigationController</code> all the way to the just presented <code>MainViewController</code>, which takes us back to the initial state where the <code>UIWindow</code> is showing the <code>RegisterViewController</code>.</li>
<li>The <code>RegisterViewController</code> is being replaced by the <code>MainViewController</code> as the <code>rootViewController</code>.</li>
</ul>
<h2 id="a-namestate_preservation_and_restorationastate-preservation-and-restoration"><a name="State_Preservation_and_Restoration"></a>State Preservation and Restoration</h2>
<p>Before looking into how to best replace the <code>rootViewController</code> there is one more thing to consider.</p>
<p>Up until now, we&rsquo;ve only been talking about replacing the <code>rootViewController</code> and its descendants as part of an &ldquo;initial&rdquo; launch. <strong>As long as the app isn&rsquo;t terminated</strong>, upon switching to it, its view will be restored. Still, the change in the view hierarchy is not permanent. As soon as the app is terminated by iOS due to memory pressure, the next time the user launches the app, the <code>rootViewController</code> will revert to <code>RegisterViewController</code> as if it was launched for the first time.</p>
<p>This is where state preservation and restoration feature comes in. One thing to keep in mind is that <strong>every ancestor</strong> <code>UIViewController</code>, including the one whose state you want preserved and restored <strong>must have</strong> its <code>restorationIdentifier</code> set.</p>
<p><img src="/images/2019/02/15/restorationIdentifier.png" alt="View Controllers with restoration identifiers set"></p>
<p>The simplest way to test preservation and restoration is via Xcode. Launch the app, navigate to the view controller with a <code>restorationIdentifier</code> to preserve.  Then:</p>
<ul>
<li>Put the app into the background</li>
<li>Stop the app&rsquo;s execution by pressing the stop button in Xcode</li>
<li>Launch the app</li>
</ul>
<video controls playsinline preload="metadata" style="float: left">
 <source src="/video/2019/02/15/purple.mp4" type="video/mp4" />
</video>
<video controls playsinline preload="metadata" style="float: left">
 <source src="/video/2019/02/15/blue.mp4" type="video/mp4" />
</video>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/green.mp4" type="video/mp4" />
</video>
<p>What you can&rsquo;t see from the video is that shortly after I put the app in the background, I stop the execution via Xcode. Effectively the app is now considered to be terminated by iOS.</p>
<p>That looks good. Let&rsquo;s try it on the <code>MainViewController</code> now.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/main.mp4" type="video/mp4" />
</video>
<p>You can briefly see the snapshot of the <code>MainViewController</code> that was taken just before the app moved to the background. Followed by the &ldquo;Initial UI&rdquo;.</p>
<p>Obviously the state preservation and restoration isn&rsquo;t working as expected. <strong>I haven&rsquo;t been able to gather enough information so I am only guessing</strong> that state preservation and restoration is coupled to the presentation and transition context. In other words, it&rsquo;s not enough to simply set a new <code>rootViewController</code> and expect it to be restored. Whatever <code>UIViewController</code> to be restored possibly needs to be a descendant of the &ldquo;Initial UI&rdquo;. If you do know more, I would very much like to hear from you.</p>
<h2 id="a-namecontainer_view_controlleracontainer-view-controller"><a name="Container_View_controller"></a>Container View Controller</h2>
<p>With what I know and can see so far, it appears that once the <code>rootViewController</code> has been set, <code>UIKit</code> does not provide for a way to replace it. As such, any presentation and transitions must originate from the <code>rootViewController</code> itself.</p>
<p>A Container View Controller is merely a <code>UIViewController</code> that introduces (or rather exposes) the concept of &ldquo;child&rdquo; view controllers. We came across the concept of a child view controller during presenting and dismissing view controllers.</p>
<blockquote>
<p>Container view controllers are most often used to facilitate navigation and to create new user interface types based on existing content. In almost every way, <strong>a container view controller</strong> is like any other content view controller in that it <strong>manages a root view</strong> and some content.</p>
</blockquote>
<p>One way to think about a container view controller is how a <code>UITabBarController</code> manages the presentation of the view for each <code>UIViewController</code> set in its <code>viewControllers</code> property. Every time you select a tab, the corresponding view appears into the window&rsquo;s bounds and the control is passed to its respective <code>UIViewController</code>.</p>
<p>Thinking back to what we were set out to do. <strong>We want to bring into the window the view of another view controller while replacing an existing stack of view controllers.</strong> Which sounds awfully lot like how a <code>UITabBarController</code> behaves.</p>
<p><img src="/images/2019/02/15/containerViewController.png" alt="Container View Hierarchy"></p>
<p>With the container view controller now acting as the root, the view of the <code>RegisterViewController</code> effectively is embedded in the view of the <code>RootViewController</code>. Visually, nothing has changed.</p>
<p>Now that a <code>UIViewController</code> manages the view hierarchy presented, we can replace notifications in favour of an unwind segue. Nothing to see in the <code>DoneViewController</code>. The unwind segue is defined in the storyboard.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">class</span> <span class="nc">DoneViewController</span><span class="p">:</span> <span class="n">UIViewController</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>The <code>AppDelegate</code> has all of the code related to the notification removed. Here is the code for the <code>RootViewController</code>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kd">class</span> <span class="nc">RootViewController</span><span class="p">:</span> <span class="n">UIViewController</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">private</span> <span class="kd">func</span> <span class="nf">transition</span><span class="p">(</span><span class="n">from</span><span class="p">:</span> <span class="n">UIViewController</span><span class="p">,</span> <span class="n">to</span><span class="p">:</span> <span class="n">UIViewController</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">from</span><span class="p">.</span><span class="n">willMove</span><span class="p">(</span><span class="n">toParent</span><span class="p">:</span> <span class="kc">nil</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kc">self</span><span class="p">.</span><span class="n">addChild</span><span class="p">(</span><span class="n">to</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kc">self</span><span class="p">.</span><span class="n">transition</span><span class="p">(</span><span class="n">from</span><span class="p">:</span> <span class="n">from</span><span class="p">,</span> <span class="n">to</span><span class="p">:</span> <span class="n">to</span><span class="p">,</span> <span class="n">duration</span><span class="p">:</span> <span class="kc">self</span><span class="p">.</span><span class="n">transitionCoordinator</span><span class="p">?.</span><span class="n">transitionDuration</span> <span class="p">??</span> <span class="mf">0.4</span><span class="p">,</span> <span class="n">options</span><span class="p">:</span> <span class="p">[],</span> <span class="n">animations</span><span class="p">:</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">    <span class="p">})</span> <span class="p">{</span> <span class="p">(</span><span class="n">finished</span><span class="p">)</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">        <span class="n">from</span><span class="p">.</span><span class="n">removeFromParent</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">        <span class="n">to</span><span class="p">.</span><span class="n">didMove</span><span class="p">(</span><span class="n">toParent</span><span class="p">:</span> <span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kr">@IBAction</span> <span class="kd">func</span> <span class="nf">unwindToRootViewController</span><span class="p">(</span><span class="kc">_</span> <span class="n">segue</span><span class="p">:</span> <span class="n">UIStoryboardSegue</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="kd">let</span> <span class="nv">storyboard</span> <span class="p">=</span> <span class="n">UIStoryboard</span><span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="s">&#34;Main&#34;</span><span class="p">,</span> <span class="n">bundle</span><span class="p">:</span> <span class="n">Bundle</span><span class="p">(</span><span class="k">for</span><span class="p">:</span> <span class="n">type</span><span class="p">(</span><span class="n">of</span><span class="p">:</span> <span class="kc">self</span><span class="p">)))</span>
</span></span><span class="line"><span class="cl">	
</span></span><span class="line"><span class="cl">	<span class="k">if</span> <span class="kd">let</span> <span class="nv">registerViewController</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">children</span><span class="p">.</span><span class="bp">first</span><span class="p">(</span><span class="k">where</span><span class="p">:</span> <span class="p">{</span> <span class="nv">$0</span> <span class="k">is</span> <span class="n">RegisterViewController</span> <span class="p">}),</span> <span class="kd">let</span> <span class="nv">mainViewController</span> <span class="p">=</span> <span class="n">storyboard</span><span class="p">.</span><span class="n">instantiateInitialViewController</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">	<span class="kc">self</span><span class="p">.</span><span class="n">transition</span><span class="p">(</span><span class="n">from</span><span class="p">:</span> <span class="n">registerViewController</span><span class="p">,</span> <span class="n">to</span><span class="p">:</span> <span class="n">mainViewController</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">	<span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>Let&rsquo;s see it in action.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/rootViewController.mp4" type="video/mp4" />
</video>
<p>Note that as part of the transition, the <code>DoneViewController</code> is effectively dismissed. Hence the animation that &ldquo;presents&rdquo; the <code>MainViewController</code> is the same as if the call was <code>mainViewController.dismiss(animated: true)</code> while the <code>DoneViewController</code> was presented.</p>
<p>The respective view hierarchy and memory graph</p>
<p><img src="/images/2019/02/15/container_view_hierarchy.png" alt="Container View Hierarchy"></p>
<p><img src="/images/2019/02/15/container_memory_graph.png" alt="Container Memory Graph"></p>
<p>How about state preservation and restoration.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/mainViewController.mp4" type="video/mp4" />
</video>
<p>One thing to keep in mind when preserving a <code>UIViewController</code> that acts as the container, is that your code is responsible for saving any references to its child view controllers. Here is what it looks like.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kr">override</span> <span class="kd">func</span> <span class="nf">encodeRestorableState</span><span class="p">(</span><span class="n">with</span> <span class="n">coder</span><span class="p">:</span> <span class="n">NSCoder</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kc">super</span><span class="p">.</span><span class="n">encodeRestorableState</span><span class="p">(</span><span class="n">with</span><span class="p">:</span> <span class="n">coder</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kc">self</span><span class="p">.</span><span class="n">children</span><span class="p">.</span><span class="n">forEach</span> <span class="p">{</span> <span class="n">child</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="kd">let</span> <span class="nv">restorationIdentifier</span> <span class="p">=</span> <span class="n">child</span><span class="p">.</span><span class="n">restorationIdentifier</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="n">coder</span><span class="p">.</span><span class="n">encode</span><span class="p">(</span><span class="n">child</span><span class="p">,</span> <span class="n">forKey</span><span class="p">:</span> <span class="n">restorationIdentifier</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="kr">override</span> <span class="kd">func</span> <span class="nf">decodeRestorableState</span><span class="p">(</span><span class="n">with</span> <span class="n">coder</span><span class="p">:</span> <span class="n">NSCoder</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kc">super</span><span class="p">.</span><span class="n">decodeRestorableState</span><span class="p">(</span><span class="n">with</span><span class="p">:</span> <span class="n">coder</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="kd">let</span> <span class="nv">mainViewController</span> <span class="p">=</span> <span class="n">coder</span><span class="p">.</span><span class="n">decodeObject</span><span class="p">(</span><span class="n">of</span><span class="p">:</span> <span class="p">[</span><span class="n">MainViewController</span><span class="p">.</span><span class="kc">self</span><span class="p">],</span> <span class="n">forKey</span><span class="p">:</span> <span class="s">&#34;MainViewController&#34;</span><span class="p">)</span> <span class="k">as</span><span class="p">?</span> <span class="n">MainViewController</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="n">addChild</span><span class="p">(</span><span class="n">mainViewController</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>When the <code>RootViewController</code> is instantiated as part of the &ldquo;Initial UI&rdquo;, the <code>RegisterViewController</code> will also be present in its &ldquo;children&rdquo; property. Therefore as part of the layout, we need to make sure the <code>MainViewController</code> is the only one in the view hierarchy.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="kr">override</span> <span class="kd">func</span> <span class="nf">viewDidLayoutSubviews</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">registerViewController</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">children</span><span class="p">.</span><span class="bp">first</span><span class="p">(</span><span class="k">where</span><span class="p">:</span> <span class="p">{</span> <span class="nv">$0</span> <span class="k">is</span> <span class="n">RegisterViewController</span> <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nv">mainViewController</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">children</span><span class="p">.</span><span class="bp">first</span><span class="p">(</span><span class="k">where</span><span class="p">:</span> <span class="p">{</span> <span class="nv">$0</span> <span class="k">is</span> <span class="n">MainViewController</span> <span class="p">})</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">switch</span> <span class="p">(</span><span class="n">registerViewController</span><span class="p">,</span> <span class="n">mainViewController</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">case</span> <span class="p">(</span><span class="kd">let</span> <span class="nv">registerViewController</span><span class="p">?,</span> <span class="kd">let</span> <span class="nv">mainViewController</span><span class="p">?):</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span><span class="p">.</span><span class="k">switch</span><span class="p">(</span><span class="n">source</span><span class="p">:</span> <span class="n">registerViewController</span><span class="p">,</span> <span class="n">destination</span><span class="p">:</span> <span class="n">mainViewController</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">default</span><span class="p">:</span>
</span></span><span class="line"><span class="cl">        <span class="k">break</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kc">super</span><span class="p">.</span><span class="n">viewDidLayoutSubviews</span><span class="p">()</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">private</span> <span class="kd">func</span> <span class="p">`</span><span class="k">switch</span><span class="p">`(</span><span class="n">source</span><span class="p">:</span> <span class="n">UIViewController</span><span class="p">,</span> <span class="n">destination</span><span class="p">:</span> <span class="n">UIViewController</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">    <span class="n">source</span><span class="p">.</span><span class="n">willMove</span><span class="p">(</span><span class="n">toParent</span><span class="p">:</span> <span class="kc">nil</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">destination</span><span class="p">.</span><span class="n">view</span><span class="p">.</span><span class="n">frame</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">view</span><span class="p">.</span><span class="n">bounds</span>
</span></span><span class="line"><span class="cl">    <span class="kc">self</span><span class="p">.</span><span class="n">view</span><span class="p">.</span><span class="n">addSubview</span><span class="p">(</span><span class="n">destination</span><span class="p">.</span><span class="n">view</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">    <span class="n">source</span><span class="p">.</span><span class="n">view</span><span class="p">.</span><span class="n">removeFromSuperview</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">    <span class="n">source</span><span class="p">.</span><span class="n">removeFromParent</span><span class="p">()</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="n">destination</span><span class="p">.</span><span class="n">didMove</span><span class="p">(</span><span class="n">toParent</span><span class="p">:</span> <span class="kc">self</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span></span></span></code></pre></div>
<p>This time, the <code>MainViewController</code> is restored as expected.</p>
<video controls playsinline preload="metadata">
 <source src="/video/2019/02/15/restoredViewController.mp4" type="video/mp4" />
</video>
<p>For completeness, here are the visual hierarchy and memory graph of the app after the restore process is done.</p>
<p><img src="/images/2019/02/15/restore_view_hierarchy.png" alt="Container View Hierarchy"></p>
<p><img src="/images/2019/02/15/restore_memory_graph.png" alt="Container Memory Graph"></p>
<h2 id="a-nameconsiderationsaconsiderations"><a name="Considerations"></a>Considerations</h2>
<p>Keep in mind that the user can, at any time, kill the app. At this point, the restoration process will not happen and the <code>rootViewController</code> will revert back to the one in the &ldquo;Initial UI&rdquo;. This will also happen if your app crashes.</p>
<blockquote>
<p>ISTR that removing the app from the multitasking UI specifically disables state restoration, on the grounds that the user only does this when there’s something wrong with the app and thus it’s better to start from a clean slate. - <a href="https://developer.apple.com/forums/thread/68675?answerId=198881022#198881022">Quinn “The Eskimo!”</a>, Apple Developer Relations, Developer Technical Support, Core OS/Hardware</p>
</blockquote>
<p>You should anticipate, embrace and gracefully handle your app reverting to its &ldquo;Initial UI&rdquo;.</p>
<p>As an example, in the case of a registration, it is possible that you store some authorization token to give access to the user. On startup, you can detect that and allow the user to login with the existing credentials.</p>
<p>One thing to consider is that if you decide to hardcode the decision as to what <code>rootViewController</code> to show, you effectively limit the choices you can give to a user to recover for a &ldquo;bad state&rdquo;. If the user cannot merely terminate the app, they will have to re-install.</p>
<p>Consider giving the user the ability to fallback in stages:</p>
<ul>
<li>While the user is using the app:
<ul>
<li><strong>to revert</strong> to a previous state; e.g. logout</li>
</ul>
</li>
<li>By removing the app from the multitasking UI:
<ul>
<li><strong>to remove</strong> any existing state, either through preservation or in memory; e.g.  recover from a crash</li>
</ul>
</li>
<li>By un-installing:
<ul>
<li><strong>to erase</strong> any hard persisted data. e.g. an authorization token so as to start over.</li>
</ul>
</li>
</ul>
<h2 id="a-nameconclusionaconclusion"><a name="Conclusion"></a>Conclusion</h2>
<p>tl;dr. You should use a Container View Controller as the <code>rootViewController</code> and swap one child <code>UIViewController</code> for another.</p>
<p>Should you wish to preserve the <code>rootViewController</code>, consider the native iOS support of preserving and restoring state.</p>
<p>Keep in mind that state preservation and restoration goes beyond what <code>UIViewController</code> is present. UIKit views can also have preservable state. As an example, a <code>UIScrollView</code> preserves its <code>zoomScale</code>, <code>contentInset</code>, and <code>contentOffset</code> properties, effectively &ldquo;<a href="https://developer.apple.com/documentation/uikit/uiscrollview#1653221">so that the content appears scrolled to the same position as before</a>&rdquo;.</p>
<p>That can be useful for persisting any registration steps as the user goes through, browses through a collection of photos or reads a long text.</p>
<p>I would like to thank @marc, @jsorge, @tekl of <a href="http://seattlexcoders.org">Seattle Xcoders</a> for their input and for keeping me sane through this. Even though I am remote, Seattle Xcoders has welcomed me as if I am based in Seattle.</p>
<p>Shoutout to <a href="http://backslashn.com">Andy</a>. It <a href="https://stackoverflow.com/a/34814662/3887">may have taken 3 years</a> but we did it!</p>
<h2 id="one-more-thing">One more thing</h2>
<p>This is one of the many technical challenges that I am tackling as part of making <a href="https://windmill.qnoid.com/iphone/">Windmill on the iPhone</a> the best experience it can be.</p>
<p>I have been busy working towards Windmill 3.0 which brings publishing of your apps during development.</p>
<p>You can download <a href="https://windmill.qnoid.com">Windmill</a> for free.-</p>
<h2 id="a-namesample_projectasample-project"><a name="Sample_Project"></a>Sample Project</h2>
<p><a href="https://github.com/qnoid/rootViewController">github.com/qnoid/rootViewController</a></p>
<h2 id="a-namereferencesareferences"><a name="References"></a>References</h2>
<ul>
<li><a href="https://developer.apple.com/library/archive/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/StrategiesforImplementingYourApp/StrategiesforImplementingYourApp.html#//apple_ref/doc/uid/TP40007072-CH5-SW2"><strong>Preserving Your App’s Visual Appearance Across Launches</strong></a>, App Programming Guide for iOS</li>
<li><a href="https://developer.apple.com/library/archive/featuredarticles/ViewControllerPGforiPhoneOS/PreservingandRestoringState.html"><strong>Preserving and Restoring State</strong></a>, View Controller Programming Guide for iOS</li>
<li><a href="https://developer.apple.com/library/archive/featuredarticles/ViewControllerPGforiPhoneOS/ImplementingaContainerViewController.html"><strong>Implementing a Container View Controller</strong></a>, View Controller Programming Guide for iOS</li>
<li><a href="https://developer.apple.com/documentation/uikit/uiviewcontroller"><strong>UIViewController</strong></a>, Documentation &gt; UIKit &gt; View Controllers</li>
</ul>
<h2 id="a-namerelatedarelated"><a name="Related"></a>Related</h2>
<div class="toc">
<ul>
<li><a href="https://stackoverflow.com/questions/34813889/replacing-the-uiwindows-rootviewcontroller-while-using-a-transition-appears-to">Replacing the UIWindow&rsquo;s rootViewController while using a transition, appears to be leaking</a></li>
<li><a href="https://www.youtube.com/watch?v=lyNHJOsAxIs">Memory and CPU Profiling</a></li>
<li><a href="https://developer.apple.com/library/archive/documentation/iPhone/Conceptual/iPhoneOSProgrammingGuide/StrategiesforHandlingAppStateTransitions/StrategiesforHandlingAppStateTransitions.html#//apple_ref/doc/uid/TP40007072-CH8-SW1">Strategies for Handling App State Transitions</a></li>
<li><a href="https://developer.apple.com/library/archive/qa/qa1561/_index.html#//apple_ref/doc/uid/DTS40007952">Technical Q&amp;A QA1561, How do I programmatically quit my iOS application?</a></li>
<li><a href="https://developer.apple.com/library/archive/technotes/tn2298/_index.html">Technical Note TN2298, Using Unwind Segues</a></li>
<li><a href="https://developer.apple.com/documentation/uikit/uipresentationcontroller">UIPresentationController</a>, Documentation &gt; UIKit &gt; View Controllers</li>
</ul>
</div>
]]></description>
        <pubDate>Fri, 15 Feb 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Hiring for diversity</title>
        <link>https://qnoid.com/2019/01/25/Hiring-for-diversity.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/01/25/Hiring-for-diversity.html</guid>
        <description><![CDATA[<p><em>Approximately 3'30&rsquo;&rsquo; minutes reading time</em></p>
<p>Ask yourself a question. &ldquo;Do we hire for diversity&rdquo;? If the answer is &ldquo;We hire based on merit&rdquo;, chances are you aren&rsquo;t doing enough.</p>
<p>By leaving diversity to chance, you assume and expect a uniform distribution of people with different race, age, gender and social status to arrive at your doorstep.</p>
<p>This is not the case. Take tech as an example.</p>
<p><img src="/images/2019/01/25/2604WEB_college-enrollment-v3-fix.jpg" alt="">
<em><strong>Source: <a href="https://www.wired.com/story/computer-science-graduates-diversity/">WOMEN AND MINORITIES IN TECH</a>, Wired</strong></em></p>
<blockquote>
<p>As this chart shows, white men dominate college computer science departments. By a lot. One of the reasons for this may be the way companies try to recruit talent. Stanford researchers observed more than 75 recruiting sessions held by more than 60 companies and identified countless seemingly obvious ways the recruiters might be alienating female recruits, from sexist jokes to presentations displaying only slides of men.</p>
</blockquote>
<p>I encourage you to read the whole article on Wired which is an excellent piece, on how the use of words, access to resources (e.g. computers at home) and <a href="https://www.forbes.com/sites/tanyatarr/2018/04/04/by-the-numbers-what-pay-inequality-looks-like-for-women-in-tech/#92232660b113">salary inequality</a> play a role.</p>
<p>Start by measuring the distribution among your current hires. One way to do this is by creating an anonymous, optional questionary. It&rsquo;s important that you have a discussion first. Make sure everyone understands what the intent is and buys into it.</p>
<p>ustwo, a London agency, has gone a step further and created a public <a href="https://diversity.ustwo.com">Diversity Dashboard</a> to, as far as I can see, demonstrate commitment, raise awareness and to be held accountable.</p>
<p>Keep in mind that those numbers may also reveal a bias in hiring, while you believe you are merely focusing on merit.</p>
<blockquote>
<p>A 2015 study followed up on this, and found that candidates with black-sounding names from elite universities did only as well as those with white-sounding names from less-selective schools.<br>
<em><strong>Source: <a href="https://www.nytimes.com/2016/02/28/magazine/is-blind-hiring-the-best-hiring.html">Is Blind Hiring the Best Hiring?, The New York Times</a></strong></em></p>
</blockquote>
<p>It may be possible that you are unknowingly exhibiting bias during your hiring process by expecting people to &ldquo;fit in&rdquo; rather than to &ldquo;come as they are&rdquo;. Feeding into a cultural conformity as opposed to diversity.</p>
<p>Who is present at an interview and how people express or respond can equally discourage people to come forward or be allowed to proceed. Having a diverse representation when you start from a non diverse background can be challenging.</p>
<p>Once again, ustwo has created a Head of Diversity role to <a href="https://www.ustwo.com/blog/inclusion-and-diversity-at-ustwo-london/">tackle lack of equal representation</a> head on and drive change.</p>
<blockquote>
<p>We are completely overhauling our hiring process. This will include standardised questions and mixed interview groups. We will seek ways to ensure we are meeting a diverse range of candidates which we hope will lead to an increase in hiring of underrepresented candidates. <br>
<em><strong>Whitney Berry, Head of Diversity, ustwo</strong></em></p>
</blockquote>
<p>Below I am only suggesting a list of actions that you could take, across different areas to <a href="https://qnoid.com/2016/03/28/Diversity-and-Inclusion.html#main">help diversity flourish</a>.</p>
<h2 id="education">Education</h2>
<ul>
<li>Work with local authorities to provide training to <a href="http://researchbriefings.parliament.uk/ResearchBriefing/Summary/SN06705">unemployed young people</a> that have dropped out of education (<a href="https://en.wikipedia.org/wiki/NEET">NEET</a>).</li>
<li>Work with Universities to provide internships/placements to minority groups.</li>
</ul>
<h2 id="hiring">Hiring</h2>
<ul>
<li>Take action to avoid discrimination based on gender/age/race when screening candidates.</li>
<li>Involve a diverse group of people in the hiring process.</li>
<li>Actively seek to hire minorities for head/management/leadership roles.</li>
</ul>
<h2 id="support">Support</h2>
<ul>
<li>Support <a href="https://twitter.com/RichardAmplery/status/819138127348584448">meetups</a> and groups that give a voice to under represented people (e.g. LGBT) and invite them to talk in house to raise awareness.</li>
<li>Fund people in need either directly or via a matching contribution to employees; <a href="https://www.kiva.org/">KIVA</a>.</li>
<li>Fund charities and institutions that defend people&rsquo;s rights to education and employment.</li>
<li>Fund <a href="https://twitter.com/uikonf/status/818410212180848641">diversity tickets</a> at conferences.</li>
<li>Give people time off to volunteer in causes that have a social impact.</li>
</ul>
<h2 id="day-to-day-operations">Day to day operations</h2>
<ul>
<li>Be open, encourage and support ideas and views that challenge norms.</li>
<li>Measure, track and have visibility on data that shows how diverse the company is.</li>
<li>Provide parental leave as a work benefit.</li>
</ul>
<h2 id="further-reading">Further Reading</h2>
<ol>
<li><a href="https://www.bbc.co.uk/programmes/b01f5lcg">Should universities give preference to applicants from poor backgrounds?</a></li>
<li><a href="https://www.theguardian.com/world/2018/aug/08/tokyo-medical-school-admits-changing-results-to-exclude-women">Tokyo medical school admits changing results to exclude women</a></li>
</ol>
]]></description>
        <pubDate>Fri, 25 Jan 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>User Accounts</title>
        <link>https://qnoid.com/2019/01/17/User-Accounts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/01/17/User-Accounts.html</guid>
        <description><![CDATA[<p><em>Approximately 2'30&rsquo;&rsquo; minutes reading time</em></p>
<p>Windmill thus far has been devoid of the concept of a user account. There hasn&rsquo;t been a need since Windmill has been a standalone macOS app. With the arrival of <a href="https://windmill.qnoid.com/iphone/">Windmill on the iPhone</a> the requirement to have a &ldquo;user&rdquo; account becomes more apparent.</p>
<p>On the iPhone, a user should be able to view the IPA file for each app that has been <a href="https://windmill.qnoid.com/mac/#install-the-app-on-a-device">exported</a>. There are two parts in enabling this functionality.</p>
<ul>
<li>Publish an export for a given &ldquo;user&rdquo;.</li>
<li>Return a list of exports for a given &ldquo;user&rdquo;.</li>
</ul>
<p>Both to be supported by a server that provides a REST API.</p>
<h2 id="requirements">Requirements</h2>
<p>The simplest thing would be to have a user create an account using a username and a password. I take a few issues with this approach.</p>
<h3 id="no-passwords">No passwords.</h3>
<p>First and foremost <a href="https://qnoid.com/2014/02/22/Why-arent-we-password-free-yet.html#main">I consider asking a user for a password a compromise in security</a> for the following reasons.</p>
<ul>
<li>Users tend to <a href="https://www.troyhunt.com/password-reuse-credential-stuffing-and-another-1-billion-records-in-have-i-been-pwned/">reuse passwords across services</a>.</li>
<li><a href="https://haveibeenpwned.com">Database leaks</a> expose user accounts across services.</li>
<li>Security is effectively weakened by using email to authenticate a user via password resets.</li>
</ul>
<h3 id="cross-device-platform-support">Cross device, platform support.</h3>
<p>Windmill is a native macOS app. Windmill on the iPhone will be a native iOS app. A user should be able to use Windmill from macOS, iOS and possibly the web.</p>
<p>A solution needs to be able to work, potentially, for every Apple platform as well as the web.</p>
<h3 id="anonymous">Anonymous.</h3>
<p>Ideally, I would like to take user accounts a step further and provide this functionality without even asking for an email. An email can be used to identify an individual and is data that can be exploited by a malicious third party should it become compromised.</p>
<h2 id="in-summary">In Summary</h2>
<ul>
<li>No password. The server should be able to authenticate a user without the need of a password.</li>
<li>Cross device/platform support. The user should be able to use Windmill from a different device and/or platform. e.g. Safari on the Mac, Windmill macOS, Windmill iOS.</li>
<li>Anonymous. User shouldn&rsquo;t have to enter an email to identify with the service.</li>
</ul>
<p>Plus, it should be as seamless as possible with very little friction and overhead.</p>
<p>After some research and discussion<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>, it looks like <a href="https://developer.apple.com/icloud/cloudkit/">CloudKit</a> might be able to check all the boxes.</p>
<p>I will have to investigate further.</p>
<h2 id="see-also">See also</h2>
<ul>
<li><a href="https://developer.apple.com/videos/play/wwdc2016/226/">What&rsquo;s New with CloudKit</a> - WWDC 2016 - Session 226 - iOS, macOS, tvOS, watchOS</li>
<li><a href="https://cdn.apple-cloudkit.com/cloudkit-catalog/#authentication">CloudKit Authentication</a></li>
<li><a href="https://developer.apple.com/library/archive/documentation/DataManagement/Conceptual/CloudKitWebServicesReference/SettingUpWebServices.html#//apple_ref/doc/uid/TP40015240-CH24-SW3">CloudKit Web Services Reference</a></li>
</ul>
<blockquote>
<p>Some database operations require that users sign in using their Apple ID. Your web app will need to handle these authentication errors and present the user with a dialog to sign in. Apple will present the actual sign-in page through a redirect URL so that the user’s credentials remain confidential. If the user chooses to sign in, the response contains a web authentication token that you use in the subpath of subsequent requests. - &ldquo;CloudKit Web Services Reference, 2016-06-13&rdquo;</p>
</blockquote>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Thank you <a href="https://twitter.com/mattfarrugia">Matt Farrugia</a> for offering some of your time to bounce these ideas off of you.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Thu, 17 Jan 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Public Spaces</title>
        <link>https://qnoid.com/2019/01/09/Public-Spaces.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/01/09/Public-Spaces.html</guid>
        <description><![CDATA[<p><em>Approximately 2'30&rsquo;&rsquo; minutes reading time</em></p>
<p>Yesterday I felt like having a conversation. I wanted to talk about user authentication on iOS. How to implement it <a href="https://qnoid.com/2014/02/22/Why-arent-we-password-free-yet.html#main">without asking the user for a password</a>. I wanted to do even better and have <a href="https://marco.org/2018/04/27/overcast42">anonymous user accounts</a>.</p>
<p>I was excited! Like a little kid that comes home from school and wants to talk to his parents about something new. Then, I stumbled. Who do I talk to about this? I am not at an office. I am not sitting at a co-working space. I am not attending a developers&rsquo; conference. Suddenly, I paused. Where is everybody? How do I reach out?</p>
<p>I thought of Twitter first. One reason I love Twitter is how it makes everyone accessible. You can direct your message at anyone and everyone. So I did, knowing full well that the chances of someone coming back are slim.</p>
<p>Twitter is more about sharing your thoughts, talking about what&rsquo;s happening now. Twitter is async by nature. It&rsquo;s not a way to have a discussion. Let alone getting a reply to jump on a call to have a conversation.</p>
<p>Then I thought of Slack. I am a member of some channels and occasionally spend some time on <a href="https://www.meetup.com/Athens-iOS-MeetUps/">Athens iOS Meetups</a>. I also decided to visit the <a href="https://xcoders.org/">Seattle Xcoders</a> channel. Surely these are the places you can find iOS developers to have a chat with.</p>
<p>Not really. Just because people can be found there, doesn&rsquo;t mean they are available. When you step into the room people don&rsquo;t have to greet you. In fact, such a behaviour is not netiquette. Saying &ldquo;g&rsquo;day&rdquo;, &ldquo;καλημέρα&rdquo;, &ldquo;bonjour&rdquo; messages is just noise<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>. Asking a question doesn&rsquo;t mean it will get acknowledged. At best, what you will have is an async, robotic chat. With any form of expression narrowed down to written dialog. No eye-popping dialogue, no raising eyebrows, no gesticulations, nodding, human interaction.<sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup></p>
<p>Finally, I thought of email. I will admit this was getting silly. Still, I looked around on people&rsquo;s websites that I felt I wanted to talk to. Not much. No email information. No contact me. No happy to talk. Nothing. In fact, I&rsquo;m guilty of that too!</p>
<p>Huh? In an online world, where we are all connected and accessible, where is everybody?</p>
<p>With social media focusing on individual expression and ways to satisfy our need for external validation where do we gather to exchange thoughts, ideas, knowledge?</p>
<p>In a world filled with co-working spaces and open plans offices why do we wait for lunch or a coffee break to converse? How accessible are these spaces to the public?</p>
<p>Are we all too busy working, driven by numbers maximising output that both our <a href="https://en.wikipedia.org/wiki/Ego_depletion">willpower</a> and availability have diminished?</p>
<p>Where are our public gathering spaces used for civil discourse?</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Walking into a <a href="https://en.wikipedia.org/wiki/Kafenio">Kafenio</a> at a Greek village would cause the following in order. Visual assessment of the individual, acknowledgement, greeting, getting familiar, showing interest in what one has to say.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>Thank you <a href="http://marcschwieterman.com">Marc Schwieterman</a> for having a word with me.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Wed, 09 Jan 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Cookie free</title>
        <link>https://qnoid.com/2019/01/09/Cookie-free.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/01/09/Cookie-free.html</guid>
        <description><![CDATA[<p><em>Approximately 1 minute reading time</em></p>
<p>In an effort to make this site cookie free, have now completely removed Google Analytics, converted any Twitter embed links to quotes with a link to the original tweet and enabled &ldquo;Privacy-enchanced mode&rdquo; for embed YouTube</p>
<blockquote>
<p>Privacy Enhanced Mode allows you to embed YouTube videos without using cookies that track viewing behavior. This means viewing inbox isn’t collected to personalize the viewing experience. Instead, video recommendations are contextual and related to the currently played video. Videos playing in a Privacy Enhanced Mode embedded player won’t influence the viewer&rsquo;s browsing experience on YouTube.</p>
</blockquote>
<blockquote>
<p>To use Privacy Enhanced Mode, change the domain for the embed URL in your HTML from <a href="https://www.youtube.com">https://www.youtube.com</a> to <a href="https://www.youtube-nocookie.com">https://www.youtube-nocookie.com</a> as shown in the following example:</p>
</blockquote>
<p><a href="https://support.google.com/youtube/answer/171780?hl=en#">Embed videos &amp; playlists, YouTube Help</a></p>
<p>Make sure to clear any existing cookies for this website. Here is how to <a href="https://support.apple.com/en-gb/guide/safari/manage-cookies-and-website-data-sfri11471/mac">Manage cookies and website data in Safari on Mac</a>.</p>
<p>If you notice any cookies on this website, please <a href="http://www.twitter.com/qnoid">let me know</a> by sending me the URL and the type of cookie you see.</p>
<p>Good riddance I say!</p>
<p>.-</p>
]]></description>
        <pubDate>Wed, 09 Jan 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Nothing but a dream</title>
        <link>https://qnoid.com/2019/01/07/Nothing-but-a-dream.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2019/01/07/Nothing-but-a-dream.html</guid>
        <description><![CDATA[<p><em>Approximately 5 minutes reading time</em></p>
<p>In 2017 I decided to leave <a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html#main">London</a>. I was suffering with anxiety and that feeling of not belonging had come to haunt me once again. Regardless, I was hopeful, positive, optimistic and was looking forward to the future. A future I very much had romanticised. I wanted to believe. That innate need to find my calling was still burning strong after all. That&rsquo;s not to say the decision to leave was irrational or not weighted. To this day I believe it was the best decision I could have made given the circumstances. At the time it felt possible. In hindsight the chances of that future materialising were really really slim.</p>
<p>After years of <a href="https://qnoid.com/2016/12/01/Thinking-of-quitting-the-software-industry.html#main">disappointment with the software industry</a> I wanted to take a different path. A path to personal growth, doing good, generating value and bringing positive change in this world. A way to find my place in the universe.</p>
<p>I love to create. I love that software development gives me the power to create. I don&rsquo;t love software development in and of itself. I love software development that is purposeful. I love software development that satisfies a need. I love software development in the service of the people.</p>
<p>I also need to be able to make a living. Given that software development as a skill has the potential to earn you money I decided <a href="https://windmill.qnoid.com">Windmill</a> could help me with that. It was important that the two came hand in hand, doing something purposeful while also making a living.</p>
<p>Since I wasn&rsquo;t looking for employment, I had to minimise expenses while living off my savings. I also wanted to eliminate distractions. I gave away, donated most of my personal belongings and went on my way with a suitcase, a carry on bag, my laptop and around £15k of savings heading east to Australia.</p>
<p>I travelled on a tourist visa, which granted me access for 3 months into the country. Once there, I would apply for a &ldquo;Skilled independent visa&rdquo;, which by the way takes 7-8 months to be granted from the application date. Effectively this visa gives you permanent stay and the right to work. In order to <strong>be invited</strong> to apply you need to accumulate a certain number of points. You get points based on your age, education, work experience, English language etc.</p>
<p>To prove knowledge of the English language I had to take a test on reading, writing, listening, speaking. This is a test that, even as a native speaker, you can&rsquo;t just walk in and out expecting to get an almost perfect score. You have to study and prepare so that you are familiar with what will be asked of you. I didn&rsquo;t and my anxiety got the better of me.</p>
<p>There is a quota on the number of visas issued each year. Everyone is sorted, descending, based on the number of points. Invitations are sent out starting from the top. If the number of applicants is high, someone that has even the minimum required of points may never get an invite. At the time, the effective minimum required me to score an almost perfect score on <strong>every</strong> subject in the English language. On top of that, the number of applicants was only getting higher which meant that no matter what, there was no way to accumulate the number of points required.</p>
<p>Now this created a very real situation that had to be dealt with. There was a high chance that sooner or later I had to leave the country. Suffering from what I would call mild depression at the time wasn&rsquo;t helping either.</p>
<p>There was one more thing. The decision to visit Australia from the UK had to do with the fact that my partner has a dual citizenship. She too was on a path of self discovery and needed some time off to figure what she wanted to do next. It was also an opportunity for her to spend more time with family and friends after many years away. Having a home to stay while going through this transition in our lives was really really important. It provided stability and safety, gave us peace of mind.</p>
<p>Suffice to say it didn&rsquo;t play out the way we both expected. By that time, it had been 3 months since we moved to Australia and 6 since we had left London. Yet again forced to make a decision not under the best of terms, with anxiety and depression looming.</p>
<p>We could stay in Australia, where the cost of living wouldn&rsquo;t be significantly cheaper than London, where only my partner had the right to a full time job and a high risk of having to deal with a situation where I’ll be forced to leave the country.</p>
<p>Or retreat back to London, a city that I love dearly, but demands your full attention, with Brexit incoming, give up on our dreams, ignore the reasons that lead to our departure.</p>
<p>Lastly, move to Athens with lower cost of living, doubling down on our dreams, using the remaining savings we had left to rent and fully furnish an apartment.</p>
<p>Bruised and scarred, we opted to move to Athens.</p>
<p>Within 4 weeks we flew out of Australia and into a rented apartment. It turns out you can&rsquo;t outrun <a href="https://qnoid.com/2018/11/23/Anxiety-and-Depression.html#main">anxiety and depression</a>.-</p>
]]></description>
        <pubDate>Mon, 07 Jan 2019 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Anxiety and Depression</title>
        <link>https://qnoid.com/2018/11/23/Anxiety-and-Depression.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2018/11/23/Anxiety-and-Depression.html</guid>
        <description><![CDATA[<p><em>Approximately 7 minutes reading time</em></p>
<p>For a very, very, very long time, I have been suffering primarily from anxiety and on separate occasions with depression. It may appear as is if comes and goes though I would describe it as dormant, lingering under the surface. About 6 months ago it slowly creeped up on me. This time it hit the hardest. It was crippling, unbearable and nasty.</p>
<p>Since about 6 weeks ago it feels like I am on a path of recovery. <strong>If you have been suffering from anxiety and depression I want to tell you that I feel you. It is not your fault. Take your time; hang in there; don&rsquo;t be hard on yourself. You are not alone.</strong></p>
<p>For everyone else who is close to someone with anxiety and depression as a friend, family, a co-worker, a boss, a member of society; this one is for you.</p>
<p>I know it is hard for you too. It is tough dealing with someone who looks into the void, seemingly unable to make even minimum effort, show any signs of care for the world. Who wishes to die. Who can be abrupt, angry and bitter. They don&rsquo;t choose to be that way. They don&rsquo;t want to live this way. They are drowning, screaming for help.</p>
<p>I want to share this with you. It comes from a personal experience while dealing with anxiety and depression. How I reacted and perceived behaviours and attitudes. What worked and didn&rsquo;t work for me. It is not for the faint of heart.</p>
<h2 id="be-gracious">Be gracious.</h2>
<p>During that time, I was at my most vulnerable. Feeling exposed, hyper sensitive and on alert. The slightest form of confrontation felt like a warrant for a fight or flight response. An innocent joke, being judgemental, a comment on what I did, did not, had to or should not do, had a negative, disproportional impact on my mood and emotional state. Often I would shy away from discussions, events, situations in order to avoid it all.</p>
<p>I did not enjoy it when people picked on my behaviour, forced me to engage, asked me repeatedly how I was feeling, how long is &ldquo;this&rdquo; going to last, confronting me, coercing me to deal with &ldquo;it&rdquo;, man-up.</p>
<p>As long as people accepted that I wasn&rsquo;t feeling good, were calm in their demeanour when I was upset and angry, game me space to breathe and didn&rsquo;t force their expectations on me, they didn&rsquo;t make things worse.</p>
<h2 id="be-patient">Be patient.</h2>
<p>Everything was meaningless, worthless, a downward spiral into a well where there is absolutely zero joy and nothing worth doing.</p>
<p>Pushing me to get moving, asking me to do things, even more so on your time isn&rsquo;t helping. Having an opinion as to what is meaningful or what I should be doing, isn&rsquo;t good either.</p>
<p>Instead, it helped me cope when I was told to take as much time as I needed, was re-assured and was just let be.</p>
<h2 id="be-loving">Be loving.</h2>
<p>There were times where a daunting feeling would weigh upon me in just a split second. A feeling of imminent doom. A darkness consuming me for no reason. I would start feeling terrified, especially in a crowd.</p>
<p>There are absolutely zero ways to reason about this.</p>
<p>A hug, a holding hand, telling me everything will be ok, taking me somewhere where I felt safe was the best way to handle it.</p>
<h2 id="be-caring">Be caring.</h2>
<p>I was in no mood to cook, clean the house, make the bed or anything really. For reference, I have had a relatively high degree of independence since I was little (less than 10 years old) and have learned to live far and away from home, on my own, being self-sufficient since I turned 18.</p>
<p>Cooking a nice meal, cleaning and tidying up not only removed the worry but also created a nice environment to be living in. It may seem like it didn&rsquo;t make a difference but it helped.</p>
<p>I would wake up in the middle of the night with panic attacks, gasping for air, feeling like I was dying.</p>
<p>Even though I rarely asked, I am much too proud and considerate, it made me feel better when someone woke up alongside to provide comfort, help me with breathing and calm me down.</p>
<h2 id="be-fearless">Be fearless.</h2>
<p>I wanted to die.</p>
<p>Even though I never made any attempts, I did have suicidal thoughts. It is a tough thing to hear. Even writing about it gives me the chills and makes me emotional.</p>
<p>Telling me to snap out of it only put more pressure on me. Telling me to take control made me think people weren&rsquo;t listening. Downplaying it made me feel insignificant. Asking me how is this going to solve anything made me feel even more trapped and didn&rsquo;t really present me with a way out.</p>
<p>Whoever was on the receiving end had to be fearless and calm. I needed empathy. I needed to hear how important I was to them.</p>
<h2 id="be-level-headed">Be level-headed.</h2>
<p>There were days where I was willing to have a conversation about it and be more open. Still, talking about it would make me feel really uncomfortable, shaking, filled with adrenaline.</p>
<p>Pulling the rug from under my feet was not good. Presenting me with what-ifs&rsquo; or making me face reality wasn&rsquo;t cool. &ldquo;What if you get fired?&rdquo;, &ldquo;What if your partner leaves you?&rdquo;, &ldquo;You won&rsquo;t have money to pay rent&rdquo;, &ldquo;You can&rsquo;t keep doing this for long&rdquo;.</p>
<p>All these only served to amplify my anxiety and fear. At times it would also make me angry and upset.</p>
<p>In this case, I am the one being moody with irrational fears. You need to be thinking clearly. Don&rsquo;t take it personally. Don&rsquo;t feel like you are being attacked. Do not take away whatever emotional support I am hanging on to. As hard as this situation may be, remember, this is not about you.</p>
<p>Ask people before you do anything that could upset them. e.g. like turning up on their doorstep unexpected or worse sending a public servant.</p>
<h2 id="be-there">Be there.</h2>
<p>I felt alone and at times I even felt abandoned. People were busy with work, their kids and family, their significant other or just needed time for themselves.</p>
<p>Not having people there for me to the extend that I needed them was the hardest to cope with. It wasn&rsquo;t enough to just go to the movies once every month, to meet again after 2 weeks, to give me a 5 minute call to check on me or to talk via social media.</p>
<p>Being there regularly and often would have helped tremendously. Having somebody present was really important. Even when they did absolutely nothing but sit there on the same room as me. It gave me comfort.</p>
<p>People coming and going didn&rsquo;t help either. It made me feel unworthy and made me think people didn&rsquo;t care enough. Sending me a message of &ldquo;Hey, is everything ok?&rdquo; after weeks/months was not enough.</p>
<p>Having said all that, keep in mind that no matter of your good intentions chances are you alone can&rsquo;t treat someone that suffers from anxiety and depression. It is not your job anyway so don&rsquo;t feel the pressure to do so.</p>
<p>Each of you plays a different role, whether a childhood friend, a sibling, a partner, a parent. Being gracious, patient, loving, caring, fearless, level-headed and present will go a long way.</p>
<h2 id="final-words">Final words.</h2>
<p>This experience has given me the impression that overall we have no idea how to deal with people that suffer from depression and anxiety. Even worse, our behaviour at times can be detrimental to those suffering.</p>
<p>It also appears to me there is a real lack of knowledge on what depression or anxiety really is. People thought I was just having a bad day or I was just being bombastic.</p>
<p>It does not help that we don&rsquo;t talk about it more. There seems to be a stigma and a taboo associated with mental illnesses that makes people want to shut down. Living in a fast paced, demanding, increasingly isolating world does not help either.</p>
<p>Dealing with anxiety and depression requires us to be accommodating, supportive and empathetic towards each other or else we risk stretching the social fabric that connects us too thin.-</p>
<p><em>While writing this post, I kept thinking of people suffering with anxiety and depression. Some that I know of, had the courage to come forward, write, share and be open about their struggle. At the time, it made me realise I am not alone, gave me hope. I also can&rsquo;t help but think of the people that didn&rsquo;t make it. How this post might have given them a voice. A lifeline.</em></p>
<blockquote>
<p>In the US, 18.1% of the population every year suffers from anxiety disorder. <a href="https://adaa.org/about-adaa/press-room/facts-statistics">Facts &amp; Statistics, Anxiety and Depression Association of America</a></p>
</blockquote>
<blockquote>
<p>In Europe, 25% of the population suffer from depression or anxiety each year. <a href="http://www.euro.who.int/en/health-topics/noncommunicable-diseases/mental-health/news/news/2012/10/depression-in-europe/depression-in-europe-facts-and-figures">Depression in Europe: facts and figures, World Health Organisation</a></p>
</blockquote>
]]></description>
        <pubDate>Fri, 23 Nov 2018 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Thinking of quitting the software industry</title>
        <link>https://qnoid.com/2016/12/01/Thinking-of-quitting-the-software-industry.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2016/12/01/Thinking-of-quitting-the-software-industry.html</guid>
        <description><![CDATA[<p><em>Approximately 12 minutes reading time</em></p>
<p>I love software development. I believe technology is an enabler.<br>
I am also getting tired of this industry.</p>
<blockquote>
<p>At the age of 36, beginning to feel tired about the lack of principles, lack of professionalism and education in the software industry.</p>
</blockquote>
<p>My first computer was a <a href="https://en.wikipedia.org/wiki/ZX_Spectrum#ZX_Spectrum_.2B2">Sinclair ZX 128K +2</a>. I remember writing a <strong>few lines</strong> of <a href="https://en.wikipedia.org/wiki/Sinclair_BASIC">BASIC</a> but that was about it when it comes to programming. Owning an <a href="https://en.wikipedia.org/wiki/Amiga">AMIGA</a> didn&rsquo;t make any difference as I would mostly play games on it. With a PC, I started tinkering with <a href="https://en.wikipedia.org/wiki/DOS">DOS</a>, editing <a href="https://en.wikipedia.org/wiki/CONFIG.SYS">config.sys</a> and <a href="https://en.wikipedia.org/wiki/AUTOEXEC.BAT">autoexec.bat</a> files, primarily to <a href="https://en.wikipedia.org/wiki/DOS_memory_management">manage memory</a> to, guess what, run games. With the arrival of <a href="https://www.youtube.com/watch?v=5VPFKnBYOSI">Windows 95</a> I spent a lot of time understanding how hardware and software worked together, albeit at a high level. I would format the hard drive almost every week due to messing up the OS. The back of the PC never had its screws tight as I would open the case, move cards around PCI slots, change <a href="https://en.wikipedia.org/wiki/Parallel_ATA">PATA cables</a>, <a href="https://en.wikipedia.org/wiki/Overclocking">overlock</a> the CPU, install better RAM, etc. Come to think of it, <strong>I was constantly optimising</strong>.</p>
<blockquote>
<p>Have felt really bad in the past for not having a CompSci degree or for not being that good with algorithms. Please don’t fall for this.</p>
</blockquote>
<p>In 1998 I went to study at the <a href="http://www.sunderland.ac.uk">University of Sunderland</a> towards a <a href="https://en.wikipedia.org/wiki/Bachelor_of_Engineering">BEng</a> Computer System Engineering degree. After the 1st year, I switched over to a <a href="https://en.wikipedia.org/wiki/Bachelor_of_Science">BSc</a> Information Technology. I believe I did it <strong>with a career prospect in mind</strong>.</p>
<blockquote>
<p>&quot;qnoid&quot; is the name of a demo game that wrote in VB back in 1999 as a first year student at Sunderland University.</p>
</blockquote>
<p>One of my first software development assignments was to build an application using Visual Basic. I wrote a simple loop to move a &ldquo;spaceship&rdquo; left and right while deflecting a ball within the window. I wasn&rsquo;t given a high mark because the tutor assumed previous programming experience, hence the handicap. Funny.</p>
<video controls preload="auto">
 <source src="/static/2016/qnoid.mp4" type="video/mp4" />
 </video>
<p><em>Did you notice the sound effect when the game ends?</em></p>
<p>In 2001, I was offered a work placement at <a href="http://cern.ch">CERN</a>. This is where I got my first real world experience in building software. I was thrown into <a href="https://en.wikipedia.org/wiki/Java_Platform,_Enterprise_Edition">Java EE</a>, databases, XML and the web. I had no prior knowledge of any of these technologies whatsoever.</p>
<p><strong>Had to read a lot, practice even more, write code, take notes, repeat</strong>.</p>
<p><img src="/static/2016/cern.png" alt="My office at CERN">
<em>My office at CERN. Books and notes all over the desk.</em></p>
<p>The following year, I went back to University to finish my studies. That year I was taught Java as a programming language. I remember the whole class (100+ students) struggling to understand basic principles. <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">What is an object</a>, <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">what is a class</a>, what makes it abstract, what is an interface, where and how are applicable. Even though I knew what the tutor was talking about, I too had trouble forming a well rounded understanding. Hell, I remember myself at the end of the year (&ldquo;2 years&rdquo; into Java), during the exam telling my tutor &ldquo;I finally understand what an interface is&rdquo;. Still, I was ignorant of the how, the where and the why.</p>
<p>I finished University and got a job as a &ldquo;Java Web Developer&rdquo; at an Internet Service Provider working mostly for projects related to the tourism industry (don&rsquo;t ask). There was a project manager and a <strong>single developer</strong>. That would be me. A database admin was generally available to ask questions but not attached to a project. Same for a system admin. Also senior developers, colleagues working on other projects, willing to answer my ignorant questions.</p>
<blockquote>
<p>Tho <a href="https://twitter.com/macropoulos">@Macropoulos</a> is an amazing macro photographer, most knowledge that have of bash originates from him way back in 2004. Thank you Stavro.</p>
</blockquote>
<p><strong>I had no idea how to build software.</strong></p>
<p>I knew how to hack code. Did I understand anything about software design? No. How to manage a growing codebase? No. How to deal with technical debt? No. Why I had seemingly decided to opt for design X, decided on Y or go with approach Z? Of course not.</p>
<p><strong>My critical thinking in software development had developed very little all these years at University.</strong></p>
<p>I remember constantly re-writing the codebase as I was going along in an effort to get a better understanding of how code fits together including trade-offs. I would print Java articles off the Internet to read every day.</p>
<p><img src="/static/2016/forthnet.png" alt="My office at Forthnet">
<em>Notice the printed article to my right. Yeap. Had a stack of these.</em></p>
<p>I discovered <a href="https://en.wikipedia.org/wiki/Object-relational_mapping">ORM</a>, faced the &ldquo;<a href="http://www.realsolve.co.uk/site/tech/hib-tip-pitfall.php?name=why-lazy">N+1 selects</a>&rdquo; problem and learned about caching. I had an urge to understand how things work, take them apart, examine, put it all back together.</p>
<p>I fondly remember the &ldquo;<a href="http://www.headfirstlabs.com/books/hfdp/">Head First Design Patterns</a>&rdquo; book with its &ldquo;There are no dumb questions&rdquo; section. <strong>That book developed my critical thinking even more.</strong> Same goes for <a href="https://www.amazon.co.uk/Effective-Java-Second-Joshua-Bloch/dp/0321356683">Effective Java</a>.</p>
<p>I stayed for almost 4 years on that job, learning and practicing constantly. Around 2008, I also started teaching Java to final year University students. They were utterly lost, drawing parallels to my time at University 5 years ago, damn!</p>
<blockquote>
<p>When started the iPhone Stanford course in 2009 didnt imagine giving a talk on a iOS conference right after <a href="https://twitter.com/edog1203">@edog1203</a></p>
</blockquote>
<p>I held 3 more roles as a Java Developer, until 2011, working in academia and research, the media industry, finance.</p>
<p>In the meantime, in September 2009, I started attending the iPhone Stanford course on iTunes and a year later started building <a href="/software-engineer/#verylargebox">verylargebox.</a></p>
<p>I went to work as an iOS Developer at <a href="http://ncr.com">NCR</a>, lead the technical delivery of <a href="http://tescobank.com">Tesco Bank</a>&rsquo;s Mobile Banking app for the iPhone and <a href="https://qnoid.com/2016/10/17/Timings-a-bitch.html#main">just recently</a> as Head of Mobile at <a href="https://www.soldo.com">Soldo</a>.</p>
<p>Throughout my career, every time I went into a new work environment, I&rsquo;d come across a different mindset. Whether that was from developers, managers, directors; technical or not, involved in the software delivery process none the less.</p>
<p>Some didn&rsquo;t believe in the merits of <a href="https://en.wikipedia.org/wiki/Software_testing">software testing</a> or any <a href="https://en.wikipedia.org/wiki/Software_engineering">software engineering</a> principles, others in <a href="https://en.wikipedia.org/wiki/Database_normalization">database normalisation</a> or <a href="https://en.wikipedia.org/wiki/Denormalization">denormalization</a> for that matter.</p>
<p><img src="http://imgs.xkcd.com/comics/third_way.png" alt="http://xkcd.com/1285/">
<em>Thrown in there, arguments of the &ldquo;tab vs spaces&rdquo; type.</em></p>
<p>Some felt strongly about procedural programming with very little structure, others fixating on functional and reactive programming.</p>
<blockquote>
<p>If you come from an OO background and want to get a grasp on FP, one of my favourite talks from this year's <a href="https://twitter.com/nsconf">@nsconf</a> <a href="https://t.co/ej9p9NMqOV"><a href="https://t.co/ej9p9NMqOV">https://t.co/ej9p9NMqOV</a></a></p>
</blockquote>
<p><a href="https://en.wikipedia.org/wiki/Software_development_process">Software development processes</a> varying from non existing to very inefficient. Long discussion meetings, ad hoc phone calls, emails. No planning, no management, no roles, no ownership. It&rsquo;s like watching amateur football where everyone chases the ball.</p>
<blockquote>
<p>Learned <em>a lot</em> on project management and software delivery by working alongside <a href="https://twitter.com/mattfarrugia">@mattfarrugia</a> in the past. Thank you Matt!</p>
</blockquote>
<p><strong>Why do so many people involved in the software industry believe that software development is subjective?</strong></p>
<blockquote>
<p>FWIW, this is what it's like to hire for a Lead iOS developer. Worse than the worse customer acquisition strategy.</p>
</blockquote>
<p><img src="/images/2016/12/01/candidates.png" alt="candidates graph"></p>
<p><a href="https://qnoid.com/2016/01/14/We-need-to-raise-the-bar-on-software-development.html#main">The bar is low</a>. As far as I can tell and see, education (higher education, online courses, training, schools) falls short in all of these below.</p>
<ul>
<li>Academics are detached from the software industry.</li>
<li>Professionals who do know, do not necessarily make good teachers/mentors.</li>
<li>Not enough practicing your craft.</li>
<li>Teaching how to write code rather software development as a discipline.</li>
<li>Failing to develop critical thinking.</li>
</ul>
<blockquote>
<p>Whether they come from language, platform, hardware, network, interaction. Know the fundamentals, use critical judgment. Should be enough.</p>
</blockquote>
<p>It does not help that the industry is still evolving. There are new paradigms, languages, platforms and challenges all the time. Still, <a href="https://en.wikipedia.org/wiki/History_of_software">by now</a> we should have a solid foundation on which to start from and agree upon. People have very little interest in studying history when the technology always stays fresh and exciting. Repeating the same mistakes in the process, debating on issues that have already been settled, going down the same path in a different language, platform, domain.</p>
<p>The software industry is growing, without any signs of stopping any time soon, generating an unsatisfied demand for people. On top of that, there is money and there is plenty to go around.</p>
<p><a href="https://en.wikipedia.org/wiki/Startup_company">Private investments</a>, <a href="https://en.wikipedia.org/wiki/Subsidy">government funding</a> or simply because software is driving businesses everywhere that are profitable there is very little understanding of how wasteful a software development process is, concern about the quality of people through the door, incentive to invest in the people.</p>
<p><strong>Software is driving the economy and is unregulated.</strong></p>
<blockquote>
<p>Brilliant slide by <a href="https://twitter.com/unclebobmartin">@unclebobmartin</a> at <a href="https://twitter.com/xup_uk">@xup_uk</a>. Let this fictional front page suck in for a minute.</p>
</blockquote>
<blockquote>
<p>“Regulating pieces of software as if they were taxis or hotels makes no sense at all and wouldn’t help protect consumers or stimulate the economy,” said James Waterworth, vice-president of CCIA, a lobby group for the tech industry.</p>
</blockquote>
<blockquote>
<p>European court takes up the question: what is Uber? <a href="https://t.co/tbe0p2G0m0"><a href="https://t.co/tbe0p2G0m0">https://t.co/tbe0p2G0m0</a></a> — Financial Times (@FinancialTimes) <a href="https://twitter.com/FinancialTimes/status/803376469728698368">November 28, 2016</a></p>
</blockquote>
<p>So how is all that affecting the industry as a whole and me personally?</p>
<p>It is creating a culture of <a href="https://www.quora.com/Why-are-engineers-called-rockstars-and-ninjas">rockstars and ninjas</a> and the chances of finding a good, <a href="https://qnoid.com/2014/08/28/Bitwink.html#main">solid team</a> to deliver software are slim. We spend more time arguing, cranking code, boosting our egos, rather than focusing on solving problems, building software, growing personally, professionally and the industry as a whole.</p>
<p>It is considered acceptable not to be <a href="https://en.wikipedia.org/wiki/Structural_engineer">a professional</a> as long as you produce software, regardless of whether it&rsquo;s delayed, of questionable quality as long as it satisfies the business needs. It&rsquo;s all been factored in the operating cost for the company.</p>
<p>This is an industry where mediocracy rules with no sense of collectiveness and no-one being held personally accountable in their profession. Salaries are going up, no-one is grabbing us by the collar and <a href="https://en.wikipedia.org/wiki/Marc_Andreessen">software is still eating the world</a>.</p>
<p><strong>This is an industry where I am finding it hard to grow, do good, generate value and bring positive change in this world.</strong></p>
<blockquote>
<p>Building the perfect team <a href="https://twitter.com/nytimes">@nytimes</a> is worth a read; amusing that Google was looking in data. <a href="https://t.co/EmZrLoFQ1B"><a href="https://t.co/EmZrLoFQ1B">https://t.co/EmZrLoFQ1B</a></a></p>
</blockquote>
]]></description>
        <pubDate>Thu, 01 Dec 2016 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Timing&#39;s a bitch</title>
        <link>https://qnoid.com/2016/10/17/Timings-a-bitch.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2016/10/17/Timings-a-bitch.html</guid>
        <description><![CDATA[<blockquote>
<p>After 5 years in Scotland the time has come to move on. Starting tomorrow will be based in London. Looking for both a flat and a role.</p>
</blockquote>
<p>It was my first Monday in London. Had arrived only 3 days ago, on a train to King&rsquo;s Cross from Edinburgh.</p>
<p>Less than a week ago, I had put the word out that I am moving to London. I was overwhelmed by the number of calls and emails. An ex googler with a &ldquo;well funded&rdquo; startup building a &ldquo;hyperlocal&rdquo; app. A guy with &ldquo;an idea&rdquo;, having applied to a Y Combinator fellowship programme looking for a technical founder. Someone working on &ldquo;some really exciting things&rdquo; looking for a CTO. A corporation building a “digital team”. VP of Engineering roles in well known startups.  Recruiters, HR specialists and “talent people”.</p>
<p>On the <em>3rd of August 2015, 13:16</em>, I got an email that stood out from the crowd right away. The founder introduced himself, let me know how he had found my details, described the startup’s goal, its target market, funding and size. On top of that, he said what got him interested in “me”. Why he thought I was the man for the job. Finally, he told me he is happy to talk more over Skype if I’m interested.</p>
<p>During the Skype call, I basically “interviewed” the founder. On a call that lasted about 2 hours, he spent 90 minutes answering any questions I had. Finally, I said:</p>
<p>-“So, do you have any questions for me?”<br>
-“I know all about you”, he said.</p>
<p>I am now thinking, ok the guy has seen a CV, how much can he really tell just by looking at a CV.</p>
<p>-“I have read your posts, watched your talks, etc.”</p>
<p>A few months later I would notice his email on the database of <a href="https://qnoid.com/2013/08/11/On-sacrifices.html#main">verylargebox</a>. He had also used my product.</p>
<p>We arranged to meet in Rome along with the CTO and the CMO. I will just say that <strong>it was intense</strong>! The whole thing started at 4pm (flew out of London at 09:05) and I went back to my room at 2 in the morning. We talked product, we talked delivery, we talked security, we talked business, processes, culture, I loved it!</p>
<p><img src="/images/flight.png" alt=""></p>
<p>A month later I started working at <a href="https://www.soldo.com">Soldo</a> with two primary responsibilities. <a href="https://soldo.workable.com">Establish a mobile team</a> in London and deliver version 2.0 for both the iOS and Android app.</p>
<blockquote>
<p>Ecstatic to be joining a FinTech startup as head of mobile. A great honour to have this role offered. Can't wait to make things happen.</p>
</blockquote>
<h2 id="delivering-quality-software">Delivering quality software</h2>
<p>Delivering quality software takes more than <a href="https://qnoid.com/2014/08/28/Bitwink.html#main">a good team</a>. Everyone involved must possess a collective understanding on how to deliver. You need a strategy. You must educate people, put processes in place, create habits, establish communication channels. People must want the change, asking for and willing to go through it.</p>
<p>It takes a lot of trust, faith, insight, sensibility, intelligence from anyone to let you “have it your way”. There are four stages the person has to go through with you.</p>
<ol>
<li>
<p><strong>Acknowledging there is a problem.</strong> It is possible that what you are talking about isn’t even on their radar.</p>
</li>
<li>
<p><strong>Understanding how you are trying to solve it.</strong> This can prove challenging if you don’t share the same background, knowledge, expertise, understanding.</p>
</li>
<li>
<p><strong>Giving you the go ahead.</strong> Acknowledging and understanding isn’t necessarily enough to give you the green light to proceed. There are priorities, availability and on occasion <a href="https://en.wikipedia.org/wiki/Workplace_politics">politics</a>. This could lead to months of waiting time to never happening.</p>
</li>
<li>
<p><strong>Going out of their way to make it happen.</strong> This requires a change on their part. Not just operational but a change in behaviour and attitude.</p>
</li>
</ol>
<p>Having planted the seeds, I was now ready to start hiring a team.</p>
<blockquote>
<p>At <a href="https://twitter.com/soldo">@soldo</a> have found people with sensibility, that are inclusive, open to discuss, willing to change &amp; do better. Wish you could see this.</p>
</blockquote>
<h2 id="hiring-is-hard">Hiring is hard.</h2>
<p>It took 3 months just to find a “junior” iOS Developer and 5 months for a “lead” one. Damn! There are many contributing factors to this.</p>
<ul>
<li>Quality of candidates is low. Have already <a href="https://qnoid.com/2016/01/14/We-need-to-raise-the-bar-on-software-development.html#main">written on the subject.</a></li>
<li>Soldo as a workplace was not on the developers’ radar. Even personally reaching out to developers didn’t make a difference. When people have so much choice they will go for the one that ticks all the boxes. Working for a startup that you haven’t heard of is not your natural first choice.</li>
<li>Lack of engineering team in London. Unfortunately, Soldo does not have an engineering team based in London. This makes it harder to attract talent. You must be part of the community, it does not happen overnight and more than one man need to be up for it.</li>
</ul>
<p>The numbers below are over a period of 8 months.</p>
<p><img src="/images/candidates.png" alt=""></p>
<h2 id="timing">Timing</h2>
<p><img src="/images/timing.png" alt=""></p>
<p>Eventually it became clear that it was not happening. Building a startup, your priority is to find product/market fit while remaining sustainable.</p>
<p>Soldo already had an iOS and Android app that served this purpose. Building version 2.0 however important, eventually was not a priority in the grand scheme of things.</p>
<p><strong>I have decided to leave Soldo at the end of the month</strong>. Still, I am fortunate to have been part of the <a href="https://www.soldo.com">Soldo family</a> for over a year.</p>
<p>Regardless, the overwhelming acknowledgement that I have received from everyone at Soldo is unlike anything I have received so far in my life.</p>
<p>I can not thank you enough.</p>
<p>Soldo’s future is indeed bright.</p>
<p><img src="/images/soldo.png" alt=""></p>
]]></description>
        <pubDate>Mon, 17 Oct 2016 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>A primer in HTTP caching and its native support by iOS</title>
        <link>https://qnoid.com/2016/04/10/A-primer-in-HTTP-caching-and-its-native-support-by-iOS.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2016/04/10/A-primer-in-HTTP-caching-and-its-native-support-by-iOS.html</guid>
        <description><![CDATA[<h2 id="introduction">Introduction</h2>
<p><em>This post is based on Xcode 7.3 and iOS 9.3</em></p>
<p>All the information in this post can be found in the iOS documentation but the support for computing if a response is &ldquo;fresh&rdquo;.</p>
<p>This post pieces all the information together to form <strong>a primer in HTTP caching and its native support by iOS</strong>. This is by no means an exhaustive post on HTTP caching on iOS.</p>
<p>Still, this is useful if you want to understand what iOS gives you out of the box, especially if you are using an Amazon S3 via HTTP. (i.e. to store and retrieve images).</p>
<h2 id="what-does-the-ios-documentation-say">What does the iOS documentation say</h2>
<p>NSURLSession uses the <a href="https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSURLSessionConfiguration_class/index.html#//apple_ref/occ/clm/NSURLSessionConfiguration/defaultSessionConfiguration">NSURLSessionConfiguration.defaultSessionConfiguration</a>, which uses the <a href="https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSURLCache_Class/index.html#//apple_ref/occ/clm/NSURLCache/sharedURLCache">NSURLCache.sharedCached</a> for its <a href="https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSURLSessionConfiguration_class/index.html#//apple_ref/occ/instp/NSURLSessionConfiguration/URLCache">URLCache</a>.</p>
<p>From <a href="https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSURLSession_class">NSURLSession&rsquo;s documentation</a>,</p>
<blockquote>
<p>For a data task, the NSURLSession object may call the delegate’s URLSession:dataTask:willCacheResponse:completionHandler: method. Your app should then decide whether to allow caching. If you do not implement this method, the default behavior is to <strong>use the caching policy specified in the session’s configuration object</strong>.</p>
</blockquote>
<p>From <a href="https://developer.apple.com/library/ios/documentation/Foundation/Reference/NSURLSessionConfiguration_class/index.html#//apple_ref/occ/instp/NSURLSessionConfiguration/requestCachePolicy">NSURLSessionConfiguration&rsquo;s documentation</a></p>
<blockquote>
<p>Set this property to one of the constants defined in NSURLRequestCachePolicy to specify whether the cache policy should depend on expiration dates and age, whether the cache should be disabled entirely, and whether the server should be contacted to determine if the content has changed since it was last requested.</p>
</blockquote>
<p><strong>The default value is <a href="https://developer.apple.com/library/ios/documentation/Cocoa/Reference/Foundation/Classes/NSURLRequest_Class/index.html#//apple_ref/c/econst/NSURLRequestUseProtocolCachePolicy">NSURLRequestUseProtocolCachePolicy</a>.</strong></p>
<p><em><strong>Figure 1</strong> NSURLRequestUseProtocolCachePolicy decision tree for HTTP and HTTPS</em>,</p>
<p><img src="/static/2016/http_caching_2x.png" alt="NSURLRequestUseProtocolCachePolicy decision tree for HTTP and HTTPS">
<em>Copyright © 2016 Apple Inc. All rights reserved. Updated: 2015-10-06</em></p>
<p>Briefly put:</p>
<blockquote>
<ol>
<li>If a cached response does not exist for the request, the URL loading system fetches the data from the originating source.</li>
<li>Otherwise, <strong>if the cached response does not indicate that it must be revalidated every time, and if the cached response is not stale (past its expiration date)</strong>, the URL loading system returns the cached response.</li>
<li><strong>If the cached response is stale or requires revalidation</strong>, the URL loading system makes a HEAD request to the originating source to see if the resource has changed. If so, the URL loading system fetches the data from the originating source. Otherwise, it returns the cached response.</li>
</ol>
</blockquote>
<h2 id="how-to">How-to</h2>
<p>Let&rsquo;s see it in action. Given this sample code,</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">session</span> <span class="p">=</span> <span class="n">NSURLSession</span><span class="p">(</span><span class="n">configuration</span><span class="p">:</span> <span class="n">NSURLSessionConfiguration</span><span class="p">.</span><span class="n">defaultSessionConfiguration</span><span class="p">())</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nv">sessionDataTask</span> <span class="p">=</span> <span class="n">session</span><span class="p">.</span><span class="n">dataTaskWithURL</span><span class="p">((</span><span class="n">NSURL</span><span class="p">(</span><span class="n">string</span><span class="p">:</span> <span class="s">&#34;http://qnoid.com/assets/images/avatar.jpg&#34;</span><span class="p">)</span><span class="o">!</span><span class="p">))</span> <span class="p">{</span> <span class="p">[</span><span class="kr">weak</span> <span class="n">imageView</span> <span class="p">=</span> <span class="kc">self</span><span class="p">.</span><span class="n">imageView</span><span class="p">]</span> <span class="n">data</span><span class="p">,</span> <span class="kc">_</span><span class="p">,</span> <span class="kc">_</span> <span class="k">in</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="k">guard</span> <span class="kd">let</span> <span class="nv">_imageView</span> <span class="p">=</span> <span class="n">imageView</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            
</span></span><span class="line"><span class="cl">            <span class="n">dispatch_async</span><span class="p">(</span><span class="n">dispatch_get_main_queue</span><span class="p">()){</span>
</span></span><span class="line"><span class="cl">                <span class="n">_imageView</span><span class="p">.</span><span class="n">image</span> <span class="p">=</span> <span class="n">UIImage</span><span class="p">(</span><span class="n">data</span><span class="p">:</span> <span class="n">data</span><span class="p">!)</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="n">sessionDataTask</span><span class="p">.</span><span class="n">resume</span><span class="p">()</span></span></span></code></pre></div>
<p><a href="/static/2016/default.mitm">This is the HTTP trace</a> (<a href="http://mitmproxy.org">mitmproxy</a> trace)</p>
<p><img src="/static/2016/default.png" alt="enter image description here"></p>
<p>Notice that this response (i.e. coming from an AWS S3 bucket, &ldquo;Server: AmazonS3&rdquo;) has an <strong>ETag</strong> but only a <strong>Last-Modified</strong> header.</p>
<p>Let&rsquo;s see if NSURLCache has stored both the Etag and the Last-Modified headers.
In Xcode, press SHIFT+CMD+2 to open &ldquo;Devices&rdquo;.</p>
<p>Under &ldquo;Installed Apps&rdquo; select the app, right click, &ldquo;Download Container&hellip;&rdquo;</p>
<p><img src="/static/2016/devices.png" alt="enter image description here"></p>
<p>Open the terminal, navigate to the location of the container. Use <strong><a href="https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man1/grep.1.html">grep</a></strong> to search. Bash will find a string even if it&rsquo;s inside a binary. Et voilà!</p>
<p><img src="/static/2016/cache.png" alt="enter image description here"></p>
<p>With the <strong>NSURLRequestUseProtocolCachePolicy decision tree</strong> and the response headers in mind, let&rsquo;s see how iOS uses this information to decide whether to use a cached response or not.</p>
<p>This response does not &ldquo;require revalidation every time&rdquo; (e.g. a header of &ldquo;Cache-Control: must-revalidate&rdquo; is not present) so iOS will check if &ldquo;response stale&rdquo;. According to the documentation above, iOS considers a respone stale if it&rsquo;s <strong>past its expiration date</strong>. The server however does not specify an explicit expiration time, &ldquo;using either the Expires header, or the max-age directive of the Cache-Control header.&rdquo; (<a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.2.1">13.2.1 Server-Specified Expiration</a>)</p>
<p>When Server-Specified expiration is not available, HTTP states that &ldquo;<strong>In order to decide whether a response</strong> is fresh or <strong>stale</strong>, <strong>we need</strong> to compare <strong>its freshness lifetime</strong> to its age&rdquo;.<br>
<em><a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.2.4">13.2.4 Expiration Calculations, Heuristic Expiration</a></em></p>
<p>However, this is an implementation detail as &ldquo;the cache MAY compute a freshness lifetime using a heuristic&rdquo;. The spec goes on to suggest an algorithm like so.</p>
<blockquote>
<p>Also, if the response does have a Last-Modified time, the heuristic expiration value SHOULD be no more than some fraction of the interval since that time. A typical setting of this fraction might be 10%.</p>
</blockquote>
<p>Turns out the cache used in <a href="https://forums.developer.apple.com/thread/44518">NSURLSession does compute a fresness lifetime</a> (Apple Developer Forums, an account is required), using the algorithm suggested in the spec.</p>
<p>Using the above response as an example, let&rsquo;s calculate the <em>freshness_lifetime</em>.</p>
<pre>
  freshness_lifetime = (date_value - last_modified) * 10% =>
  
  ([Sat, 09 Apr 2016 10:26:51 GMT] - [Sun, 17 Jan 2016 14:15:33 GMT]) * 10% =>
  
  [82 days, 19 hours, 11 minutes and 18 seconds] * 10% =>
  7,153,878 * 10% = 715388 seconds = 8 days 6 hours 43 minutes 8 seconds
</pre>
<p>&ldquo;The calculation to determine if a response has expired is quite simple:&rdquo;</p>
<pre>
  response_is_fresh = (freshness_lifetime > current_age)
</pre>
<p>where current age can be <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.2.3">loosely <em>calculated as</em></a></p>
<pre>
current_age = now - date_value
</pre>
<p>So the response will go <strong>stale in 8 days 6 hours 43 minutes 8 seconds</strong> from the date it was put in the cache.</p>
<p>With all that in mind, let&rsquo;s go through the <em>NSURLRequestUseProtocolCachePolicy decision tree</em> from the beginning.</p>
<ol>
<li>The request is made</li>
<li>&ldquo;Cached response exists&rdquo;?
<ol>
<li>No</li>
<li>&ldquo;Fetch the response&rdquo;</li>
<li>Put it in the cache along with the &ldquo;Date, &ldquo;Last-Modified&rdquo; and &ldquo;Etag&rdquo; headers</li>
</ol>
</li>
</ol>
<p><strong>A day has passed.</strong></p>
<ol>
<li>The request is made</li>
<li>&ldquo;Cached response exists&rdquo;?
<ol>
<li>Yes</li>
<li>&ldquo;Require revalidation every time?&rdquo;
<ol>
<li>No</li>
<li>&ldquo;Response stale&rdquo;?
<ol>
<li>No</li>
<li>&ldquo;Return the cached response&rdquo;</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
</ol>
<p>In case of a non stale (i.e. fresh) response, <strong>no request is made</strong> as the response is returned from the local cache. Don&rsquo;t expect to see a network call. That&rsquo;s good!</p>
<p><strong>8 days 6 hours 43 minutes 9 seconds have passed.</strong></p>
<ol>
<li>The request is made</li>
<li>&ldquo;Cached response exists&rdquo;?
<ol>
<li>Yes</li>
<li>&ldquo;Require revalidation every time?&rdquo;
<ol>
<li>No</li>
<li>&ldquo;Response stale&rdquo;?
<ol>
<li>Yes</li>
<li>&ldquo;Issue a HEAD* request&rdquo;</li>
<li>&ldquo;Changed?&rdquo;
<ol>
<li>No</li>
<li>&ldquo;Return the cached response&rdquo;</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
</ol>
<p>Notice how iOS issues a <strong>GET</strong> rather than a <strong>HEAD</strong> method. <strong>AFAICS, this is to avoid issuing two network requests in order to fetch the resource.</strong></p>
<p><img src="/static/2016/stale.png" alt="enter image description here"></p>
<p>In the case of a <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5">304 Not Modified</a>, <strong>there is no content</strong> as the response will be returned from the local cache.</p>
<p><img src="/static/2016/304.png" alt="enter image description here"></p>
<h2 id="conclusion">Conclusion</h2>
<p><strong>NSURLSession</strong>, <strong>NSURLSessionConfiguration</strong> and <strong>NSURLCache</strong> support caching of entity tag validators (aka <strong>ETag</strong>) and cache invalidation based on how &ldquo;fresh&rdquo; a resource is.</p>
<p>A few notes.</p>
<ul>
<li>
<p><strong>Once a response has been added in the cache</strong>; the longer the time since &ldquo;Last-Modified&rdquo;, the longer it will take to become stale. e.g.</p>
<ul>
<li>&ldquo;Last-Modified&rdquo; in the last 24 hours, stale in ~2.4 hours</li>
<li>&ldquo;Last-Modified&rdquo; in the last 30 days, stale in 3 days.</li>
<li>&ldquo;Last-Modified&rdquo; in the last 180 days, stale in 18 days.</li>
</ul>
</li>
<li>
<p><strong>The later a response is added to the cache</strong>; the longer it will take to become stale.</p>
</li>
<li>
<p><strong>You have no direct control when the cache expires</strong>; strictly speaking with only a &ldquo;Last-Modified&rdquo; header <strong>you have no control over when the cache updates</strong>. e.g. Once a resource has been cached, if the resource is updated on the server, it will only be fetched by iOS only when the cached response becomes stale.</p>
</li>
</ul>
<p>Consider all the above before deciding whether the default configuration supports your needs.</p>
<p><em><a href="https://github.com/qnoid/etag">Source code</a></em></p>
<h2 id="kudos">Kudos</h2>
<p><a href="http://mitmproxy.org">mitmproxy</a></p>
<h2 id="further-reading">Further reading</h2>
<p><a href="http://i.stack.imgur.com/J83Q5.png">13 Caching in HTTP</a>, Hypertext Transfer Protocol &ndash; HTTP/1.1</p>
]]></description>
        <pubDate>Sun, 10 Apr 2016 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Diversity and Inclusion</title>
        <link>https://qnoid.com/2016/03/28/Diversity-and-Inclusion.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2016/03/28/Diversity-and-Inclusion.html</guid>
        <description><![CDATA[<p><em>Approximately 7’39’’ reading time</em></p>
<p>One of the things I have struggled with in the past is this.</p>
<p><strong>How do you know if an individual has a well rounded understanding of an issue when stating their view?</strong></p>
<p>This gets more difficult when your view is different.</p>
<p><strong>How do you know an individual has factored in your view when stating theirs?</strong></p>
<p><strong>How do you know others, hearing that individual’s view, understand that this view might or might not have taken into account yours?</strong></p>
<p>You don’t.</p>
<p>The only way to know is to put you in a room. You, that individual and all the others; so that every one states their view.</p>
<p>At the end,</p>
<ul>
<li>Every individual in that room has a well rounded understanding.</li>
<li>Every individual has now factored in your view.</li>
<li>Every individual knows that every view has been factored in.</li>
</ul>
<p>This is on the basis that everyone is <a href="https://en.wikipedia.org/wiki/Kantian_ethics">acting out of duty</a>.</p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/8rv-4aUbZxQ" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>You might argue that just because everyone has stated their view, it does not mean that they have now factored in yours.</p>
<p>Even more so when an individual still holds the same view. <strong>Seemingly</strong> not factoring in yours.</p>
<h2 id="the-internet">The Internet</h2>
<p>As the internet becomes more social, people are connected more than ever before. <a href="https://www.internet.org">Despite being more connected than ever</a>, the means by which views are communicated fall short overall.</p>
<p><em>Humans have long used writings to communicate.</em></p>
<p><img src="/images/Rosetta_Stone.JPG" alt="Rosetta Stone"><br>
Rosetta Stone <a href="https://commons.wikimedia.org/wiki/File:Rosetta_Stone.JPG"><em>© Hans Hillewaert, via Wikimedia Commons</em></a></p>
<p><em>And images.</em></p>
<p><img src="/images/SantaCruz-CuevaManos-P2210651b.jpg" alt="Cueva Manos"><br>
Cueva Manos <a href="https://commons.wikimedia.org/wiki/File:SantaCruz-CuevaManos-P2210651b.jpg"><em>By Mariano (Own work), via Wikimedia Commons</em></a></p>
<p><a href="https://en.wikipedia.org/wiki/Exploration">Exploration</a> and <a href="https://en.wikipedia.org/wiki/Trade">trade</a> over the centuries exposed people to a plethora of customs, traditions, sciences and knowledge.</p>
<p><a href="https://en.wikipedia.org/wiki/21st_century">Even today</a>, travelling to a foreign country is not enough to give you a good understanding of its society. You need to spend years before you can fully grasp, appreciate and aknowledge its contributions and shortcomings to this world.</p>
<p>The internet has evolved at an extreme pace but at the same time is <a href="https://en.wikipedia.org/wiki/Internet_censorship_in_China">failing to bind us together</a>. Breaking down physical barriers, faster than legislation can adjust and the means of communication can mature.</p>
<p>No matter how primitive in nature, <a href="https://en.wikipedia.org/wiki/Greeting">greetings</a>, gestures, facial expressions, body language and the tone of our voice have helped us come together as species.</p>
<p><a href="https://en.wikipedia.org/wiki/Origin_of_language"><em>Origin of language</em></a></p>
<p><img src="/images/12719113_10102665120179591_3471165635858509622_o.jpg" alt="Virtual Reality">
<em>“I just joined Samsung to launch their new Galaxy smartphones and talk about the future of virtual reality.</em>“ - <a href="https://www.facebook.com/zuck/posts/10102665126861201">Mark Zuckerberg</a></p>
<ul>
<li><a href="http://www.theverge.com/2016/3/28/11284590/oculus-rift-vr-review"><em>Virtual Reality is around the corner</em></a></li>
</ul>
<p><a href="https://en.wikipedia.org/wiki/Social_media">Social media</a> has an every increasing role and a responsibility to boot in bringing people together.</p>
<p>As an example, <a href="https://twitter.com">Twitter</a> fails to facilitate a round table discussion and is prone to the <a href="https://en.wikipedia.org/wiki/Echo_chamber_%28media%29">Echo chamber</a> effect.</p>
<p>An individual’s high number of followers amplifies their influence at an exponential rate. This is a powerful way to spread your view or publicly shame, but can easily lead to peer pressure, used as means of coercion and bullying.</p>
<p><strong>You should think twice before using a retweet like a whistle to get the attention of the angry mob</strong>, opting for <a href="https://en.wikipedia.org/wiki/Ochlocracy">Ochlocracy</a> in the process.</p>
<iframe src="https://embed-ssl.ted.com/talks/jon_ronson_what_happens_when_online_shaming_spirals_out_of_control.html" width="640" height="360" frameborder="0" scrolling="no" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>
<ul>
<li><a href="https://blog.twitter.com/2015/fighting-abuse-to-protect-freedom-of-expression-au"><em>Fighting abuse to protect freedom of expression - The Official Twitter Blog</em></a></li>
<li><a href="https://blog.twitter.com/2016/announcing-the-twitter-trust-safety-council"><em>Announcing the Twitter Trust &amp; Safety Council - The Official Twitter Blog</em></a></li>
</ul>
<p>The Internet is still in its infant stage. You need to be respectful, demonstrate empathy, be mindful of cultural differences, communication bariers, mental and emotional state else <strong>you risk ousting people</strong>.</p>
<h2 id="the-importance-of-diversity-and-inclusion">The importance of diversity and inclusion</h2>
<blockquote>
<p>Sounds contradictory that access to vast information leads to biased people with less reasoning. Critical thinking goes out of the window.</p>
</blockquote>
<p>When you support a cause or you are personally affected, your views can easily turn to beliefs. Beliefs that you fight hard for and feel strongly about.</p>
<p><a href="https://en.wikipedia.org/wiki/Belief">Beliefs are not inheritely bad</a>. Beliefs give a sense of purpose, influence, provide stability to enable progress. Don’t challenge your beliefs for too long though and you risk stagnation.</p>
<p>By merely believing that a view holds true, a view is right, without allowing for a debate, you risk more than “being wrong”.</p>
<blockquote>
<p>Look for and embrace your polar opposites in life. Those who will challenge your thinking, critical of your work. Will only make you better.</p>
</blockquote>
<p>You risk applying it on a case where it does not hold. Potentially failing to support that cause you believe so strongly about.</p>
<p>You risk creating prejudice by enforcing your beliefs on another individual.</p>
<p>You risk making an individual’s view biased or worse, driven by fear.</p>
<p>You risk not being exposed to the diversity of views that can shape your understanding.</p>
<p>A view of an individual comes from their experiences. Experiences that are shaped by life and also interpreted differently. Views that vary based on <a href="https://en.wikipedia.org/wiki/Culture">culture</a>, <a href="https://en.wikipedia.org/wiki/Race_(human_categorization)">race</a>, <a href="https://en.wikipedia.org/wiki/Social_status">social status</a> and individuality.</p>
<blockquote>
<p>Culture shock much? Some Syrian newcomers are staying at a hotel where the <a href="https://twitter.com/hashtag/VancouFur?src=hash">#VancouFur</a> furry convention is going on. <a href="https://t.co/rPi6HN72Lz">pic.twitter.com/rPi6HN72Lz</a> — Ziya Tong (@ziyatong) <a href="https://twitter.com/ziyatong/status/707264910997233665">March 8, 2016</a></p>
</blockquote>
<p><strong>The world is shaped today from all these views coming together, being challenged, influenced, co-existing</strong>.</p>
<p>To deny those views is to deny our freedom.</p>
<h2 id="it-is-a-collective-effort-that-lies-with-you">It is a collective effort that lies with you</h2>
<blockquote>
<p>While making sure we don’t kill each other in the process or become extinct. A long time of being civilised while in need to be primitive.</p>
</blockquote>
<p>Going back to my original question.</p>
<p><strong>How do you know if</strong> an individual has a well rounded understanding of an issue when stating their view?</p>
<p>I now think of it like this.</p>
<p><strong>How do you ensure</strong> an individual has a well rounded understanding of an issue when stating their view?</p>
<p>As an individual you have a responsibility to be mindful and careful when you communicate your view. Avoid being dogmatic, polarising.</p>
<p>Given that your goal is to educate then do so by having a discussion and explain to an individual your view. This isn’t about being politically correct or restraining. This is about being mindful of differences and aware of context.</p>
<p>Rather than assuming or letting your bias kick in, establish a context first by asking the “right” questions. Listen. Process. This will give you both a better understanding and increased chances to make a change.</p>
<p>Spread views that have the above qualities.<br>
Look for views that have the above qualities.</p>
<blockquote>
<p>Even though information is more accessible than ever, getting an overall understanding to form an opinion on matters is hard.</p>
</blockquote>
<p>Protect views that are being oppressed. Speak up and defend every individual’s right to their view. A world where having a different view is <a href="https://en.wikipedia.org/wiki/Heresy">heresy</a> is no different that <a href="https://en.wikipedia.org/wiki/Totalitarianism">a world with a single view</a>.</p>
<p>Consider how the media can shape a view and people with a social status can influence.</p>
<p>Consider how companies operate, politicians debate and countries legislate.</p>
<p>Consider the current issues that the world is facing today.</p>
<p>Challenge.</p>
<p>Even this article, now that you have finished reading it. Understand <em>how</em> it applies, <em>what</em> is not tackling, <em>why</em> and <em>where</em> it falls short by omission. Share your view.</p>
<p><strong>We have evolved because of diversity</strong>.<br>
<strong>We have come this far by being inclusive</strong>.</p>
]]></description>
        <pubDate>Mon, 28 Mar 2016 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>We need to raise the bar on software development</title>
        <link>https://qnoid.com/2016/01/14/We-need-to-raise-the-bar-on-software-development.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2016/01/14/We-need-to-raise-the-bar-on-software-development.html</guid>
        <description><![CDATA[<p><strong>3 Sep 2016:</strong>
<em>Have reworded some of the questions after noticing I had to followup with an explanation. Have also added 15 more that IMO an experienced iOS developer should know.</em></p>
<blockquote>
<p>Been heavily involved in the hiring process, evaluating CVs, asking technical questions, creating coding exercises, interviewed developers.</p>
</blockquote>
<p>In the past, I used to teach object oriented programming in Java. Mainly to University students who were struggling in class and wanted some outside help. What I found as the main reason people were failing was they didn’t have a solid understanding of the basic principles of software engineering.</p>
<p>In the last 2 permanent job roles, <a href="https://careers.stackoverflow.com/qnoid">in my long career</a>, I have been heavily involved in the hiring process. Writing job descriptions, evaluating CVs, screening candidates by asking technical questions, going through coding exercises, interviewing developers for both cultural and technical fit.</p>
<p>You know something isn’t right when out of tens of CVs, only a handful pass the screening phase and a low single digit get an offer. It’s a funnel, a heartbreaking one.</p>
<p>The screening phase is really just a list of straight forward technical questions that you would expect everyone applying for the role to know. Contractors with £500 day rates, people looking for a permanent role, “juniors”.</p>
<p>For iOS, there are questions like this one:</p>
<blockquote>
<p><strong>Q: What does ARC stand for, how does it work and what are the benefits of using it</strong>?<br>
A: Automatic Reference Counting. It works by inserting “retain” and “release” calls to objects, at compile time, where required with the benefit of “knowing” things like scope and usage. Effectively, it provides memory management for the trivial cases.</p>
</blockquote>
<p>and another one:</p>
<blockquote>
<p><strong>Q: What is a retain cycle? How would you avoid it</strong>? <br>
A: A retain cycle occurs when two instances have a “strong” reference to each other. You can avoid it by declaring one as “weak”.</p>
</blockquote>
<p>To be clear. These questions are meant to be answered briefly, be complete and precise enough to demonstrate basic understanding. They are not in depth, not tricky, not to have a debate and definitely don’t prove much on senior status. Listening to how an answer is formulated says a lot about a canidate’s understanding, knowledge and confidence.</p>
<p>By asking questions on the fundamentals, it is easy to tell when people have a fixed, narrow understanding of these. A typical answer that keeps coming up when asking “<strong>Where would you use a protocol</strong>?” is “In a table view.”. (thinking of its datasource)</p>
<p>We all have our own share of responsibility for this.</p>
<p><strong>As a manager</strong>, for asking your development team “to go faster” and “get things done”. Measure how long software delivery takes. Identify where and why you are wasting time; restructure. Give your developers room to breath, support them to grow professionally. You need to let them take their time to read that chapter in the book, to watch that conference talk, to practice what they know. Factor that in  the time it takes to deliver software.</p>
<p><strong>As a digital agency</strong>, for not educating your customer on technical debt, not managing expectations, risk and priorities. At least deliver quality software. Don’t just please the customer for the paycheque.</p>
<p><strong>As an experienced developer</strong>, for not providing estimates, speaking up on technical debt, raising awareness on how to deliver quality software. You need to let your manager know how long implementing that requirement will take to get it done. That includes testing; and documentation; and every other business requirement. i.e. localisation, accessibility support. If you don’t have the faintest idea, <strong>ask for time</strong> to do your research.</p>
<p><strong>As a teacher/mentor/knowledge bearer</strong>, for showing lack of responsibility, being careless, skipping over the details, not dedicating time to address questions. Explain the “why” and show the “how”. Spend the time and effort to properly explain. Develop people’s critical thinking. <strong>Teach them</strong> how to think for themselves.</p>
<p><strong>Finally you</strong>, the developer, study, practice, challenge, repeat.  Read books, attend courses. Get structured, formal education.  Watch a talk on the subject. Preferably from the source. For iOS, that’s <a href="https://developer.apple.com/videos/">WWDC</a>. Use <a href="http://asciiwwdc.com">ASCIIwwdc</a> to search.</p>
<p>Read blogs, watch talks and keep an eye for references, bibliography, solid arguments.
<a href="https://www.mikeash.com/pyblog/">Mike Ash</a>, <a href="https://vimeo.com/nsconf">nsconf</a>, <a href="https://vimeo.com/album/3132071">NSScotland</a>, <a href="http://nsspain.com/2015/">NSSpain</a>, <a href="http://iosdevweek.ly">iosdevweekly</a></p>
<p>Follow subject experts on Twitter.
Ask your team to code review.</p>
<p>Be critical! challenge! ask questions, compare and contract your own understanding.</p>
<blockquote>
<p>A final year student from <a href="https://twitter.com/univofstandrews">@univofstandrews</a> impressed me the most with his iOS skills at <a href="https://twitter.com/milkroundabout">@milkroundabout</a>. Be curious, read up and write code!</p>
</blockquote>
<p>In my opinion, here are 25 questions you need to know.</p>
<ol>
<li>What does ARC stand for, how does it work and what are the benefits of using it?</li>
<li>What is a retain cycle? How would you avoid it?</li>
<li>What is a weak and what is a strong reference?</li>
<li>What would you use an enum for?</li>
<li>What is a protocol useful for?</li>
<li>What is a protocol extension useful for?</li>
<li>What is the delegate pattern? Give an example.</li>
<li>What is a block?</li>
<li>How can blocks create a retain cycle? How do you avoid it?</li>
<li>What would you use a NSNotification for?</li>
<li>What are the basic navigation concepts in iOS? Can you describe where you would use each?</li>
<li>What is a UIViewController responsible for? How would you typically implement one?</li>
<li>What is an IBOutlet and an IBAction?</li>
<li>Why is a UITableView good at displaying a long list of items?</li>
<li>What is auto-layout? Where does it help?</li>
<li>What is a storyboard? What is a xib? Where would you use each?</li>
<li>Under what scenario would you choose a xib over code or vice versa?</li>
<li>What is a file&rsquo;s owner?</li>
<li>What is a unit test?</li>
<li>What is a precondition, a postcondition, an assertion?</li>
<li>What are the four most common HTTP verbs related to a RESTful web service?</li>
<li>Give a brief description of what a RESTful webservice is.</li>
<li>What is JSON?</li>
<li>How do you know that a <strong>network request</strong> was successful?</li>
<li>What is a network timeout?</li>
</ol>
<p><strong>Advanced</strong></p>
<ol>
<li>What do you have to be mindful of when testing an asynchronous network call?</li>
<li>What is the risk in blocking the main thread when performing a lengthy operation such as network access or a heavy computation?</li>
<li>What is the difference between a NSOperationQueue and a dispatch_queue? Describe a scenario where you would use each.</li>
<li>What is the difference between dispatch_async and dispatch_sync? Describe a scenario where you would use each.</li>
<li>What are dispatch_group(s) useful for? Describe a scenario where you would use them.</li>
<li>What is a ”Zombie object&quot;? How would you use it?</li>
<li>What is a memory leak?</li>
<li>What is unbounded memory growth?</li>
<li>What is an autorelease pool? Describe a scenario where you would use one.</li>
<li>Given that an app uses a lot of memory, give some general advice on how to bring overall usage down.</li>
<li>What are the risks associated with high memory usage?</li>
<li>What is a memory warning? How would you typically handle it?</li>
<li>How would you deal with a sudden spike in memory usage?</li>
<li>What are the risks of a high CPU usage?</li>
<li>How would you deal with bursts in CPU usage?</li>
</ol>
<p><strong>Related talks</strong></p>
<ul>
<li><a href="https://vimeo.com/97058344">Not Invented Here</a> - <a href="https://twitter.com/mzarra">Marcus Zarra</a></li>
<li><a href="https://vimeo.com/92158446">How to get hired by Black Pixel</a> - <a href="https://twitter.com/mattfarrugia">Matt Farrugia</a></li>
</ul>
]]></description>
        <pubDate>Thu, 14 Jan 2016 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>To be celebrated as a human</title>
        <link>https://qnoid.com/2015/12/09/To-be-celebrated-as-a-human.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2015/12/09/To-be-celebrated-as-a-human.html</guid>
        <description><![CDATA[<blockquote>
<p>Grandma’s death made me realise that you don’t have to achieve perfection in order to be celebrated as a human; what a weight to have lifted.</p>
</blockquote>
<p>Grandma<sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> was stubborn.</p>
<p>Born in the thirties of the 20th century, she was married and had 3 children. She looked after her parents as they grew older, raised her niece and her firstborn grandson. A spouse till her mid fifties when her husband abandoned her.</p>
<p>At that age she got a job at <a href="https://en.wikipedia.org/wiki/Tupperware">Tupperware</a> to make ends meet.</p>
<p>Through her work she got to travel to London, attend events at the Hilton Athens Hotel (a lot of the time with her grandson by her side to look after) was appointed team leader and given a corporate car.</p>
<p><strong>She started her life in her fifties</strong> and at the age of 81, at her funeral, every single person was standing up and her colleagues donated money to charity on her name.</p>
<p>People again and again praised her great mind, reached out to her for advice and admired how she could hold a conversation about any subject.</p>
<p>I do wonder and hope to achieve, if only at the slightest, the greatness of this woman.</p>
<p>Who I am today, I owe a great deal to her.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>The last child, youngest daughter of a family coming from <a href="https://en.wikipedia.org/wiki/Trabzon">Trabzon</a> and <a href="https://en.wikipedia.org/wiki/%C3%87e%C5%9Fme">Çeşme</a> and moved to <a href="https://en.wikipedia.org/wiki/Corinth">Corinth</a>.&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Wed, 09 Dec 2015 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The price of freedom</title>
        <link>https://qnoid.com/2015/02/25/The-price-of-freedom.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2015/02/25/The-price-of-freedom.html</guid>
        <description><![CDATA[<p><a href="http://en.wikipedia.org/wiki/John_Locke">John Locke</a> in his work on political philosophy, defines the “the state of nature”; as in “the state that all people are in naturally”:</p>
<blockquote>
<p>“People in this state do not have to ask permission to act or depend on the will of others to arrange matters on their behalf.” - <a href="http://en.wikipedia.org/wiki/State_of_nature#John_Locke">State of nature, Second Treatise: John Lock, 1689</a></p>
</blockquote>
<p>However, the second you are born, you give a tacit consent to live in a society and enter into a <a href="http://en.wikipedia.org/wiki/Social_contract">“Social contract”</a>; emphasis mine.</p>
<blockquote>
<p>Social contract arguments typically posit that individuals have consented, either explicitly or tacitly, <strong>to surrender some of their freedoms</strong> and submit to the authority of the ruler or magistrate (or to the decision of a majority), <strong>in exchange for protection of their remaining rights</strong>.</p>
</blockquote>
<p>With that contract you effectively trade that freedom in exchange to feel safe.</p>
<p>As you come into this world, your family is there to nurture you. You are fed, learn to walk, taught how to speak and in exchange you ask for permission whenever you wish to take matters in your own hands. You are slowly being conditioned on your way to integrate with society. If you happen to be lucky in the “<a href="https://www.youtube.com/watch?v=uZTweMHEFAI">ovarian lottery</a>” - you will be granted access to food, water and given basic human rights such as the right to education.</p>
<p>As you leave the safety of your family and begin to integrate with society, you have to contribute your worth to the common welfare. It is that duty that imposes a <a href="http://en.wikipedia.org/wiki/Civic_virtue">civic virtue</a> in order to claim your right to society; emphasis mine.</p>
<blockquote>
<p>Civic virtue is the cultivation of habits and personal living that are claimed to be important for the success of community. Civic virtue is also <strong>the dedication</strong> of citizens to the common welfare of their community even <strong>at the cost of</strong> their <strong>individual interests</strong>.</p>
</blockquote>
<p>It is the price of admission. The price you pay to feel safe in the community else risk <a href="http://en.wikipedia.org/wiki/Ostracism">ostracism</a>.</p>
<p>Living in a <a href="http://en.wikipedia.org/wiki/Civil_society">civil society</a>, means you now greatly depend on the will of others before you take action.
While that holds true for everyone, it greatly depends on your <a href="http://en.wikipedia.org/wiki/Social_status">social status</a>.</p>
<p>Since by civic virtue you are dedicated to the common welfare of society and you earn your social status based on your contribution then how much individual freedom do you really have left to pursue your individual interests?</p>
<p>A greedy society, a society that has an appetite solely driven by its desire to maximise its welfare, puts at risk that very social contract that asks people to enter into.</p>
<blockquote>
<p>“…no one knows his place in society, his class position or social status, nor does anyone know his fortune in the distribution of natural assets and abilities, his intelligence, strength, and the like.” - <a href="http://en.wikipedia.org/wiki/A_Theory_of_Justice">A theory of Justice: John Bordley Rawls, 1971</a></p>
</blockquote>
<p>I am lucky to be born in Europe.
I am fortunate not to be poor.
I am privileged to have received higher education.
I am favoured to be working in IT.</p>
<p>Yet, it took me 35 years to be able to buy 9 months of &ldquo;some&rdquo; freedom to &ldquo;not have to ask permission to act or depend on the will of others to arrange matters&rdquo;.</p>
<p>It has been hard to get here and as I look forward, being part of a greedy society that always asks for something in return is not a society that is worth having.</p>
<p>I don’t want to live in a society that recklessly sacrifices individual freedom, where as an individual you don&rsquo;t really matter unless you always have something to offer, a society that constantly asks for something in return, that treats every human interaction as a transaction, that instills fear of losing social status. I want to live in a society that puts its faith in people and supports them to do their best. A society that contributes in the making of great people so that in itself can achieve greatness.</p>
]]></description>
        <pubDate>Wed, 25 Feb 2015 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Bitwink</title>
        <link>https://qnoid.com/2014/08/28/Bitwink.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2014/08/28/Bitwink.html</guid>
        <description><![CDATA[<p>For the last 7 months had the chance of working alongside members of the <a href="http://bitwink.com">Bitwink</a> team. Bitwink does iOS development and is available for hire in Edinburgh, Scotland.</p>
<p>Out of the whole team, it was <a href="https://twitter.com/gordonchristie">@gordonchristie</a>, <a href="https://twitter.com/adurdin">@adurdin</a> and <a href="https://twitter.com/mattfarrugia">@mattfarrugia</a> that spend the time with. In case you haven&rsquo;t heard of them before, Gordon Christie is &ldquo;that guy&rdquo; that built the hugely popular <a href="https://itunes.apple.com/gb/app/edinbus-lothian-buses-times/id324503614?mt=8">Edinbus</a>. Andy Durdin every now and then writes about <a href="http://backslashn.com">the quirks in games</a> and is the man behind <a href="https://twitter.com/GameDevEd">@GameDevEd</a>. Matt Farrugia gave an awesome talk at <a href="http://nsscotland.com">NSScotland</a> in 2013 on <a href="http://2013.nsscotland.com/speakers.html">“How to get hired by Black Pixel”</a> and is the Bitwink owner. You&rsquo;ll find them hanging around <a href="http://macmacdev.com">macmacdev</a> every 2nd Thursday of the month.</p>
<p>Now, all too often you&rsquo;ll read on people&rsquo;s CVs and companies&rsquo; portfolios how they can deliver software on time, on budget and to the complete satisfaction of everyone involved, so let&rsquo;s get this out of the way first.</p>
<p>Building quality software is HARD!</p>
<p>You have to manage milestones, risk and priorities. You have to give estimates on how long things will take and revise them. You have to understand what you are building, step in, take responsibility, let prejudices aside and trust your team. You have to communicate effectively, within your team, across teams, suppliers and stakeholders. You have to keep an eye on code quality, review, make compromises. You have to take quite a beating and still deliver.</p>
<p>You need good men.</p>
<p>Gordon is thoughtful, brings sense where there is madness and he is the voice of reason. He is methodical, his every move is a well calculated one.</p>
<p>Andy is one hell of a software engineer. He is relentless and will deal with whatever software problem you throw his way. He always finds a way to get things done.</p>
<p>Matt brings it all together. He knows his people very well. How they think, what makes them tick, what’s required for them to perform at their best. He is diligent, measured, focused. He knows how to deliver software. He is a leader.</p>
<p>These guys are no ninjas or rockstars; the are smart and know how to do their job. They are Professionals.</p>
<p>Gordon, Andy, Matt, I have learned so much working alongside you and have come out a better man and a better developer. It was an honour and a privilege to work with you and I am grateful. Thank you.</p>
]]></description>
        <pubDate>Thu, 28 Aug 2014 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Why arent we password free yet?</title>
        <link>https://qnoid.com/2014/02/22/Why-arent-we-password-free-yet.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2014/02/22/Why-arent-we-password-free-yet.html</guid>
        <description><![CDATA[<blockquote>
<p>By using a password, you actually give up security control and risk your users' data. Stop asking for one now.</p>
</blockquote>
<p>Turns out if you buy a new iPhone, you are required to answer your security questions before making any purchases on the App Store with your Apple ID (Sunday, 22 December 2013 10:52). The password that you have already set up is not enough to verify your identity in this scenario.</p>
<p><img src="/static/2014/02/06/verification-required.png" alt="Verification Required"></p>
<h2 id="security-questions">Security Questions</h2>
<blockquote>
<p>Security Confirmation<br>
Because this is the first time making a purchase on this device, you must verify your identity by answering the following questions before you can complete your purchase. If you have forgotten your answers, contact Customer Support</p>
</blockquote>
<p>Not sure why Apple believes a password might have been compromised with the new device. Usually security questions are used as means to reset a password in case you have forgotten it. It&rsquo;s an alternative way to identify who you are. Unfortunately not as convenient as the password.</p>
<p>Security questions are usually more than one (personally have seen up to 8!) and the user rarely gets to choose what they are. Since their purpose is to identify the user, they are naturally &ldquo;trying&rdquo; to touch on personal, private data (i.e. favourite actor, personal hero, childhood nickname). Effectively the user is coerced into answering them, all too often choosing arbitrary answers via association or totally random characters. Because they are created at the same time the account is set up and rarely used the chances of forgetting them increases with every day passing by. In this case that was about 2 years ago.</p>
<p>So what if you do not answer?</p>
<blockquote>
<p>You did not provide the correct answer to one or both of your security questions. If you continue to provide incorrect answers, your Apple ID will be locked and you will be unable to make any purchases while it remains locked.</p>
</blockquote>
<p><img src="/static/2014/02/06/security-questions.png" alt="Security Questions"></p>
<p>Notice the</p>
<blockquote>
<p>If you have forgotten your answers, contact Customer Support.</p>
</blockquote>
<p>If you fail to recall your security questions, then a combination of things like your date of birth, address, and 4 last digits of your credit card as entered in your profile <a href="https://medium.com/cyber-security/24eb09e026dd">is enough to prove who you are</a>.</p>
<p><em>By the way, the account to this date has not been used to make a purchase on the App Store.</em></p>
<h2 id="have-you-forgotten-your-password">Have you forgotten your password?</h2>
<p>Another way of identifying a user is via an email. The idea being that the user who set an email for her account, has secure and sole access to her email.</p>
<p>Let&rsquo;s see how that looks. An anonymous user requests to identify via email in order to access her account. That is a single prompt for her email address.</p>
<p><img src="/static/2014/02/06/forget-your-password.png" alt="Forgotten Password"></p>
<p>The assumption is that the user owns the email of her account, hence plausible to identify her.</p>
<p>The user enters her email,</p>
<p><img src="/static/2014/02/06/emailed-link.png" alt="Email link"></p>
<p>the email contains a link that the user needs to follow to identify herself,</p>
<p><img src="/static/2014/02/06/verify-email.png" alt="Verify email"></p>
<p>since the user has identified, can also create a new password to secure her account,</p>
<p><img src="/static/2014/02/06/create-new-password.png" alt="Create new password"></p>
<p>and access it.</p>
<p><img src="/static/2014/02/06/logged-in.png" alt="Logged In"></p>
<p><strong>Take a look at your stats and see how many of your users are using the forgotten password link or the percentage of users calling in due to having forgotten their password.</strong></p>
<h2 id="the-leak">The leak</h2>
<p>The truth is, no matter how secure a password can be, your users are most likely reusing them. As a result, <strong>security is no longer under your control.</strong></p>
<p>Back in October 2013, <a href="http://blogs.adobe.com/conversations/2013/10/important-customer-security-announcement.html">Adobe&rsquo;s customers IDs and encrypted passwords were compromised</a>. Less than 2 months later, <a href="https://github.com/blog/1698-weak-passwords-brute-forced">Adobe&rsquo;s database of passwords was used to hack Github</a>. Essentially, <a href="http://security.stackexchange.com/questions/45834/how-were-weak-passwords-brute-forced-in-github">Adobe&rsquo;s leak compromised Github.</a> Oh, let&rsquo;s not forget <a href="http://plaintextoffenders.com">plain text offenders</a>.</p>
<h2 id="enter-password-policies">Enter password policies</h2>
<p>Password policies are a best effort to keep passwords secure and as a side effect protect against compromises like Adobe&rsquo;s. However, a password policy can&rsquo;t guarantee that the password will be unique to your service and passwords that use common character substitution are equally vulnerable. Also, enforcing a strong policy can potentially harm user acquisition and will likely increase the chances of a user forgetting her password.</p>
<h2 id="you-dont-need-a-password">You don&rsquo;t need a password</h2>
<p>Let&rsquo;s look back to the &ldquo;forgotten password&rdquo; cycle.</p>
<ol>
<li>An anonymous user wants to access her account.</li>
<li>User asks to identify via email (forgotten password).</li>
<li>User enters her email.</li>
<li>User receives a verification link.</li>
<li>User authenticates by following that verification link.</li>
<li><em>User creates password.</em></li>
<li>User is logged in.</li>
</ol>
<p>Since most services now use long lived sessions, the user will rarely have to enter her password again. Yet just by using a password your service is vulnerable to attacks like Github&rsquo;s.</p>
<h2 id="lets-think-of-better-ways-to-identify-a-user-instead">Let&rsquo;s think of better ways to identify a user instead</h2>
<p>Email isn&rsquo;t designed for user identification. <a href="http://www.slicklogin.com">Google just recently bought SlickLogin</a>. SlickLogin uses a distinct sound to identify a user. Apple already <a href="http://en.wikipedia.org/wiki/Touch_ID">uses a fingerprint to identify a user</a> on an iPhone 5S.</p>
<p>On mobile, you can use <a href="https://github.com/verylargebox/VLBUserIdentity">residence based authentication</a>.</p>
<p>Every second you keep a password database around, you are putting your data and others&rsquo; at risk. <strong>Stop asking your users to create a password.</strong></p>
<p>Focus your efforts on how to best identify a user.</p>
<p><strong>Update:</strong> <a href="http://www.lukew.com/ff/entry.asp?1487">Some metrics provided by Luke Wroblewski on passwords</a> back in January 2012 and <a href="http://www.lukew.com/ff/entry.asp?1590">statistics on top three passwords.</a> Some highlights:</p>
<ul>
<li>86% of U.S. companies use password authentication.</li>
<li>70% of people do not use a unique password for each Web site.</li>
<li>Around 82% of people have forgotten a password used on a Web site.</li>
<li>Password recovery is the number one request to help desks for intranets that don’t have single sign-on portal capabilities.
2/3 of people with leaked accounts at both Sony and Gawker reused their passwords on both sites.</li>
</ul>
]]></description>
        <pubDate>Sat, 22 Feb 2014 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>We need to talk about fizzbuzz</title>
        <link>https://qnoid.com/2013/12/20/We-need-to-talk-about-fizzbuzz.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/12/20/We-need-to-talk-about-fizzbuzz.html</guid>
        <description><![CDATA[<p>Originally wrote <a href="https://qnoid.com/2011/02/23/Why-cant-programmers-design-software.html#main">&ldquo;Why Can&rsquo;t Programmers.. Design Software?&rdquo;</a> on forrst. It spur a discussion that made some people think about software design; <a href="https://qnoid.com/2011/02/20/software-design.html#main">that was the goal</a>.</p>
<blockquote>
<p>Wow. Well, that is certainly the most enterprisey Java approach to the problem I&rsquo;ve ever seen. It seems a bit excessive. Aiming for abstraction at the cost of readability.</p>
</blockquote>
<blockquote>
<p>Overengineering is how I&rsquo;d call this. Though the specific use-case is an obvious abuse, the general idea behind isn&rsquo;t that bad&hellip;</p>
</blockquote>
<blockquote>
<p>I think that this is a fantastic approach. Could someone call this excessive or overengineering? Of course, in the context of FizzBuzz. However, not in the context of software design in general. Far to often we (and I&rsquo;m more than guilty of this) jam tons of lines of procedural code inside of our classes without thinking of reuse or any sort of abstraction. The point of this post (as far as I can tell, correct me if I&rsquo;m wrong, @qnoid) is to actually think about what you&rsquo;re doing, not just blindly build a solution as fast and in as few lines as possible.</p>
</blockquote>
<p>Lately have been noticing a lot of traffic coming from <a href="http://www.somethingawful.com/">@Something_Awful</a>. Felt like writing a follow up because as time goes by, even more developers will come across the post and totally miss the point.</p>
<ul>
<li>Q: Should you write an implementation of fizzbuzz in this way?</li>
<li>A: No.</li>
<li>Q: Should you shoehorn OO arbitrarily to a software design?</li>
<li>A: No.</li>
</ul>
<p>Personally, like to <a href="https://qnoid.com/2011/06/08/Metrics-of-an-object-oriented-world.html#main">draw the design early</a>. It helps guide developers and show intent.<br>
Is there a risk of over engineering? Absolutely. Even though <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">grammar does help with OO</a> there are concepts that give little room for doubt when it comes to <a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main">designing software in OO</a> (i.e. object lifecycles). At the end of the day it comes down to experience.</p>
<p>Here is another <a href="https://gist.github.com/grantslatton/7187941">fizzbuzz</a> implementation that really adds something new to the table.<br>
Not a clue what &ldquo;<a href="http://en.wikipedia.org/wiki/Deterministic_finite_automaton">deterministic finite automata</a>&rdquo; is, but it sounds cool.</p>
]]></description>
        <pubDate>Fri, 20 Dec 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>On sacrifices</title>
        <link>https://qnoid.com/2013/08/11/On-sacrifices.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/08/11/On-sacrifices.html</guid>
        <description><![CDATA[<p><a href="https://qnoid.com/software-engineer/#verylargebox">verylargebox</a> took almost 3 years before its public release on the 20th of July 2013.
978* days to be exact.</p>
<blockquote>
<p>Picture a box — verylargebox (@verylargebox) <a href="https://twitter.com/verylargebox/statuses/5198013530112000">November 18, 2010</a></p>
</blockquote>
<p>The actual time was around 6 months based on a 40h/week schedule. This is taking an idea existing solely in a couple of spoken words all the way to an app tangible by anyone. Once the release date had been set the last month turned really challenging. Ensure everything falls into place, communicate with both a designer to <a href="https://twitter.com/verylargebox/status/366577038615801856">visually enrich the app</a> and a video production company for the video promo, &ldquo;recruit&rdquo; testers to drive the app before submitting.</p>
<video controls preload="auto" width="480" height="207">
 <source src="/static/2013/08/11/verylargebox.mp4" type="video/mp4" />
 </video>
<p>You might be wondering what about the 30 months of overhead? Well, that&rsquo;s having a 9-5, suffering from 3 burnouts of 3-6-6 months, taking care of loved ones, dealing with personal matters, trying to have a social life.</p>
<p>Making something from scratch is tough; both mentally and physically. You skip the gym, you stop eating healthy, you pull all nighters, you start ignoring friends, you loose touch with the outside world, you effectively sit on a chair and ignore everything coming your way. You have to make personal sacrifices along the way as you must put the hours; there is no way around it.</p>
<p>The truth is that verylargebox would have possibly taken even more time to build if it wasn&rsquo;t for the myriad QA on StackOverflow, the dozens of blog posts and tutorials available and the open source community.</p>
<p>Yet, it&rsquo;s not only about writing software. It&rsquo;s about achieving your dreams and aspirations, saving that extra weekend to be with loved ones, taking care of yourself, moving the whole industry forward one step at a time.</p>
<p>It is for those reasons that <a href="https://github.com/verylargebox">have open sourced 3 libraries</a> (<a href="https://github.com/verylargebox/VLBCameraView">VLBCameraView</a>, <a href="https://github.com/verylargebox/VLBScrollView">VLBScrollView</a>, <a href="https://github.com/verylargebox/VLBAlertViews">VLBAlertViews</a>) and have already described <a href="https://github.com/qnoid/TBUserIdentity">residence based authentication</a> that the box is made of.</p>
<p>verylargebox would probably have failed had it not be for all the support from friends. An encouraging talk, that snippet of code, the long conversation after midnight, putting you back on track, doing the chores for you, pushing you to do better. Even questioning the very thing that you do, forcing you to put things into perspective and keep the faith.</p>
<p>Thank you <strong>Maria</strong>, <strong>Leonida</strong>, <strong>Sam C</strong>, <strong>Keith</strong>, <strong>Andrew</strong>, <strong>Guy</strong>, <strong>Mike</strong>, <strong>Yaniv</strong>, <strong>Sam E</strong>, <strong>Stephanie</strong>, <strong>Bryan</strong>, <strong>George P</strong>, <strong>Aristoteli</strong>, <strong>Mark R</strong>, <strong>Ali</strong>, <strong>Colin</strong>, <strong>Philip</strong>, <strong>Jon</strong>, <strong>Matt</strong>, <strong>Max</strong>, <strong>Michali</strong>, <strong>Niko S</strong>, <strong>Pari</strong>, <strong>Pano</strong>, <strong>Taso</strong>, <strong>Jamie</strong>, <strong>Brian</strong>. Without you verylargebox would not have been real today.</p>
<p>The road ahead is even tougher. Hope to find the strength to pull it off.</p>
<p>.-</p>
<p><strong>Note:</strong> &ldquo;hg init&rdquo; happened 3 days earlier.</p>
]]></description>
        <pubDate>Sun, 11 Aug 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>On mobile</title>
        <link>https://qnoid.com/2013/06/13/On-mobile.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/06/13/On-mobile.html</guid>
        <description><![CDATA[<p>Marco Arment made some great points on the state of iOS 7 but had an urge to make something clear.</p>
<blockquote>
<p>Great points by @<a href="https://twitter.com/marcoarment">marcoarment</a> on the state of iOS. If you don&rsquo;t get why, watch &ldquo;Building user interfaces for iOS 7&rdquo; <a href="http://t.co/INIKoYb1gi" title="http://www.marco.org/2013/06/11/fertile-ground">marco.org/2013/06/11/fer…</a></p>
</blockquote>
<h2 id="the-disruption-has-happened-already">The disruption has happened already</h2>
<p>It all started in <a href="https://www.youtube.com/watch?feature=player_detailpage&amp;v=t2MOwQ089eQ#t=1354s">June 29, 2007 when the original iPhone was introduced</a>. At the time when people were using their smartphones to make phone calls, send text, take photos, listen to music.</p>
<p>It&rsquo;s not that mobile phones weren&rsquo;t well equipped. They were relatively <a href="http://en.wikipedia.org/wiki/Siemens_SL45">advanced</a>. <a href="http://en.wikipedia.org/wiki/Nokia_6310i">Bluetooth</a>, <a href="http://en.wikipedia.org/wiki/Siemens_SXG75">GPRS</a>, GPS, <a href="http://en.wikipedia.org/wiki/Sony_Ericsson_K810i">back camera</a>, <a href="http://en.wikipedia.org/wiki/Nokia_N80">front facing camera</a>, <a href="http://en.wikipedia.org/wiki/Nokia_N91">large storage</a>; you name it.</p>
<p>Mobile phones had split <a href="http://en.wikipedia.org/wiki/List_of_Sony_Ericsson_products">per</a>-<a href="http://en.wikipedia.org/wiki/List_of_Nokia_products">so</a>-<a href="http://en.wikipedia.org/wiki/List_of_Motorola_products#Mobile_telephones">nalities</a> and <a href="http://en.wikipedia.org/wiki/File:S60_3rd_Edition_from_N73.jpg">the Internet was something you would &ldquo;go to&rdquo;</a>. Phones were <a href="https://en.wikipedia.org/wiki/Wireless_Application_Protocol">merely a window</a> to the Internet rather than being part of it. The main (ref?) business was selling ringtones; <a href="https://en.wikipedia.org/wiki/Ringtone#Ringtone_business">a profitable business</a> none the less. In their pursuit to expand market share, companies had lost focus. Developers weren&rsquo;t really looking.</p>
<p>On October 17th, 2007 Steve Jobs announced ^1 the forthcoming <a href="http://daringfireball.net/misc/2007/10/third-party-apps-on-iphone.text">availability of the iOS SDK</a>. The following WWDC the <a href="http://www.youtube.com/watch?v=xo9cKe_Fch8">App Store was introduced</a> and <a href="http://en.wikipedia.org/wiki/App_Store_(iOS)">in July, 2008 it was released</a> changing the face of mobile as we knew it.</p>
<h2 id="the-iphone-transcends-each-individual-sdk">The iPhone transcends each individual SDK</h2>
<p>Since then, Apple has invested heavily in the iOS SDK. Each year a new version is released with a new set of APIs. Collectively they make iOS and what the iPhone is today. Even though each version deserves its own release, to focus on a single feature set is short sighted in my opinion.</p>
<table>
<thead>
<tr>
<th><strong>2008</strong></th>
<th><strong>2009</strong></th>
<th><strong>2010</strong></th>
<th><strong>2011</strong></th>
<th><strong>2012</strong></th>
</tr>
</thead>
<tbody>
<tr>
<td>Cocoa Touch</td>
<td>CoreData</td>
<td>AirPlay</td>
<td>Core Image</td>
<td>Social Framework</td>
</tr>
<tr>
<td>AV Foundation</td>
<td>MapKit</td>
<td>AirPrint</td>
<td>Twitter</td>
<td>Pass Kit</td>
</tr>
<tr>
<td>CoreAudio</td>
<td>GameKit</td>
<td>Local Notifications</td>
<td>CoreBluetooth</td>
<td>Reminders</td>
</tr>
<tr>
<td>CoreLocation</td>
<td></td>
<td>Event Kit</td>
<td>Newsstand</td>
<td>UI State Preservation</td>
</tr>
<tr>
<td>Accelerometer</td>
<td></td>
<td>Core Motion</td>
<td></td>
<td>Auto Layout</td>
</tr>
<tr>
<td>CoreAnimation</td>
<td></td>
<td>Data Protection</td>
<td></td>
<td></td>
</tr>
<tr>
<td>Quartz 2D</td>
<td></td>
<td>Core Telephony$</td>
<td></td>
<td></td>
</tr>
</tbody>
</table>
<p><a href="http://en.wikipedia.org/wiki/IOS_SDK#SDK_release_history"><em>iOS SDK Release History</em></a></p>
<p>Looking back through the lifespan of the iPhone, <a href="http://en.wikipedia.org/wiki/Foursquare">Foursquare was released in 2009</a> and <a href="http://en.wikipedia.org/wiki/Instagram">Instagram on October 6th, 2010</a>. Both looked past a feature set on what was possible with mobile and ended up disrupting local recommendations and image sharing respectively. Don&rsquo;t expect Foursquare or Instagram to even budge with the release of iOS 7.</p>
<h2 id="ios-7-is-worth-it-but-only-as-much">iOS 7 is worth it, but only as much</h2>
<p>Indeed the App Store is crowded with <a href="http://www.theverge.com/2013/6/10/4412918/apple-stats-update-wwdc-2013">almost a million apps</a>. Big players like Facebook, Google (Google+), Yahoo! (Flickr), Amazon and ebay, along with many small ones. But even though they are on mobile, the extent to which they utilise it is poor. The main reason they are there in the first place is the <a href="http://allthingsd.com/20130325/among-big-properties-apple-and-amazon-have-greatest-portions-of-mobile-only-users/">large user base</a> present which <a href="http://venturebeat.com/2013/04/02/espn-mobiles-growth-shows-the-explosion-in-mobile-usage/">will only grow</a>. Apple touted half a billion users. That&rsquo;s a number you cannot ignore.</p>
<p>With the arrival of iOS 7 this fall, Apple&rsquo;s marketing team will surely promote apps that elevate the new feature set, satisfying the thirst of people buying the new iPhone and those upgrading to the latest iOS. You should do well to be on that wave and get a <a href="http://blog.anylistapp.com/2012/08/app-store/">free ride by Apple</a>. A big opportunity indeed. But that&rsquo;s about it.</p>
<h2 id="mobile-begs-for-some-innovation">Mobile begs for some innovation</h2>
<p>To treat mobile as just another platform, mirroring existing services, porting established ideas or looking for a category to fill is not innovative.</p>
<p>Mobile is the pinnacle of personal computing. People carry them around <a href="http://blog.flurry.com/?Tag=Usage%20Statistics">spending a great deal of time</a>. Even though mobile users have become familiar with tapping, swiping, pinching and are comfortable enough to share their location and photos, as an industry we still have a lot to learn and have barely scratched the surface of what&rsquo;s possible in mobile computing.</p>
<p>^1 Even though Steve was <a href="http://www.guardian.co.uk/technology/appsblog/2011/oct/24/steve-jobs-apps-iphone?newsfeed=true">reluctant</a> initially.</p>
]]></description>
        <pubDate>Thu, 13 Jun 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Sound Debugging</title>
        <link>https://qnoid.com/2013/06/08/Sound-Debugging.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/06/08/Sound-Debugging.html</guid>
        <description><![CDATA[<p><a href="https://soundcloud.com/qnoid/nsbrief-123-nsconference-6">Interview at NSBrief: #123: NSConference 6</a> with <a href="https://twitter.com/casademora">Saul Mora</a></p>
<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/rMtGcLLYldw" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<blockquote>
<p>Have filed bug report under rdar://16341784 See openradar.appspot.com/radar?id=5346823308836864*</p>
</blockquote>
<p>Xcode&rsquo;s ability to play sounds has been underused. Sound patterns can help debug notifications and visualize execution on unfamiliar code.</p>
<p>In this series of posts will explain what sound debugging is, show where it is useful, how it compares to traditional methods (e.g. logging) and bounce a few ideas on how it might help with testing, measure performance, debug concurrency and the teaching of algorithms.</p>
<h2 id="breakpoints-that-play-sound">Breakpoints that play sound</h2>
<p>In case you didn&rsquo;t know, <a href="https://developer.apple.com/xcode/" title="XCode is an Apple developed IDE to write iOS/Mac apps">XCode</a> has the ability to <a href="http://developer.apple.com/library/ios/#documentation/ToolsLanguages/Conceptual/Xcode_User_Guide/060-Debug_and_Tune_Your_App/debug_app.html">play a sound on a breakpoint</a>. Combined with the option to &ldquo;Automatically continue after evaluating&rdquo; you can effectively create a score based on code execution.</p>
<p>The idea behind sound debugging is based on the timing of these sounds; i.e. for an execution path with two breakpoints, you get this sound:</p>
<audio controls preload="none">
 <source src="/static/2013/06/08/funk-hero.m4a" type="audio/mp4" />
 </audio>
<p>Let&rsquo;s name those two sounds &ldquo;funk&rdquo; and &ldquo;hero&rdquo; respectively. Now, the sequence of two sounds doesn&rsquo;t tell you much without knowing the code they are associated with. What do those sounds actually &ldquo;mean&rdquo;?</p>
<p>Here is the cheat sheet.</p>
<p><strong>funk:</strong> an instance of QNDSubject was created. <br>
<strong>hero:</strong> an instance of QNDSubject was notified.</p>
<p>Now you can &ldquo;visualise&rdquo; code. Whenever you hear those two sounds, you know that &ldquo;an instance of QNDSubject was created&rdquo; and (by being the only instance) that &ldquo;was notified&rdquo;.</p>
<p>Both <strong>without taking a look at the source code</strong>. Let&rsquo;s look at the two parts of source code that the score relates to.</p>
<p>First the QNDSubject class where the instance is created.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl"><span class="p">@</span><span class="n">implementation</span> <span class="n">QNDSubject</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="o">+</span><span class="p">(</span><span class="n">instancetype</span><span class="p">)</span><span class="n">newSubject</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="n">QNDSubject</span> <span class="o">*</span><span class="n">subject</span> <span class="p">=</span> <span class="p">[</span><span class="n">QNDSubject</span> <span class="n">new</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="p">[</span><span class="n">subject</span> <span class="n">wasCreated</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="p">[[</span><span class="n">NSNotificationCenter</span> <span class="n">defaultCenter</span><span class="p">]</span> <span class="n">addObserver</span><span class="p">:</span><span class="n">subject</span>
</span></span><span class="line"><span class="cl">                                             <span class="n">selector</span><span class="p">:@</span><span class="n">selector</span><span class="p">(</span><span class="n">wasNotified</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                                                 <span class="n">name</span><span class="p">:</span><span class="n">QND_NOTIFY_SUBJECT</span>
</span></span><span class="line"><span class="cl">                                               <span class="n">object</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl"><span class="k">return</span> <span class="n">subject</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="o">-</span><span class="p">(</span><span class="n">void</span><span class="p">)</span><span class="n">dealloc</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="p">[[</span><span class="n">NSNotificationCenter</span> <span class="n">defaultCenter</span><span class="p">]</span> <span class="n">removeObserver</span><span class="p">:</span><span class="kc">self</span>
</span></span><span class="line"><span class="cl">                                                    <span class="n">name</span><span class="p">:</span><span class="n">QND_NOTIFY_SUBJECT</span>
</span></span><span class="line"><span class="cl">                                                  <span class="n">object</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="o">-</span><span class="p">(</span><span class="n">void</span><span class="p">)</span><span class="n">wasCreated</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="p">{}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="o">-</span><span class="p">(</span><span class="n">void</span><span class="p">)</span><span class="n">wasNotified</span>
</span></span><span class="line"><span class="cl"><span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="p">{}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">@</span><span class="n">end</span></span></span></code></pre></div>
<p>Second, the notification.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="n">QNDSubject</span> <span class="o">*</span><span class="n">subject</span> <span class="p">=</span> <span class="p">[</span><span class="n">QNDSubject</span> <span class="n">newSubject</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="p">[[</span><span class="n">NSNotificationCenter</span> <span class="n">defaultCenter</span><span class="p">]</span> <span class="n">postNotificationName</span><span class="p">:</span><span class="n">QND_NOTIFY_SUBJECT</span> <span class="n">object</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span></span></span></code></pre></div>
<p>Even though the code base is relatively small in this case, it still requires more than one look to understand its execution.</p>
<ul>
<li>Find the class whose instance you are interested in.</li>
<li>Look for the code that creates this instance.</li>
<li>Is the QNDSubject#wasCreated called?</li>
<li>Does it register for notifications?</li>
<li>Does the notification fire?</li>
</ul>
<p>No matter how &ldquo;clean&rdquo; code is, it is still hard to read between the lines.</p>
<p>There are two reasons in this case why a sound clip works better in visualising code than actually looking at code itself.</p>
<ul>
<li><strong>The time taken to listen</strong> to the sound clip is smaller than the time taken to read the code.</li>
<li><strong>The proximity of the two sounds</strong> is closer compared to every line of code that makes up the execution.</li>
</ul>
<p>Now, in such a small code base, logging would likely help as much <sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup>.</p>
<p>Where sound debugging really shines is in large <sup id="fnref:2"><a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a></sup>, unfamiliar codebases (or even a week? old) where the need to track multiple points of execution is required. Even more so, when such code is mostly based on async execution and is loosely couple using delegates and notifications.</p>
<p>Some examples where sound debugging can help you:</p>
<ul>
<li>Order of execution.</li>
<li>An instance is being reused or created each time.</li>
<li>A tap is handled more than once.</li>
<li>An object is destroyed.</li>
<li>A timer is invalidated or not.</li>
<li>An instance no longer listens for notifications.</li>
</ul>
<p><em>A second part will follow.</em></p>
<p><em><a href="https://github.com/qnoid/QNDSoundDebuggingSample">Source Code</a></em></p>
<p><strong>Origin:</strong> Had to come up with sound debugging when needed to debug an app where one operation &ldquo;sometimes&rdquo; timed out before another one had been executed.</p>
<p>Had just been brought in an unfamiliar and vast code base, involving lots of complex, async code and notifications. Knowing only two methods, (#didTimeOut and #executed) placed a breakpoint in each and listened.</p>
<p>After a couple of executions, was confident <sup id="fnref:3"><a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a></sup> that the timeout always came first. That gave a lead as where to look at and to the eventual fix.</p>
<p>Being in an unfamiliar code base found it easier to use sound breakpoints as stepping stones rather looking at method names to get a better understanding of what&rsquo;s involved in the tap of a button.</p>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>Even then, logging is still <strong>slower for your brain to process</strong> and also more prone to errors to your eyes; i.e. <br>
<strong>was</strong>Creat<strong>ed</strong>   <br>
<strong>was</strong>Notifi<strong>ed</strong>&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:2">
<p>As the code base grows, the practicalities of logging diminish. Your eyes might require to constantly jump in and out of the logs and all too often you need to indent logs so that they stand out.&#160;<a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
<li id="fn:3">
<p>When dealing with async/concurrent code you can &ldquo;never&rdquo; be sure of timings that are outside your control.&#160;<a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Sat, 08 Jun 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to implement a reusable UIView</title>
        <link>https://qnoid.com/2013/03/20/How-to-implement-a-reusable-UIView.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/03/20/How-to-implement-a-reusable-UIView.html</guid>
        <description><![CDATA[<p>There seems to be a lot of confusion around custom views on iOS that can be used both at compile time under Interface Builder and at runtime.</p>
<p>Even though a lot of posts exist that show how to design a UIView with a custom hierarchy using Interface Builder, there seems to be unnecessary complexity on what comes next.</p>
<h2 id="1-design-the-look-and-feel-and-view-hierarchy-in-interface-builder">1. Design the look and feel and view hierarchy in Interface Builder</h2>
<p>The first thing to do is create a xib file (TBView.xib) as to design in Interface Builder the look and feel of your custom view along with its hierarchy.</p>
<p><strong>By convention</strong>, this nib should hold <strong>a single top-level view</strong>.</p>
<p>The code to load any views that are in a xib file is the following.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="n">NSBundle</span> <span class="o">*</span><span class="n">mainBundle</span> <span class="p">=</span> <span class="p">[</span><span class="n">NSBundle</span> <span class="n">mainBundle</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="n">NSArray</span> <span class="o">*</span><span class="n">views</span> <span class="p">=</span> <span class="p">[</span><span class="n">mainBundle</span> <span class="n">loadNibNamed</span><span class="p">:@</span><span class="s">&#34;TBView&#34;</span> 
</span></span><span class="line"><span class="cl">                                        <span class="n">owner</span><span class="p">:</span><span class="kc">nil</span> 
</span></span><span class="line"><span class="cl">                                      <span class="n">options</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span></span></span></code></pre></div>
<p>Where <em>views</em> is a collection of every top-level view in the xib file. (in this case a single one)</p>
<p><em>Will come back later to see what role the owner plays in loading the view.</em></p>
<h2 id="2-create-a-subclass-of-uiview-as-your-custom-view">2. Create a subclass of UIView as your custom view</h2>
<p>In order to use the above look and feel in your custom view <strong>and be able to do so under Interface Builder^1</strong> you need to create a subclass of UIView.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="p">#</span><span class="kd">import</span> <span class="p">&lt;</span><span class="nc">UIKit</span><span class="o">/</span><span class="nc">UIKit</span><span class="p">.</span><span class="nc">h</span><span class="p">&gt;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="p">@</span><span class="n">interface</span> <span class="n">TBView</span> <span class="p">:</span> <span class="n">UIView</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="p">@</span><span class="n">end</span></span></span></code></pre></div>
<p><strong>By convention</strong>, the name of your subclass should be the same as the xib file.</p>
<h2 id="3-using-it-at-compile-time-under-interface-builder">3. Using it at compile time under Interface Builder </h2>
<p>In your UIViewController&rsquo;s xib, drag a view and set the &ldquo;Class&rdquo; as &ldquo;TBView&rdquo; in the &ldquo;Custom Class&rdquo; section under &ldquo;Identity Inspector&rdquo;. (CMD+OPTION+3)</p>
<p><strong>By convention</strong>, this view should have the same size as the look and feel design.</p>
<p>Any view in a nib file that is part of the view hierarchy is initialised using <a href="https://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/Protocols/NSCoding_Protocol/Reference/Reference.html">NSCoding#initWithCoder:</a> hence this is the spot where you load the  #view from the xib and add it as a subclass.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="o">-</span><span class="p">(</span><span class="n">id</span><span class="p">)</span><span class="n">initWithCoder</span><span class="p">:(</span><span class="n">NSCoder</span> <span class="o">*</span><span class="p">)</span><span class="n">aDecoder</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span> <span class="p">=</span> <span class="p">[</span><span class="kc">super</span> <span class="n">initWithCoder</span><span class="p">:</span><span class="n">aDecoder</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="kc">self</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">nil</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="n">NSBundle</span> <span class="o">*</span><span class="n">mainBundle</span> <span class="p">=</span> <span class="p">[</span><span class="n">NSBundle</span> <span class="n">mainBundle</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="n">NSArray</span> <span class="o">*</span><span class="n">views</span> <span class="p">=</span> <span class="p">[</span><span class="n">mainBundle</span> <span class="n">loadNibNamed</span><span class="p">:</span><span class="n">NSStringFromClass</span><span class="p">([</span><span class="kc">self</span> <span class="kd">class</span><span class="p">])</span> 
</span></span><span class="line"><span class="cl">                                            <span class="n">owner</span><span class="p">:</span><span class="kc">nil</span> 
</span></span><span class="line"><span class="cl">                                          <span class="n">options</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="kc">self</span> <span class="n">addSubview</span><span class="p">:</span><span class="n">views</span><span class="p">[</span><span class="mi">0</span><span class="p">]];</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">self</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span></span></span></code></pre></div>
<p>Notice how we are using the name of the class, which is the same as the xib by convention  to load the view.</p>
<p>This is how the hierarchy looks like.</p>
<pre>
$0 = 0x0756c810 <TBView: 0x756bf50; frame = (0 0; 320 274); autoresize = W+H; layer = <CALayer: 0x756bfd0>>
       | <UIView: 0x756c050; frame = (0 0; 320 274); autoresize = RM+BM; layer = <CALayer: 0x756c0b0>>
       |    | <UILabel: 0x756ca70; frame = (0 126; 320 21); text = 'Hello World'; clipsToBounds = YES; opaque = NO; autoresize = RM+BM; userInteractionEnabled = NO; layer = <CALayer: 0x756c0e0>>
</pre>
<h2 id="4-using-it-at-runtime-given-a-frame">4. Using it at runtime given a frame</h2>
<p>Simply override <a href="http://developer.apple.com/library/ios/#documentation/uikit/reference/uiview_class/uiview/uiview.html">UIView#initWithFrame:</a> and use the same code to load the view from the xib and add it in the hierarchy.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="o">-</span> <span class="p">(</span><span class="n">id</span><span class="p">)</span><span class="n">initWithFrame</span><span class="p">:(</span><span class="n">CGRect</span><span class="p">)</span><span class="n">frame</span>
</span></span><span class="line"><span class="cl">    <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kc">self</span> <span class="p">=</span> <span class="p">[</span><span class="kc">super</span> <span class="n">initWithFrame</span><span class="p">:</span><span class="n">frame</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="kc">self</span><span class="p">){</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">nil</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        
</span></span><span class="line"><span class="cl">        <span class="n">NSBundle</span> <span class="o">*</span><span class="n">mainBundle</span> <span class="p">=</span> <span class="p">[</span><span class="n">NSBundle</span> <span class="n">mainBundle</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="n">NSArray</span> <span class="o">*</span><span class="n">views</span> <span class="p">=</span> <span class="p">[</span><span class="n">mainBundle</span> <span class="n">loadNibNamed</span><span class="p">:</span><span class="n">NSStringFromClass</span><span class="p">([</span><span class="kc">self</span> <span class="kd">class</span><span class="p">])</span> 
</span></span><span class="line"><span class="cl">                                            <span class="n">owner</span><span class="p">:</span><span class="kc">nil</span> 
</span></span><span class="line"><span class="cl">                                          <span class="n">options</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="kc">self</span> <span class="n">addSubview</span><span class="p">:</span><span class="n">views</span><span class="p">[</span><span class="mi">0</span><span class="p">]];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">self</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span></span></span></code></pre></div>
<p>You can now create a new instance of that view as usual.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="n">TBView</span> <span class="o">*</span><span class="n">view</span> <span class="p">=</span> <span class="p">[[</span><span class="n">TBView</span> <span class="n">alloc</span><span class="p">]</span> <span class="n">initWithFrame</span><span class="p">:</span><span class="n">frame</span><span class="p">];</span></span></span></code></pre></div>
<h2 id="5-files-owner-and-iboutlets">5. File&rsquo;s Owner and IBOutlets</h2>
<p>If you need to keep references to any of the views in the xib, you can use the custom view as the File&rsquo;s Owner and define any IBOutlets as properties of that class.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">        <span class="n">NSBundle</span> <span class="o">*</span><span class="n">mainBundle</span> <span class="p">=</span> <span class="p">[</span><span class="n">NSBundle</span> <span class="n">mainBundle</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="n">NSArray</span> <span class="o">*</span><span class="n">views</span> <span class="p">=</span> <span class="p">[</span><span class="n">mainBundle</span> <span class="n">loadNibNamed</span><span class="p">:</span><span class="n">NSStringFromClass</span><span class="p">([</span><span class="kc">self</span> <span class="kd">class</span><span class="p">])</span> 
</span></span><span class="line"><span class="cl">                                            <span class="n">owner</span><span class="p">:</span><span class="kc">self</span> 
</span></span><span class="line"><span class="cl">                                          <span class="n">options</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="kc">self</span> <span class="n">addSubview</span><span class="p">:</span><span class="n">views</span><span class="p">[</span><span class="mi">0</span><span class="p">]];</span></span></span></code></pre></div>
<p>As part of loading the views from the xib, the view will have its IBOutlets set.</p>
<p><strong>By convention</strong>, the custom class should be the File&rsquo;s Owner thus keeping all related code in a single class that can be reused.</p>
<p>Here is a macro that you can use in both initalisers to load a single view hierarchy that is available in the main bundle.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">    <span class="p">#</span><span class="n">define</span> <span class="n">loadView</span><span class="p">()</span> <span class="err">\</span>
</span></span><span class="line"><span class="cl">    <span class="n">NSBundle</span> <span class="o">*</span><span class="n">mainBundle</span> <span class="p">=</span> <span class="p">[</span><span class="n">NSBundle</span> <span class="n">mainBundle</span><span class="p">];</span> <span class="err">\</span>
</span></span><span class="line"><span class="cl">    <span class="n">NSArray</span> <span class="o">*</span><span class="n">views</span> <span class="p">=</span> <span class="p">[</span><span class="n">mainBundle</span> <span class="n">loadNibNamed</span><span class="p">:</span><span class="n">NSStringFromClass</span><span class="p">([</span><span class="kc">self</span> <span class="kd">class</span><span class="p">])</span> 
</span></span><span class="line"><span class="cl">                                        <span class="n">owner</span><span class="p">:</span><span class="kc">self</span> 
</span></span><span class="line"><span class="cl">                                      <span class="n">options</span><span class="p">:</span><span class="kc">nil</span><span class="p">];</span> <span class="err">\</span>
</span></span><span class="line"><span class="cl">    <span class="p">[</span><span class="kc">self</span> <span class="n">addSubview</span><span class="p">:</span><span class="n">views</span><span class="p">[</span><span class="mi">0</span><span class="p">]];</span></span></span></code></pre></div>
<p><em><a href="https://github.com/qnoid/TBReusableUIView">Source Code</a></em></p>
<h2 id="references">References</h2>
<p><a href="https://developer.apple.com/library/ios/#documentation/Cocoa/Reference/ApplicationKit/Protocols/NSNibAwaking_Protocol/Reference/Reference.html">NSNibAwaking Protocol Reference</a><br>
<a href="https://developer.apple.com/library/ios/#documentation/Cocoa/Conceptual/LoadingResources/CocoaNibs/CocoaNibs.html">Nib Files</a></p>
<p>^1: You can equally load the top-level view as designed in Interface Builder and use it at compile time.</p>
]]></description>
        <pubDate>Wed, 20 Mar 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to debug a &#34;class JKserializer is implemented in both&#34; case (Part 2)</title>
        <link>https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-2.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-2.html</guid>
        <description><![CDATA[<p><a href="https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-1.html#main">In the first part</a>, found out that the executable included two definitions of the JKSerializer class. The one, used at compile time, corresponding to version 1.4 of JSONKit and another, deriving from 1.5 which was present at runtime.</p>
<p>In order, 1.5 came up first in the class dump, followed by the 1.4 as used by the app. Not sure how class-dump derives that order but does appear to be relevant as we&rsquo;ll see further on.</p>
<p>The next thing is to find all the files where JKSerializer is actually coming from. This can either be a source file or a static library that includes JSONKit.</p>
<p>Using <a href="http://unixhelp.ed.ac.uk/CGI/man-cgi?find">find</a> with <a href="http://unixhelp.ed.ac.uk/CGI/man-cgi?grep">grep</a>, every file under the current directory that has &ldquo;JKSerializer&rdquo; in its contents will match, printing its name in the process.</p>
<pre>
    find . -type f -exec grep -q "JKSerializer" '{}' \; -print
</pre>
<p>Running the above under the project&rsquo;s directory, yields the following files.</p>
<pre>
./External/BugSense-iOS.frame-ork/Versions/A/BugSense-iOS
./JSONKit/JSONKit.m
</pre>
<p>So it seems that BugSense includes JSONKit as part of its distribution. Could that be version 1.5?  Looking at the <a href="http://en.wikipedia.org/wiki/Symbol_table">symbol table</a> on the file for the i386 architecture (the one running on the simulator)</p>
<pre>
    nm -arch i386 ./External/BugSense-iOS.framework/Versions/A/BugSense-iOS | less
</pre>
<p>You will find the culprit.</p>
<pre>
+[JKSerializer serializeObject:options:encodeOption:block:delegate:selector:error:]
</pre>
<p>That explains the second definition of the JKSerializer class in the executable. What about the randomness of the crash though?</p>
<p>It turns out that it depends on the order of linking the binary with libraries under Xcode. <strong>If BugSense comes first on the list, its definition of JKSerializer takes precedence.</strong> Moving the libJSONKit.a library on top, no longer causes the crash.</p>
<p><strong>Kudos</strong> to <a href="https://twitter.com/atnan">atnan</a> for <a href="http://atnan.com/blog/2012/01/12/avoiding-duplicate-symbol-errors-during-linking-by-removing-classes-from-static-libraries">his article</a> on <a href="https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man1/lipo.1.html">lipo</a> and <a href="https://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man1/ar.1.html">ar</a> tools and also a contributor to JSONKit.</p>
<p><em>Extra Tidbit</em>
The way the compiler (<a href="http://llvm.org">LLVM</a>) resolves any symbols is by using a symbol table. Using <a href="http://unixhelp.ed.ac.uk/CGI/man-cgi?nm">nm</a>, you can list the contents of the symbol table.</p>
<pre>
nm "/Users/qnoid/Library/Application Support/iPhone Simulator/5.1/Applications/9CEF83D3-C9DE-4951-95DF-CC1A3DB223F8/TBUndefined.app/TBUndefined"
</pre>
<p>Looking for JKSerializer, you can find the two class definitions. (as previously shown by the class dump)</p>
<pre>
	1044 < 0005c0b4 S _OBJC_CLASS_$_JKSerializer
	1045 < 0005bca4 s _OBJC_CLASS_$_JKSerializer
</pre>
<p>The only difference between the two being that <a href="http://sourceware.org/binutils/docs-2.17/binutils/nm.html#nm">one is defined a a local symbol while the other one as global</a>. <strong>Would like to know how that is decided and if what role (if any) plays in resolving the class.</strong></p>
<p>Symbol tables are usually implemented as <a href="https://qnoid.com/2011/04/07/hash-table-part-1.html#main" title="How to think of a hash table">hash tables</a>.</p>
<p>Looking at the source code of <a href="http://llvm.org/docs/doxygen/html/classllvm_1_1ValueSymbolTable.html">the symbol table for LLVM</a>, under <a href="http://llvm.org/docs/doxygen/html/ValueSymbolTable_8h_source.html#l00071">line 71 you can see a lookup by name</a> to the underlying hash table. This implementation of the hash table <a href="http://llvm.org/docs/doxygen/html/StringMap_8h_source.html#l00297">does not use a key</a> for looking up a value in the <a href="http://llvm.org/docs/doxygen/html/StringMap_8h_source.html#l00283">corresponding bucket</a>. Not iterating through the bucket, <strong>seemingly returning  the first definition of JKSerializer</strong>, the 1.5 version one.</p>
]]></description>
        <pubDate>Tue, 12 Feb 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to debug a &#34;class JKserializer is implemented in both&#34; case (Part 1)</title>
        <link>https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-1.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-1.html</guid>
        <description><![CDATA[<p>Recently came across the following warning while running an app on the simulator.</p>
<pre>
objc[3946]: Class JKSerializer is implemented in both **/Users/qnoid/Library/Application Support/iPhone Simulator/5.1/Applications/9CEF83D3-C9DE-4951-95DF-CC1A3DB223F8/TBUndefined.app/TBUndefined** and **/Users/qnoid/Library/Application Support/iPhone Simulator/5.1/Applications/9CEF83D3-C9DE-4951-95DF-CC1A3DB223F8/TBUndefined.app/TBUndefined**. One of the two will be used. Which one is undefined.
</pre>
<p>The thing to note is how the warning points to the exact same location. Specifically the <strong>TBUndefined</strong> executable. What this means is that the class definition somehow found its way twice in the executable.</p>
<p>A seemingly random crash would also occur when calling <a href="https://github.com/johnezang/JSONKit/blob/v1.4/JSONKit.m#L2990">NSDictionary#JSONString</a>. Random as in, every now and then the app would be in a state where it would crash. But once in this state, the crash was consistently reproduced. In both cases, the warning above was depicted.</p>
<p>When the crash occurred, the following error was emitted in the console.</p>
<blockquote>
<p>2013-02-11 22:57:19.754 TBUndefined[3946:c07] <strong>+[JKSerializer serializeObject:options:encodeOption:error:]: unrecognized selector</strong> sent to class 0x5bca4</p>
</blockquote>
<p>This is seemingly contradictory to the warning. On one hand the JKSerializer class appears to be defined twice. While on the other, one of its method definition is missing.</p>
<p>First thing to do is find where the JKSerializer class is defined. Turns out, this class is part of <a href="https://github.com/johnezang/JSONKit/blob/v1.4/JSONKit.m">JSONKit</a> under the <a href="https://github.com/johnezang/JSONKit/blob/v1.4/JSONKit.m#L452">JSONKit.m</a> file along with the expected method definition. (It&rsquo;s worth noting that JSONKit was compiled as a static library, part of a set of dependencies as defined using Cocoapods)</p>
<p>At this point decided to take a look at the executable itself for the definition of JKSerializer. <a href="https://github.com/nygard">Steve Nygard</a> has created a great tool, <a href="http://stevenygard.com/projects/class-dump/">class-dump</a>, that generates declarations of classes, protocols and categories in a Mach-O file.</p>
<p>The executable can be found at</p>
<pre>
/Users/qnoid/Library/Developer/Xcode/DerivedData/TBUndefined-dksnnnn-dsvgfybkturbkhxboi-b/Build/Products/Debug-iphonesimulator/TBUndefined.app/TBUndefined
</pre>
<p>Running a</p>
<pre>
	class-dump TBUndefined > TBUndefined.dump
</pre>
<p>and searching for JKSerializer under TBUndefined.dump we do find the two definitions as hinted by the warning. Take a look at the methods.</p>
<p>First Occurrence</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">	<span class="p">@</span><span class="n">interface</span> <span class="n">JKSerializer</span> <span class="p">:</span> <span class="n">NSObject</span>
</span></span><span class="line"><span class="cl">	<span class="cm">/* properties omitted for brevity */</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	  <span class="o">+</span> <span class="p">(</span><span class="n">id</span><span class="p">)</span><span class="n">serializeObject</span><span class="p">:(</span><span class="n">id</span><span class="p">)</span><span class="n">arg1</span> <span class="n">options</span><span class="p">:(</span><span class="n">unsigned</span> <span class="n">int</span><span class="p">)</span><span class="n">arg2</span> <span class="n">encodeOption</span><span class="p">:(</span><span class="n">unsigned</span> <span class="n">int</span><span class="p">)</span><span class="n">arg3</span> <span class="n">block</span><span class="p">:(</span><span class="n">id</span><span class="p">)</span><span class="n">arg4</span> <span class="n">delegate</span><span class="p">:(</span><span class="n">void</span><span class="p">)</span><span class="n">arg5</span> <span class="n">selector</span><span class="p">:(</span><span class="n">id</span><span class="p">)</span><span class="n">arg6</span> <span class="n">error</span><span class="p">:(</span><span class="n">SEL</span><span class="p">)</span><span class="n">arg7</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="cm">/* instance methods omitted for brevity */</span>
</span></span><span class="line"><span class="cl">	  
</span></span><span class="line"><span class="cl">	<span class="p">@</span><span class="n">end</span></span></span></code></pre></div>
<p>Second Occurrence</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">	<span class="p">@</span><span class="n">interface</span> <span class="n">JKSerializer</span> <span class="p">:</span> <span class="n">NSObject</span>
</span></span><span class="line"><span class="cl">	  
</span></span><span class="line"><span class="cl">	<span class="cm">/* properties omitted for brevity */</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	  <span class="o">+</span> <span class="p">(</span><span class="n">id</span><span class="p">)</span><span class="n">serializeObject</span><span class="p">:(</span><span class="n">id</span><span class="p">)</span><span class="n">arg1</span> <span class="n">options</span><span class="p">:(</span><span class="n">unsigned</span> <span class="n">int</span><span class="p">)</span><span class="n">arg2</span> <span class="n">encodeOption</span><span class="p">:(</span><span class="n">unsigned</span> <span class="n">int</span><span class="p">)</span><span class="n">arg3</span> <span class="n">error</span><span class="p">:(</span><span class="n">id</span> <span class="o">*</span><span class="p">)</span><span class="n">arg4</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="cm">/* instance methods omitted for brevity */</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">	<span class="p">@</span><span class="n">end</span></span></span></code></pre></div>
<p>As you can tell, the method in question, appears to have a different definition to the one the code is calling. Having 3 extra arguments, <strong>block:delegate:selector:</strong>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-swift" data-lang="swift"><span class="line"><span class="cl">	<span class="o">+</span> <span class="p">(</span><span class="n">id</span><span class="p">)</span><span class="n">serializeObject</span><span class="p">:</span><span class="n">options</span><span class="p">:</span><span class="n">encodeOption</span><span class="p">:</span><span class="n">block</span><span class="p">:</span><span class="n">delegate</span><span class="p">:</span><span class="n">selector</span><span class="p">:</span><span class="n">error</span><span class="p">:;</span></span></span></code></pre></div>
<p>Turns out, this is the <a href="https://github.com/johnezang/JSONKit/blob/master/JSONKit.m#L497">JSONKit 1.5 definition</a>.</p>
<p>In the <a href="https://qnoid.com/2013/02/12/How-to-debug-a-class-JKserializer-is-implemented-in-both-case-part-2.html#main">next part</a>, we&rsquo;ll see how that definition ended up there and explain the randomness of the crash.</p>
<p>I have created a <a href="https://github.com/qnoid/TBUndefined">sample project</a> that demonstrates the above behaviour as a reference.</p>
<h2 id="kudos">Kudos</h2>
<p><a href="https://twitter.com/mikeash">mikeash</a> for contributing so much valuable knowledge to the community for free <a href="http://www.mikeash.com/pyblog/friday-qa-2011-12-02-object-file-inspection-tools.html">via his blog</a>.<br>
<a href="https://twitter.com/alloy">alloy</a> for creating <a href="http://cocoapods.org">Cocoapods</a>.</p>
]]></description>
        <pubDate>Tue, 12 Feb 2013 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>iOS implementation of user authentication without a password</title>
        <link>https://qnoid.com/2012/12/09/iOS-implementation-of-user-authentication-without-a-password.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2012/12/09/iOS-implementation-of-user-authentication-without-a-password.html</guid>
        <description><![CDATA[<iframe width="560" height="315" src="https://www.youtube-nocookie.com/embed/_9Zu-AHhXyo" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
<p>iOS implementation of user authentication without a password as <a href="https://qnoid.com/2012/11/10/A-post-about-user-identity-that-is-thought-provoking-on-user-authorisation-and-security-or-just-utter-bullshit.html#main">specified</a> and <a href="https://qnoid.com/2012/11/10/Mockups-on-user-identity.html#main">mocked up</a> previously.</p>
]]></description>
        <pubDate>Sun, 09 Dec 2012 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Mockups on user identity</title>
        <link>https://qnoid.com/2012/11/10/Mockups-on-user-identity.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2012/11/10/Mockups-on-user-identity.html</guid>
        <description><![CDATA[<h2 id="user-identity">User identity</h2>
<p><a href="https://qnoid.com/2012/11/10/A-post-about-user-identity-that-is-thought-provoking-on-user-authorisation-and-security-or-just-utter-bullshit.html#main">The idea of a user identity</a> is a simple one with a goal to eliminate the requirement of a user entering a password. Any other requirement, including storing, transmitting and hashing should stay the same.</p>
<h2 id="introduction">Introduction</h2>
<p>As soon as a software is installed that supports user identities, a user is presented with a screen to <strong>identify</strong>.</p>
<p><a href="https://a248.e.akamai.net/camo.github.com/ed48b067a2ae62d955a4b68c59a7eedd7e011412/687474703a2f2f692e6d696e75732e636f6d2f6975436864564c66447136676e2e4a5047">Introduction</a></p>
<h2 id="identify">Identify</h2>
<p>The user enters her email and a new residence identifier is generated <sup id="fnref:1"><a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a></sup> both securely persisted on the client. On an iPhone that should be the keychain. A request is sent to the server to approve the new residence.</p>
<p>The server sends an email to the user to verify the new residence. Once the residence has been approved, its identifier and the user email are hashed and persisted. This becomes the residence of the user identity which is used for a future identification.</p>
<p><a href="https://a248.e.akamai.net/camo.github.com/63a5fced76633c6bde913b5f7eaf2dca62b81d3e/687474703a2f2f692e6d696e75732e636f6d2f693277554669626c54414a41692e4a5047">Identify</a></p>
<h2 id="sign-in">Sign in</h2>
<p>The now owner of the identity, can use it to sign in remotely to the server and retrieve her data. The user identity along with the residence identifier should be transmitted using a secure channel and compared against the hash stored in the server.</p>
<p><a href="https://a248.e.akamai.net/camo.github.com/c0856a06c8571e24d2d9ff48229cf68f92abe538/687474703a2f2f692e6d696e75732e636f6d2f696d4931657a525949355151552e4a5047">Sign in</a></p>
<h2 id="deleting-an-identity">Deleting an identity</h2>
<p>To delete an identity, slide across on an iPhone.</p>
<p><a href="https://a248.e.akamai.net/camo.github.com/2e2c745545f7e509a7fc7b2d83551c882680df5f/687474703a2f2f692e6d696e75732e636f6d2f693447376c6e3371676f4f334f2e4a5047">Delete</a></p>
<p>The identity is permanently removed from this residence.</p>
<h2 id="loose-ends">Loose ends</h2>
<ol>
<li>In the web, <a href="http://www.nczonline.net/blog/2010/04/13/towards-more-secure-client-side-data-storage/">a secure client storage doesn&rsquo;t exist.</a>
<a href="https://gist.github.com/qnoid/4052818#comment-594734">Discussion</a></li>
</ol>
<div class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1">
<p>The most simple form of the residence identifier can be a [UUID][5].&#160;<a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a></p>
</li>
</ol>
</div>
]]></description>
        <pubDate>Sat, 10 Nov 2012 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>A post about user identity that is thought provoking on user authorisation and security, or just utter bullshit</title>
        <link>https://qnoid.com/2012/11/10/A-post-about-user-identity-that-is-thought-provoking-on-user-authorisation-and-security-or-just-utter-bullshit.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2012/11/10/A-post-about-user-identity-that-is-thought-provoking-on-user-authorisation-and-security-or-just-utter-bullshit.html</guid>
        <description><![CDATA[<h1 id="user-identity">User identity</h1>
<p><strong>Disclaimer:</strong> I am no security expert.</p>
<h2 id="use-case">Use case</h2>
<p>Provide a way for a user to <strong>identify</strong> himself before <strong>remotely</strong> accessing a <strong>multi-user</strong> software that requires to <strong>associate</strong> the user with her <strong>data</strong>.</p>
<h2 id="introduction">Introduction</h2>
<p>There are two forms of user identification.</p>
<ol>
<li>Non authorised by the user</li>
<li>Authorised by the user</li>
</ol>
<h3 id="definitions">Definitions</h3>
<blockquote>
<p>Non authorised identification is a user saying who he is.<br>
Authorised identification is a user saying who he is and trusting her.</p>
</blockquote>
<p>For brevity, non authorised identification will be known simply as <strong>identification</strong>.</p>
<p>In essence, an authorised identification is a two stage identification. In the first stage the user provides an alias that is known of, usually in the form of a username. In the second stage the user provides proof to his claim, usually in the form of a password.</p>
<blockquote>
<p>Imagine sitting behind a large door. A user comes and knocks.</p>
</blockquote>
<blockquote>
<ul>
<li>&ldquo;Who is this?&rdquo;</li>
<li>&ldquo;This is John&rdquo; &lt;- Identification</li>
<li>&ldquo;Prove it!&rdquo;</li>
<li>&ldquo;Here is my passport&rdquo; &lt;- Authorised</li>
</ul>
</blockquote>
<h2 id="identity">Identity</h2>
<p>The identity of the user is her email. An email is required both for identifying it to its owner and for verifying a new residence. An identity can have many residences.</p>
<h2 id="residence">Residence</h2>
<p>Each identity is paired with a residence. A residence vouches for the user identity. Should the residence be removed, the identity can no longer be vouched for.</p>
<h2 id="characteristics-of-a-residence">Characteristics of a residence</h2>
<p>A residence has an identifier which needs to adhere to the following principles.</p>
<ol>
<li>
<p>Private.<br>
The identifier of a residence is private even to its owner.</p>
</li>
<li>
<p>Unique.<br>
A residence identifier needs to be unique from a pool of residences.</p>
</li>
<li>
<p>Secure.<br>
The identifier needs to be securely stored.</p>
</li>
</ol>
<h2 id="creating-a-new-residence">Creating a new residence.</h2>
<p>Assuming the owner of the identity wants to create a new residence from which she can access the software.</p>
<p>The user requests for the new residence to be added. Subsequently, verifies the new residence via email. The new residence can now vouch for the user&rsquo;s identity.</p>
<h2 id="delete-a-residence">Delete a residence</h2>
<p>The owner should be able to remove a residence. If a residence is deleted, the identity is also permanently removed as a residence.</p>
<h2 id="mockups">Mockups</h2>
<p><a href="https://qnoid.com/2012/11/10/Mockups-on-user-identity.html#main">Some mockups as to how it looks in practice.</a></p>
<h2 id="inspired-by">Inspired by</h2>
<ol>
<li><a href="http://storify.com/lukew/yahoo-display-password-test">Yahoo! &amp; Sprint Displayed Passwords at Scale. What Happened?</a></li>
<li><a href="http://4ourth.com/wiki/Sign%20On">Sign On</a></li>
<li><a href="https://developer.mozilla.org/en-US/docs/Persona">Persona</a></li>
</ol>
]]></description>
        <pubDate>Sat, 10 Nov 2012 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to trace and debug an iOS crash (Part 2)</title>
        <link>https://qnoid.com/2012/10/21/How-to-trace-and-debug-an-iOS-crash-part-2.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2012/10/21/How-to-trace-and-debug-an-iOS-crash-part-2.html</guid>
        <description><![CDATA[<h2 id="dead-end">Dead end</h2>
<p><a href="https://qnoid.com/2012/10/20/How-to-trace-and-debug-an-iOS-crash-part-1.html#main">Having reached a dead end</a>, decided to take a look at the client side in an effort to understand more about the request/response cycle.</p>
<p>First thing was to enable logging for the headers and body of both the <a href="https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSURLRequest_Class/Reference/Reference.html#//apple_ref/occ/cl/NSURLRequest">request</a> and the <a href="https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSHTTPURLResponse_Class/Reference/Reference.html#//apple_ref/occ/cl/NSHTTPURLResponse">response</a>.</p>
<pre>
    > GET /foo HTTP/1.1  
    > "Accept-Encoding" = gzip;  
    > "Accept-Language" = [languages];  
    > Range = "foo=0-10";  
    > "User-Agent" = "[App Bundle Id]/ (unknown, iPhone OS 4.3.3, iPad, Scale/1.000000)";

    < HTTP/1.1 200 OK  
    < Content-Type: plain/text  
    < X-pad: avoid browser bug  
</pre>
<p>Notice the &ldquo;Content-Type: plain/text&rdquo; (though the <a href="http://stackoverflow.com/questions/8711584/x-pad-avoid-browser-bug-header-added-by-apache">&ldquo;X-pad: avoid browser bug&rdquo;</a> did look interesting on its own way).</p>
<p><strong>QUESTION</strong>: How and why the content type of the response was changing from the expected &ldquo;application/json&rdquo;?</p>
<p><strong>EVIDENCE</strong></p>
<pre>
1. > GET /foo HTTP/1.1
2. < [empty body]
3. Response "Content-Type: plain/text" (Application Layer)
</pre>
<h2 id="back-to-basics">Back to basics</h2>
<p>Continuing with the elimination process, it was the iPad&rsquo;s turn this time, substituting with <a href="http://www.linuxmanpages.com/man1/curl.1.php">curl</a></p>
<pre>
    [curl] -> [AWS Load Balancer] -> [AWS EC2 Single instance)
</pre>
<p>In an effort to reproduce the request as sent by the iPad, failed to receive the &ldquo;desired&rdquo; response, instead the received response was the expected &ldquo;application/json&rdquo; one.</p>
<pre>
    curl -v -A "[App Bundle Id]/ (unknown, iPhone OS 4.3.3, iPad, Scale/1.000000)" -H "Accept:" -H "Accept-Encoding: gzip" -H "Accept-Language" = "[languages]" -H "Range: foo=0-10" www.domain.com/foo
</pre>
<p>Bare in mind that the request headers above were obtained using</p>
<pre>
    NSLog(@"%@", [request allHTTPHeaderFields])
</pre>
<p>With no access to the iOS source, it&rsquo;s difficult to know if every header is indeed in the returned NSDictionary. Hence decided to bring back to the equation the iPad and go down to the Network Layer to see the raw data.</p>
<h2 id="dumping-the-tcp">Dumping the tcp</h2>
<pre>
    [iPad 4.3.3 WiFi] -> [Mac] -> [AWS Load Balancer] -> [AWS EC2 Single instance)
</pre>
<p>In order to trace the network traffic as sent from the iPad, all you need is to have your Mac connected to the same network and share that network connection from OS X.</p>
<pre>
    Apple -> System Preferences -> Internet Sharing  
    "Share your connection from: Ethernet"  
    "To computers using: Wi-Fi"  
    "Computer name: [computer name]"  
</pre>
<p>Connect the iPad to the Wi-Fi [computer name] and have <a href="http://support.apple.com/kb/HT3994" title="Mac OS X: How to capture a packet trace">tcpdump</a> running.</p>
<pre>
    sudo tcpdump -i en0 -s 0 -B 524288 -w ~/Desktop/DumpFile01.pcap
</pre>
<p>Here is what the tcpdump revealed.</p>
<pre>
    > HEAD /foo HTTP/1.1
    > Host: [AWS Load Balancer]
    > User-Agent: [App Bundle Id]/ (unknown, iPhone OS 4.3.3, iPad, Scale/1.000000)
    > Accept-Encoding: gzip
    > Accept-Language: [languages]
    > Accept: */*
    > Cookie: [cookies]
    > Content-Length: 0
    > Connection: keep-alive

    > HTTP/1.1 200 OK
    > Date: [timestamp]
    > Server: [server]
    > Content-Range: foo=0-10/11
    > Connection: Keep-alive
    > Content-Type: text/plain
    > X-Pad: avoid browser bug
</pre>
<p>followed by</p>
<pre>
    > GET /foo HTTP/1.1
    > Host: [AWS Load Balancer]
    > User-Agent: [App Bundle Id]/ (unknown, iPhone OS 4.3.3, iPad, Scale/1.000000)
    > Accept-Encoding: gzip
    > Accept-Language: [languages]
    > Range: foo=0-10
    > Accept: */*
    > Cookie: [cookies]
    > Connection: keep-alive

    < HTTP/1.1 200 OK
    < Date: [timestamp]
    < Server: [server]
    < Content-Range: foo=0-10/11
    < Content-Type: application/json
    < Connection: Keep-alive
    < transfer-encoding: chunked
</pre>
<p>Indeed there is a &ldquo;plain/text&rdquo; response but this is coming from a HEAD request on the same URL. What follows is the &ldquo;application/json&rdquo; one to the GET.</p>
<p><strong>QUESTION</strong>: If the response is coming back as expected at the network layer, why are responses getting mixed up at the application layer?</p>
<p>Could that be a threading issue? A race condition? Why is it happening only on the iPad 4.3.3?</p>
<p>To make sure that this wasn&rsquo;t a race condition, put a breakpoint on the <a href="http://engineering.gowalla.com/AFNetworking/Classes/AFHTTPRequestOperation.html#//api/name/setCompletionBlockWithSuccess:failure:">completionBlock</a> of the HEAD request to check the response. The response was the expected one.</p>
<p>Checking the response from GET however, turned out to be the same one as the HEAD.</p>
<p><strong>QUESTION</strong>: Why would iOS 4.3.3 return a seemingly cached response?</p>
<p><strong>EVIDENCE</strong></p>
<pre>
1. > GET /foo HTTP/1.1
2. < [empty body]
3. Response "Content-Type: plain/text" (Application Layer)
4. Response "Content-Type: application/json" (Network Layer)
5. Cached response on GET /foo (Client side)
</pre>
<p><em>While debugging the above, came across a neat trick on <a href="http://www.ducea.com/2006/06/09/apache-tips-tricks-discover-the-web-server-software-and-version-of-a-remote-server/">how to query an http server for its version</a></em></p>
<p><strong>A third part will follow</strong></p>
]]></description>
        <pubDate>Sun, 21 Oct 2012 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to trace and debug an iOS crash (Part 1)</title>
        <link>https://qnoid.com/2012/10/20/How-to-trace-and-debug-an-iOS-crash-part-1.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2012/10/20/How-to-trace-and-debug-an-iOS-crash-part-1.html</guid>
        <description><![CDATA[<h2 id="there-has-been-a-crash">There has been a crash</h2>
<p>While preparing for an iOS release, observed a crash on an iPad (iOS 4.3.3, WiFi).
The crash was fairly consistent to be considered random but once in a while, it would work as expected. On the other hand, an iPad 3 (iOS 5.1, WiFi/3G) wouldn&rsquo;t exhibit the same behaviour.</p>
<p>The crash was triggered at the completion block of an <a href="http://afnetworking.github.com/AFNetworking/Classes/AFHTTPRequestOperation.html">AFHTTPRequestOperation</a> while parsing a (JSON) response with an <strong>empty body</strong> to a NSDictionary using <a href="https://github.com/johnezang/JSONKit">JSONKit</a>.</p>
<p>This was an unexpected behaviour since an empty body response was not defined in the request/response contract.</p>
<p><strong>FACTS</strong></p>
<pre>
1. iPad 4.3.3 WiFi
</pre>
<p><strong>EVIDENCE</strong></p>
<pre>
1.  > GET /foo HTTP/1.1  
2.  < [empty body]
</pre>
<h2 id="the-setup">The setup</h2>
<p>The iOS app in question, was pointing at an <a href="http://aws.amazon.com/elasticloadbalancing/">Amazon EC2 Load Balancer</a> which had a single <a href="http://aws.amazon.com/ec2/">EC2 instance</a> attached.</p>
<pre>
    [iPad 4.3.3 WiFi] -> [AWS Load Balancer] -> [AWS EC2 Single instance)
</pre>
<p>The request was an HTTP GET expecting a JSON response but getting one with an empty body instead.</p>
<pre>
    > GET /foo HTTP/1.1  
    < HTTP/1.1 200 OK  
    < [empty body]
</pre>
<p>The request had a constant set of headers and a content.
e.g. no user input was involved.</p>
<h2 id="elimination-game">Elimination game</h2>
<p>In a scenario where multiple factors are involved, you need to play the elimination game to find the culprit.</p>
<p>Hence, started by removing the load balancer and see if it makes any difference. Effectively the iOS app was now sending requests directly to the EC2 instance.</p>
<pre>
    [iPad 4.3.3 WiFi] -> [AWS EC2 Single instance]
</pre>
<p>As a result the crash would no longer manifest.</p>
<pre>
    > GET /foo HTTP/1.1  
    < [JSON]  
</pre>
<p><strong>FACTS</strong></p>
<pre>
1. iPad 4.3.3 WiFi  
2. AWS Load Balancer
</pre>
<p>At this point, you need to work backwards.</p>
<p><strong>QUESTION</strong>: Under what circumstances would the load balancer return an empty body?</p>
<p>The question does not really have a straightforward answer. A hint was given by <a href="http://www.twitter.com/goldstein">@goldstein</a> that maybe multiple instances are attached to the load balancer with one of them sending the bogus response. This however didn&rsquo;t seem to be the case. At least as shown by the <a href="http://aws.amazon.com/console/">AWS Console</a>.</p>
<p>To verify this assumption, used <a href="http://www.linuxmanpages.com/man8/traceroute.8.php">traceroute</a>. Traceroute will report if multiple addresses are assigned to a given host.</p>
<pre>
    traceroute [AWS Load Balancer]  
	Warning: [AWS Load Balancer] has multiple addresses;
</pre>
<p>Executing traceroute for a couple of times, will give you all the different ips. In this case they were two (2), one of which was the known EC2 instance.</p>
<p><strong>QUESTION</strong>: Why would the load balancer report 2 ips attached if only 1 is assigned according to the AWS console?</p>
<p>Even weirder was that the second ip reported wasn&rsquo;t anywhere to be found under the AWS console. A &ldquo;phantom&rdquo; ip.</p>
<p>Looking closer at the load balancer configuration, they were 2 availability zones defined.</p>
<pre>
    availability zone (instance = 0, healthy = NO)  
    availability zone (instance = 1, healthy = YES)
</pre>
<p>Removing the &ldquo;unhealthy&rdquo; availability zone, solved the &ldquo;multiple addresses&rdquo; issue.</p>
<p><strong>QUESTION</strong> How is that explained?</p>
<p><strong>ASSUMPTION</strong> When the [AWS EC2 Single instance] was initially created, it was assigned the reported phantom ip. At that point, it was attached to the load balancer with the given availability zone. Later on, an <a href="http://aws.amazon.com/articles/1346">elastic ip</a> was set while the instances were reduced down to one (1).</p>
<p><em>Haven&rsquo;t reproduced the above steps to verify this assumption.</em></p>
<p>Traceroute, reported both the original and elastic ip attached to the load balancer.</p>
<p>Although the load balancer was now correctly pointing to one instance, the crash wasn&rsquo;t resolved.</p>
<p><em>Kudos to <a href="http://www.twitter.com/goldstein">@goldstein</a> for his insight to AWS.</em></p>
<p><em><a href="/2012/10/21/How-to-trace-and-debug-an-iOS-crash-(Part-2).html#main">Continue to part 2</a></em></p>
]]></description>
        <pubDate>Sat, 20 Oct 2012 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Metrics of an object oriented world</title>
        <link>https://qnoid.com/2011/06/08/Metrics-of-an-object-oriented-world.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/06/08/Metrics-of-an-object-oriented-world.html</guid>
        <description><![CDATA[<script async class="speakerdeck-embed" data-id="183bacd026b1013092b722000a1d8877" data-ratio="1.72972972972973" src="//speakerdeck.com/assets/embed.js"></script>
<p>Decided to do a talk about OO; but this time wanted to provide some actual metrics to back it up.</p>
<p>Took measurements per &ldquo;iteration&rdquo;, e.g. when a new functionality is added in the code base. For each iteration counted methods and types respectively.</p>
<p>Though in the beginning adding types has some overhead, it only takes 3 iterations to achieve 83% reusability. For reusability counted the number of types reused vs the total number.</p>
<p>Would be interesting to do some more metrics and find how many iterations should take (on average) and how many types to find a true golden ratio and what that is. However it might be the case that numbers vary greatly depending on the problem domain.</p>
<p>An IDE plugin to show you how the reusability ratio increases as you add types would be a great tool to assist developers and give a new dynamic on coding.</p>
<p>Even though when starting to write code we have a higher level of understanding of the problem (iterations are not that short), usually as developers we take the procedural route and think in terms of methods. It demonstrates how complex the object oriented programming paradigm is, even though it has been around for decades.</p>
<p>Resist the urge to jump straight to code. Lay down your thoughts first using pen and paper and start thinking in terms of objects, there are benefits both in the short and long term.</p>
<p><em><a href="https://github.com/qnoid/oo-revelations">Source</a></em></p>
<p><strong>Note</strong> On the 3rd iteration there are actually 5 methods. (not 4 as depicted on the slide)</p>
<p><strong>Further Reading</strong></p>
<p><a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main">Urban Legends - O is for Object (Part 1)</a></p>
<p><a href="https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html#main">The Myth - O is for Object (Part 2)</a></p>
<p><a href="https://qnoid.com/2011/01/28/Revelations-o-is-for-object-part-3.html#main">Revelations - O is for Object (Part 3)</a></p>
<p><a href="https://qnoid.com/2011/03/07/On-reusability-part-1-misconceptions.html#main">On Reusability (Part 1) - Misconceptions</a></p>
<p><a href="https://qnoid.com/2011/03/09/On-reusability-part-2-Misconceptions.html#main">On Reusability (Part 2) - Misconceptions</a></p>
<p><a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">Don&rsquo;t Lose Your Train of Thoughts series</a></p>
<p><strong>iterations</strong></p>
<p><em>methods</em></p>
<pre><code>//1st iteration
private List&lt;String&gt; load() 
public String findByValue(String value)

//2nd iteration
public String findByReverse(String reverse)

//3rd iteration
private List&lt;Integer&gt; load() 
public Integer findByValue(Integer value)
</code></pre>
<p><em>types</em></p>
<pre><code>//1st iteration
public final class Service&lt;T&gt; 
public interface Predicate&lt;T&gt; 
public final class Implementation

//2nd iteration
public final class Evals 
public interface Eval&lt;T&gt;

//3rd iteration
public final class PredicateBuilder&lt;T&gt;
</code></pre>
]]></description>
        <pubDate>Wed, 08 Jun 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Making wordings of numbers 27 going twentyseven</title>
        <link>https://qnoid.com/2011/05/19/Making-wordings-of-numbers-27-going-twentyseven.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/05/19/Making-wordings-of-numbers-27-going-twentyseven.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Wording</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">wordings</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="nf">Wording</span><span class="p">(</span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">wordings</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">this</span><span class="p">.</span><span class="na">wordings</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">wordings</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">of</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">10</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">private</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">of</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">mod</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">if</span><span class="p">(</span><span class="n">number</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">0</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="s">&#34;&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="n">mod</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * if there is no value for a digit skip to the next mod.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * e.g.  
</span></span></span><span class="line"><span class="cl"><span class="cm">     * missing units
</span></span></span><span class="line"><span class="cl"><span class="cm">     *  120 % 10 = 0
</span></span></span><span class="line"><span class="cl"><span class="cm">     *  
</span></span></span><span class="line"><span class="cl"><span class="cm">     * missing tens
</span></span></span><span class="line"><span class="cl"><span class="cm">     *  100 % 100 = 0 //missing tens
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">if</span><span class="p">(</span><span class="n">value</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">0</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">mod</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">10</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">sb</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">StringBuilder</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">String</span><span class="w"> </span><span class="n">wording</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">wordings</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">sb</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="w"> </span><span class="n">wording</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kt">int</span><span class="w"> </span><span class="n">remaining</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">String</span><span class="w"> </span><span class="n">stringOf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">remaining</span><span class="p">,</span><span class="w"> </span><span class="n">mod</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">10</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">sb</span><span class="p">.</span><span class="na">insert</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">stringOf</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="k">return</span><span class="w"> </span><span class="n">sb</span><span class="p">.</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">WordingTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">wordings</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">new</span><span class="w"> </span><span class="n">HashMap</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">7</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;seven&#34;</span><span class="p">);</span><span class="w">                   
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">20</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;twenty&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">100</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;onehundred&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">assertOf</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">Wording</span><span class="w"> </span><span class="n">wording</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Wording</span><span class="p">(</span><span class="n">wordings</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">wording</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">number</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">stringOfSeven</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">assertOf</span><span class="p">(</span><span class="s">&#34;seven&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">7</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">stringOfTwentySeven</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">assertOf</span><span class="p">(</span><span class="s">&#34;twentyseven&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">27</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">stringOfOneHundred</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">assertOf</span><span class="p">(</span><span class="s">&#34;onehundred&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">100</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">stringOfOneHundredTwenty</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">assertOf</span><span class="p">(</span><span class="s">&#34;onehundredtwenty&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">120</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">stringOfOneHundredSeven</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">assertOf</span><span class="p">(</span><span class="s">&#34;onehundredseven&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">107</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">stringOfOneHundredTwentySeven</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">assertOf</span><span class="p">(</span><span class="s">&#34;onehundredtwentyseven&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">127</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span></span></span></code></pre></div>
<p>Just recently came across this case needing to convert a number to its wording. For example, given the number 27 produce &ldquo;twentyseven&rdquo;.</p>
<p>One way to tackle this is to dissect the number to its digits one by one, starting by the lower ones.</p>
<pre><code>(0)			2		7
(hundreds)	tens 	units
</code></pre>
<p>Using a <a href="https://qnoid.com/2011/04/07/hash-table-part-1.html#main" title="Read the series on how to think of a hashtable">lookup table</a> on units, tens, hundreds will allow us to get the wording for a single number.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">units</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashMap</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">units</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">7</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;seven&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">tens</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashMap</span><span class="o">&lt;</span><span class="n">Integer</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">tens</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">20</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;twenty&#34;</span><span class="p">);</span></span></span></code></pre></div>
<p>The real question then becomes, what algorithm will give us the number of the right magnitude? In other words, how can we get the units, the tens and the hundreds of a number?</p>
<p>For that we will take advantage of the mod operator with a touch of <a href="https://qnoid.com/2010/10/18/recursion.html#main" title="Read the popular post on recursion">recursion</a> to traverse the whole number.</p>
<p>First a reminder on the mod. <a href="http://en.wikipedia.org/wiki/Modular_arithmetic">Whenever you mod a number</a>, the value you get back is anywhere within the range of the modulo, starting from 0.</p>
<pre>
	27 % 10		= 	7 	(units)
	20 % 100 	= 	20 	(tens)
	0  % 1000 	=	0 	(hundreds)
</pre>
<p>With that in mind, starting from 10 as the modulo we get the value of the units, thus its wording.</p>
<p>Every time subtracting the current value from the number to be left with the next scale.</p>
<pre>
	27 - 7 = 20
</pre>
<p>and modding again with the next modulo</p>
<pre>
	mod * 10
</pre>
<p>until we get a 0 as the number, which is the stop condition.</p>
<p>What about numbers that are missing digits like 100 which will give a 0 as soon as we mod them? Well, there are a couple of ways to go about it.</p>
<ul>
<li>Add a lookup value of an empty string to 0. This although works, breaks the semantics of the lookup.</li>
<li>Check for a null and use an empty string instead. In this case you will have the overhead of allocating the StringBuilder and that of the append.</li>
<li>Skip to the next mod.</li>
</ul>
<p>There is however a serious limitation to the above. How do you go on about numbers between 11 (&ldquo;eleven&rdquo; and not &ldquo;tenone&rdquo;) through 19? What about the number 0?</p>
<p><strong>Developers challenge:</strong> Implement the above in your preferred language while also coming up with an answer to the above limitation. The first one to write a solution and a test that proves it, gets a postcard from Edinburgh.</p>
<p>How would you improve the algorithm to produce better wordings? Do you have another algorithm to share for figuring out the wording of a number?</p>
<p><em>As always, you can find the <a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tDJb">source code</a> of the post over at github.</em></p>
<p><strong>Kudos</strong> to @nelstrom, the person behind <a href="http://vimcasts.org/">Vimcasts.org</a>. Drew recently visitted Egypt and was pleased to find out that <a href="http://twitter.com/#!/nelstrom/status/14627578702725121">numbers are read left to right</a> as opposed to arabic script and figuring out their wording.</p>
]]></description>
        <pubDate>Thu, 19 May 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to think of... a hash table (Part 3)</title>
        <link>https://qnoid.com/2011/05/11/hash-table-part-3.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/05/11/hash-table-part-3.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The well known hash table, now with rehashing support
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">HashTable</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">BucketList</span><span class="w"> </span><span class="n">bucketList</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">HashTable</span><span class="p">(</span><span class="n">BucketList</span><span class="w"> </span><span class="n">buckets</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">rehash</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">BucketList</span><span class="p">.</span><span class="na">newBucketList</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * If we run out of buckets let&#39;s make some more 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">ensureAvailableBuckets</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">isLoaded</span><span class="p">())</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">rehash</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">ensureAvailableBuckets</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">bucketOf</span><span class="p">(</span><span class="n">key</span><span class="p">);</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A bucket list as you can tell has a hash function
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">BucketList</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">HashFunction</span><span class="w"> </span><span class="n">hashFunction</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Value</span><span class="o">[]</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">count</span><span class="p">;</span><span class="w">  </span><span class="c1">//keeping track of values added to know the load factor</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">BucketList</span><span class="p">(</span><span class="n">Value</span><span class="o">[]</span><span class="w"> </span><span class="n">buckets</span><span class="p">,</span><span class="w"> </span><span class="n">HashFunction</span><span class="w"> </span><span class="n">hashFunction</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">hashFunction</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">hashFunction</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">float</span><span class="w"> </span><span class="nf">load</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">count</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">size</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="nf">bucketOf</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">hashFunction</span><span class="p">.</span><span class="na">indexOf</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoaded</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">hashFunction</span><span class="p">.</span><span class="na">isLoaded</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">load</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="nf">size</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="p">.</span><span class="na">length</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Value</span><span class="w"> </span><span class="n">current</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Value</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="n">current</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">count</span><span class="o">++</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>The hashtable indeed <a href="https://qnoid.com/2011/04/07/hash-table-part-2.html#main" title="Read all about collision handling, in Part 2">works as expected</a>.
We do have a key to retrieve a value, we do handle conflicts when putting one under the same index.</p>
<p>However, in a hashtable there is more than just looking up values based on keys.
Take a look at the first bucket.</p>
<pre><code>0 &gt; [0, 3, 6, 9]
</code></pre>
<p>Given the fixed size of the hashtable imagine what would happen if we were to store only values with keys that came up with an index of 0.</p>
<pre><code>0 &gt; [0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30 ...]
</code></pre>
<p>The bucket would grow so large that every time we would have to iterate through the whole list to find the value for the given key. Also the remaining 2 buckets would go to waste.</p>
<p>Unless you have a collection of values that you need to store with predefined keys so that you can come up with the <a href="http://en.wikipedia.org/wiki/Hash_table#Perfect_hash_function" title="Remember how in part one the hashtable needed to figure out which index to use given the key? In hashtable terms this is called a hash function!">perfect hash function</a> that distributes them evenly, you need to think of a way to grow your bucket list and at the same time recalculate the index for each value, what is known as <strong>rehashing</strong>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A hash function is a bucket list&#39;s close friend 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">HashFunction</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">indexOf</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">bucketSize</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoaded</span><span class="p">(</span><span class="kt">float</span><span class="w"> </span><span class="n">load</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">newSize</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>The reason you need to calculate the index again for each value when rehashing is because every time you <a href="https://qnoid.com/2011/04/07/hash-table-part-1.html#main" title="Refresh your memory on how a hashtable works">get and put</a> a value given the key, the hashtable needs to figure out the index based on its size, which after resizing, has changed. Therefore it will come up with a different answer as to where the value is.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/* initial size of 3 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">6</span><span class="p">,</span><span class="w"> </span><span class="n">6</span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="c1">//6 % 3 = 0</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/* after resizing to 5 */</span><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">6</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="o">//</span><span class="n">6</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="n">5</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span></span></span></code></pre></div>
<p>As you can tell, rehashing can be quite expensive since not only there is a need to iterate through every value in the hashtable but also recalculate every index.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">BucketList</span><span class="w"> </span><span class="nf">newBucketList</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="p">,</span><span class="w"> </span><span class="n">HashFunction</span><span class="w"> </span><span class="n">hashFunction</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">BucketList</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Value</span><span class="o">[</span><span class="n">size</span><span class="o">]</span><span class="p">,</span><span class="w"> </span><span class="n">hashFunction</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">BucketList</span><span class="w"> </span><span class="nf">newBucketList</span><span class="p">(</span><span class="n">BucketList</span><span class="w"> </span><span class="n">bucketList</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kt">int</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">bucketList</span><span class="p">.</span><span class="na">hashFunction</span><span class="p">.</span><span class="na">newSize</span><span class="p">(</span><span class="w"> </span><span class="n">bucketList</span><span class="p">.</span><span class="na">size</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">BucketList</span><span class="w"> </span><span class="n">newBucketList</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="n">newBucketList</span><span class="p">(</span><span class="n">size</span><span class="p">,</span><span class="w"> </span><span class="n">bucketList</span><span class="p">.</span><span class="na">hashFunction</span><span class="p">);</span><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Value</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">bucketList</span><span class="p">.</span><span class="na">buckets</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="k">while</span><span class="p">(</span><span class="n">value</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newBucketList</span><span class="p">.</span><span class="na">bucketOf</span><span class="p">(</span><span class="n">value</span><span class="p">.</span><span class="na">key</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="n">newBucketList</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">key</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">next</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="p">}</span><span class="w">				
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="n">newBucketList</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>What you get in return though is spreading the values across all the buckets, which was the problem that lead to all this.</p>
<p>The question then becomes <strong>when is the right time to rehash</strong>? The most obvious answer would be when there is one value in every bucket and no buckets are left. There is however something that is called a <a href="http://en.wikipedia.org/wiki/Hash_table#Load_factor">load factor</a> which shows <em>how full</em> your hashtable is. The load factor is simply the ratio between the number of values and the hashtable size.</p>
<p>In the next part we&rsquo;ll see how the size of a hash table has an affect on rehashing, given a &ldquo;bad collection&rdquo; of keys.</p>
]]></description>
        <pubDate>Wed, 11 May 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to think of... a hash table (Part 2)</title>
        <link>https://qnoid.com/2011/04/07/hash-table-part-2.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/04/07/hash-table-part-2.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">HashTable</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">BucketList</span><span class="w"> </span><span class="n">bucketList</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">HashTable</span><span class="p">(</span><span class="n">BucketList</span><span class="w"> </span><span class="n">buckets</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">bucketOf</span><span class="p">(</span><span class="n">key</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="n">key</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">bucketOf</span><span class="p">(</span><span class="n">key</span><span class="p">);</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">bucketList</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Buckets for all
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">BucketList</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Value</span><span class="o">[]</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">BucketList</span><span class="p">(</span><span class="n">Value</span><span class="o">[]</span><span class="w"> </span><span class="n">buckets</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">buckets</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="nf">bucketOf</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="p">.</span><span class="na">length</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Searches the bucket in the specified index for the value of the given key
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param index the bucket that holds the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param key the key of the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the value in the bucket that has the specified key or -1
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see #bucketOf(int)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Value</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="p">;</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">next</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">if</span><span class="p">(</span><span class="n">value</span><span class="p">.</span><span class="na">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Stores the value for the given key to the specified bucket.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * If an existing value is already present, store it next to the one 
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param index the index of the bucket
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param key the key of the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Value</span><span class="w"> </span><span class="n">current</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Value</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="n">current</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><em><a href="https://qnoid.com/2011/04/07/hash-table-part-1.html#main">Start at the beginning with Part 1</a></em></p>
<p>Let&rsquo;s take a step back for a minute and take a look at the array.</p>
<pre><code>[0, 1, 2]
</code></pre>
<p>Imagine that each value in the array represents a &ldquo;bucket&rdquo;. That is a collection of values (rather than a single one). So each time you put a value in that bucket, it grows.</p>
<pre><code> 9 
 6	7  
 3	4  5
 0  1  2
 ^  ^  ^
[0, 1, 2] //bucket index
</code></pre>
<p>Rotating the view 90 degrees to the right will reveal that each bucket really is just an array</p>
<pre><code>0 &gt; [0, 3, 6, 9]
1 &gt; [1, 4, 7]
2 &gt; [2, 5]
</code></pre>
<p>This will allow us to store more than one value under the same index. Notice how 0 and 3 are both under index 0. Calculating the index of the bucket is not enough any more when querying for the value since there is the possibility of getting more than one.</p>
<p>That is why we need <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main" title="What is a class?">a class</a> to hold the value as well as the actual key associated with it.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * In each bucket basically is a linked list
</span></span></span><span class="line"><span class="cl"><span class="cm">	 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">class</span> <span class="nc">Value</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">private</span><span class="w"> </span><span class="n">Value</span><span class="w"> </span><span class="n">next</span><span class="p">;</span><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p><a href="http://en.wikipedia.org/wiki/Linked_list" title="The principal benefit of a linked list over a conventional array is that the list elements can easily be added">Having a reference to the next value</a> in the bucket will allow us to grow and iterate the array without the overhead of maintaining it.</p>
<p>So given the index and the key, we find the bucket and then iterate until we match the key to get the value. Remember that each key is really unique.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Value</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="p">;</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">next</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="k">if</span><span class="p">(</span><span class="n">value</span><span class="p">.</span><span class="na">key</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">key</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="p">.</span><span class="na">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>In that sense in every put as well as creating a new Value with the key and value we need to assign the current one as the next in the list.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">Value</span><span class="w"> </span><span class="n">current</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">this</span><span class="p">.</span><span class="na">buckets</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Value</span><span class="p">(</span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="n">current</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>That all works great but our hash table is of fixed and very small length. We need to deal with the fact that our <a href="https://qnoid.com/2011/05/11/hash-table-part-3.html#main">buckets will grow longer</a> and longer in time.</p>
]]></description>
        <pubDate>Thu, 07 Apr 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How to think of... a hash table (Part 1)</title>
        <link>https://qnoid.com/2011/04/07/hash-table-part-1.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/04/07/hash-table-part-1.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * For now, think of a hash table as something like that 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">HashTable</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Retrieves the value from the hash table given the key
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param key the key used to put the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the associated value as specified in {@link #put(int, int)}
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Stores the specified value under the given key.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Any value stored previously on the same key is overriden.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param key the key to associate the value with
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>The <a href="http://en.wikipedia.org/wiki/Hash_table">hash table</a> seems to be the dominator of data structures as it is being used to solve a variety of <a href="http://en.wikipedia.org/wiki/Computer_science">CompSci</a> problems such as caching. On a day to day basis we can use it when there is a need to <a href="https://qnoid.com/2011/01/11/encapsulation.html#main" title="Don't abuse the if series">make a choice</a> or to operate on a <a href="http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html">Set</a> (though hidden). Now, rarely there is a need to implement a hash table from scratch but having a deep understanding of <strong>how a hash table works</strong> can greatly <strong>help us make the most out of it</strong> when the time comes.</p>
<p>The basic idea is that you have an array to store values. Given that an array has an index that you can use to store and retrieve a value, it all works.</p>
<pre><code>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<p>What happens though if you want to use your <strong>own key</strong> that you can query on?
So you have a hashtable of size 3 and you want to <strong>put</strong> the value of 0 under the key 0.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="n">HashTable</span><span class="w"> </span><span class="n">hashtable</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashTable</span><span class="p">(</span><span class="n">3</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span></span></span></code></pre></div>
<p>Now given that the underlying structure is an array, <strong>the hashtable needs to figure out which index to use</strong> in the array to put the value in. Since the array is of size 3 the possible indexes are 0 to 2.</p>
<pre><code>[0, 1, 2]
|---3---|
</code></pre>
<p>A simple way to get a number within that range is to mod the key with the length of the hashtable. So in this case</p>
<pre><code>0 % 3 = 0 // key  % length = index
</code></pre>
<p>So the hashtable uses index 0 to store the value.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">size</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">this</span><span class="p">.</span><span class="na">values</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>The next time you ask for the value stored under the key 0</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">0</span><span class="p">);</span></span></span></code></pre></div>
<p>the hashtable calculates the index again and gives you the value stored</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">key</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">key</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">size</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">values</span><span class="o">[</span><span class="n">index</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>It all works great until you have a key which gives you the same index.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span><span class="w"> </span><span class="c1">// 0 % 3 = 0</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="n">hashtable</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">3</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">);</span><span class="w"> </span><span class="o">//</span><span class="w"> </span><span class="n">3</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="n">3</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">0</span></span></span></code></pre></div>
<p>That&rsquo;s when you have a <strong>collision</strong> which <a href="https://qnoid.com/2011/04/07/hash-table-part-2.html#main">you need to deal with</a>.</p>
]]></description>
        <pubDate>Thu, 07 Apr 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How To Think Of... Binary Search</title>
        <link>https://qnoid.com/2011/03/31/binary-search.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/03/31/binary-search.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Divide and conquer
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">BinarySearch</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Let&#39;s start looking from the beginning of the array 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 0 till the last index which is length - 1.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * e.g. an array of size 10 has positions from 0 to 9.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">indexOf</span><span class="p">(</span><span class="kt">int</span><span class="o">[]</span><span class="w"> </span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">what</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">indexOf</span><span class="p">(</span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="n">what</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">numbers</span><span class="p">.</span><span class="na">length</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">indexOf</span><span class="p">(</span><span class="kt">int</span><span class="o">[]</span><span class="w"> </span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">what</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">fromIndex</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">toIndex</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">fromIndex</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">toIndex</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="o">-</span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Let&#39;s take the average by shifting bytes.
</span></span></span><span class="line"><span class="cl"><span class="cm">             * How does that work?
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * For indexes of 0 to 9 we have 9 &gt;&gt;&gt; 1
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 9 in binary is 1001, therefore
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 1001 &gt;&gt;&gt; 1 = 0100
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * which is equal to 4
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Notice how we are moving each bit 1 position to the right.
</span></span></span><span class="line"><span class="cl"><span class="cm">             * So 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 1 becomes 0
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 0 becomes 1
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 0 becomes 0
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 1 falls off and becomes 0
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">average</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">fromIndex</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">toIndex</span><span class="p">)</span><span class="w"> </span><span class="o">&gt;&gt;&gt;</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">guess</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">numbers</span><span class="o">[</span><span class="n">average</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">guess</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">what</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">average</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">what</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">guess</span><span class="o">?</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">indexOf</span><span class="p">(</span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="n">what</span><span class="p">,</span><span class="w"> </span><span class="n">fromIndex</span><span class="p">,</span><span class="w"> </span><span class="n">average</span><span class="o">-</span><span class="n">1</span><span class="p">):</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">indexOf</span><span class="p">(</span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="n">what</span><span class="p">,</span><span class="w"> </span><span class="n">average</span><span class="o">+</span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">toIndex</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s assert that it works
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">BinarySearchTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">assertIndexOf</span><span class="p">(</span><span class="kt">int</span><span class="o">[]</span><span class="w"> </span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">what</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">index</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">BinarySearch</span><span class="w"> </span><span class="n">search</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">BinarySearch</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">indexOf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">search</span><span class="p">.</span><span class="na">indexOf</span><span class="p">(</span><span class="n">numbers</span><span class="p">,</span><span class="w"> </span><span class="n">what</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">index</span><span class="p">,</span><span class="w"> </span><span class="n">indexOf</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Makes the following asserts
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;ul&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns -1 on an empty array&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns the index on an odd elements array&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns the index on an even elements array&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns the index on an odd elements array with a direct hit&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns the index on an odd elements array after 1 division&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns the index on an even elements array after 1 division&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns the index on an even elements array after 2 divisions&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt; returns -1 on a non empty array -ithout the element&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;/ul&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">indexOf</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{},</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="o">-</span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">},</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">},</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">},</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">},</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">},</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">},</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">},</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">},</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">},</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">},</span><span class="w"> </span><span class="n">3</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">assertIndexOf</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">,</span><span class="w"> </span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">5</span><span class="p">,</span><span class="w"> </span><span class="n">6</span><span class="p">,</span><span class="w"> </span><span class="n">7</span><span class="p">,</span><span class="w"> </span><span class="n">8</span><span class="p">,</span><span class="w"> </span><span class="n">9</span><span class="p">},</span><span class="w"> </span><span class="n">10</span><span class="p">,</span><span class="w"> </span><span class="o">-</span><span class="n">1</span><span class="p">);</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Seems like <a href="http://en.wikipedia.org/wiki/Algorithm">algorithms</a> and <a href="http://en.wikipedia.org/wiki/Data_structure">data structures</a> are a weak point for many. Some data structures are used extensively in our day to day code (like an <a href="http://en.wikipedia.org/wiki/Array_data_structure">array</a> or a <a href="https://qnoid.com/2011/04/07/hash-table-part-1.html#main" title="How to think of... a hash table">hashtable</a>) while algorithms usually remain <a href="http://download.oracle.com/javase/6/docs/api/java/util/Arrays.html#binarySearch(int%5B%5D,%20int)">hidden under the hood</a>. In any case we rarely come any closer than that and although that&rsquo;s usually not the problem, <a href="http://forrst.com/posts/Interviewing_with_Google_Part_1-gN4">Google</a>, <a href="http://blog.mattgoyer.com/technical-interview-at-amazon-sde-and-microsoft-program-manager/">Microsoft and Amazon</a> interviews rely heavily on them.</p>
<p>Through these posts we&rsquo;ll try to explore some of them, understand them and hopefully learn something valuable in the process than just memorising them.</p>
<p>Starting with <a href="http://en.wikipedia.org/wiki/Binary_search_algorithm">Binary Search</a>. As the name implies binary search is an algorithm for finding an element. In order to use the binary search we need to have an array of elements.</p>
<p>There is however a pre-condition associated with the array. <strong><a href="http://en.wikipedia.org/wiki/Sorting_algorithm">It needs to be sorted</a></strong>. Let&rsquo;s see why by taking an array with numbers starting from 0 to 9.</p>
<pre><code>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
</code></pre>
<p><strong>Pick a number</strong> (Let&rsquo;s say 5 but keep it secret for now).</p>
<p>Is it 4? (<a href="http://en.wikipedia.org/wiki/Logical_shift" title="logical right shift operator">the average of 0 + 9 is ~4</a>)</p>
<pre><code>[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
             ^
</code></pre>
<p>No.</p>
<p><strong>Is it lower</strong> than 4?
No.</p>
<p>Since it&rsquo;s higher than 4 let&rsquo;s look between <strong>5</strong> and 9 this time.</p>
<p>Is it 7? (the average of 5 + 9 is 7)</p>
<pre><code>[5, 6, 7, 8, 9]
       ^
</code></pre>
<p>No.</p>
<p><strong>Is it lower</strong> than 7?
Yes.</p>
<p>Since it&rsquo;s lower than 7, let&rsquo;s look between 5 and <strong>6</strong> this time.</p>
<p>Is it 6? (the average of 5 + 6 is ~6)</p>
<pre><code>[5, 6]
    ^
</code></pre>
<p>No.</p>
<p><strong>Is it lower</strong> than 6?
Yes</p>
<p>Since it&rsquo;s lower than 6, let&rsquo;s look between 5 and <strong>&hellip;5</strong> this time.</p>
<pre><code>[5]
 ^
</code></pre>
<p>Is it 5? (the average of 5 + 5 is 5)</p>
<p>Yes.</p>
<p>Notice how given an index to start from and an index to end we always take the average to look for the number. That effectively reduces the numbers to look for by a factor of 2 every time.</p>
<p>Also notice how every time that we don&rsquo;t find the number we reduce the range to look for.</p>
<ul>
<li>If the number is lower that the one we guessed we look from the start till the average minus 1.</li>
<li>If it&rsquo;s higher we add 1 to the average and look till the end index.</li>
</ul>
<p>What&rsquo;s missing is when to stop looking for the number. If you follow the pattern you will notice that at some point the index to start looking from will be be greater than the end index. That&rsquo;s when you stop.</p>
<p>So you might ask yourself. In an OO language like Java how useful is that? After all <a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main">it is objects</a> that we are dealing with. For that reason there is the <a href="http://download.oracle.com/javase/6/docs/api/java/lang/Comparable.html">Comparable</a> interface that you need to <a href="http://download.oracle.com/javase/6/docs/api/java/lang/Comparable.html#compareTo(T)">implement with a single method</a> that returns an int. It&rsquo;s up to you to decide whether an object ranks lower or higher than an equivalent.</p>
<p><strong>Note:</strong> Do you know that <a href="http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=5045582">Java has a bug</a> up until version 5.0 when it comes to calculating the average?</p>
<blockquote>
<p>&ldquo;Can&rsquo;t even compute average of two ints&rdquo; is pretty embarrassing.</p>
</blockquote>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tOxr">Source</a></em></p>
<h2 id="related">Related</h2>
<ul>
<li><a href="http://jvm.today/2017/02/javas-binary-search-madness.html">Java&rsquo;s Binary Search Madness</a></li>
</ul>
]]></description>
        <pubDate>Thu, 31 Mar 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How To Think Of... Macros</title>
        <link>https://qnoid.com/2011/03/14/macros.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/03/14/macros.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Emulates a method as described in the {@link Robot} which can
</span></span></span><span class="line"><span class="cl"><span class="cm">     * be executed.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Any arguments to the method are encapsulated by the implementation.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">RobotMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Execute the method on the robot
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param robot the robot to execute the method on
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">execute</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * All available {@link RobotMethod}s
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">RobotMethods</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">LogMethod</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">RobotMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">message</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="nf">LogMethod</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">message</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">message</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">message</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">execute</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">robot</span><span class="p">.</span><span class="na">log</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">message</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AlertMethod</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">RobotMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">execute</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">robot</span><span class="p">.</span><span class="na">alert</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">MoveMethod</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">RobotMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="nf">MoveMethod</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">x</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">execute</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">robot</span><span class="p">.</span><span class="na">move</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">x</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">y</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">RobotMethod</span><span class="w"> </span><span class="nf">newMove</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MoveMethod</span><span class="p">(</span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">x</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">RobotMethod</span><span class="w"> </span><span class="nf">newAlert</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">AlertMethod</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">RobotMethod</span><span class="w"> </span><span class="nf">newMessage</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">message</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">LogMethod</span><span class="p">(</span><span class="n">message</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Tracks all the methods executed in a {@link Robot}
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Bug</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Robot</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">RobotMethod</span><span class="o">&gt;</span><span class="w"> </span><span class="n">history</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Lists</span><span class="p">.</span><span class="na">newArrayList</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param robot the robot to track
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Bug</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">robot</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">robot</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">alert</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">robot</span><span class="p">.</span><span class="na">alert</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">history</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">RobotMethods</span><span class="p">.</span><span class="na">newAlert</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">log</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">message</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">robot</span><span class="p">.</span><span class="na">log</span><span class="p">(</span><span class="n">message</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">history</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">RobotMethods</span><span class="p">.</span><span class="na">newMessage</span><span class="p">(</span><span class="n">message</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">move</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">robot</span><span class="p">.</span><span class="na">move</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">history</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">RobotMethods</span><span class="p">.</span><span class="na">newMove</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Executes all the methods in the same order as were called
</span></span></span><span class="line"><span class="cl"><span class="cm">         * on this robot
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param robot the robot to execute all methods on
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">playbackOn</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">RobotMethod</span><span class="w"> </span><span class="n">method</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">history</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">method</span><span class="p">.</span><span class="na">execute</span><span class="p">(</span><span class="n">robot</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s track some robots
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">BugTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">RobotTracker</span><span class="w"> </span><span class="n">robotTracker</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">RobotTracker</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">RobotFactory</span><span class="w"> </span><span class="n">robotFactory</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">RobotFactory</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">robotTracker</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">playbackOn</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">message</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;Hello&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Robot</span><span class="w"> </span><span class="n">buggedRobot</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">robotFactory</span><span class="p">.</span><span class="na">newRobot</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">buggedRobot</span><span class="p">.</span><span class="na">alert</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">buggedRobot</span><span class="p">.</span><span class="na">log</span><span class="p">(</span><span class="n">message</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">buggedRobot</span><span class="p">.</span><span class="na">move</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Bug</span><span class="w"> </span><span class="n">bug</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">robotTracker</span><span class="p">.</span><span class="na">latestBug</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">RobotImpl</span><span class="w"> </span><span class="n">mimic</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">RobotImpl</span><span class="p">();</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">bug</span><span class="p">.</span><span class="na">playbackOn</span><span class="p">(</span><span class="n">mimic</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">message</span><span class="p">,</span><span class="w"> </span><span class="n">mimic</span><span class="p">.</span><span class="na">log</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">mimic</span><span class="p">.</span><span class="na">x</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">mimic</span><span class="p">.</span><span class="na">y</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Imagine that you are a spy and have been assigned the task to infiltrate a robot factory to plant a tracking device which will allow you to place a bug in every robot
produced by the factory and record every action it makes. That bug can then be used to replicate all the actions the robot made on another identical robot.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s infiltrate the factory
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">RobotFactory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">RobotTracker</span><span class="w"> </span><span class="n">robotTracker</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">RobotFactory</span><span class="p">(</span><span class="n">RobotTracker</span><span class="w"> </span><span class="n">robotTracker</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">robotTracker</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">robotTracker</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Robot</span><span class="w"> </span><span class="nf">newRobot</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">RobotImpl</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/* bug will be placed and go unnoticed  */</span><span class="w">         
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">robotTracker</span><span class="p">.</span><span class="na">wasCreated</span><span class="p">(</span><span class="n">robot</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>The Robot is described as follows</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Robot</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">alert</span><span class="p">();</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">log</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">message</span><span class="p">);</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">move</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>There are a couple of things that need to be taken care off.
First is how can you tell when a robot alerts, logs or moves? In other words, <strong>how do you trace a method call</strong>? <a href="http://en.wikipedia.org/wiki/Reflection_(computer_science)" title="There is also reflection">The simplest way</a> is to use <a href="https://qnoid.com/2011/01/16/inheritance.html#main" title="Composition is also a simple and powerful way to extend">composition</a>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Bug</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Robot</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">       * @param robot the robot to track
</span></span></span><span class="line"><span class="cl"><span class="cm">       */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="nf">Bug</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          </span><span class="k">this</span><span class="p">.</span><span class="na">robot</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">robot</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">alert</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">           * Alert was just called!
</span></span></span><span class="line"><span class="cl"><span class="cm">           */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          </span><span class="k">this</span><span class="p">.</span><span class="na">robot</span><span class="p">.</span><span class="na">alert</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="cm">/* cont.d */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Notice how the Bug class must implement the Robot interface so that it can perform the same actions as the robot. (It also helps go unnoticed)
The second challenge is <strong>how do you &ldquo;save&rdquo; a method call</strong> when a method is <a href="https://qnoid.com/2011/03/07/On-reusability-part-1-misconceptions.html#main" title="A common misconception">not a first class citizen</a>?</p>
<p>For that we need an <a href="https://qnoid.com/2010/09/13/Can-an-Abstract-Class-and-an-Interface-play-nice-together.html#main" title="What's the difference with an abstract class?">interface</a> to describe a method that executes on a Robot</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">RobotMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">execute</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>The reason there is a need for an interface is that each implementation differs on which method it calls on the Robot yet we want to treat them all the same when executed on a robot.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">playbackOn</span><span class="p">(</span><span class="n">Robot</span><span class="w"> </span><span class="n">robot</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">RobotMethod</span><span class="w"> </span><span class="n">method</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">history</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">method</span><span class="p">.</span><span class="na">execute</span><span class="p">(</span><span class="n">robot</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Notice how the implementation of the <em>RobotMethod</em> also keeps the parameters needed to execute a specific method.</p>
<p>Finally use a simple List to keep track of all the methods executed in order simply by adding them to the list.</p>
<h2 id="in-summary">In summary</h2>
<ul>
<li>create a class that implements the same interface as your Robot</li>
<li>have a reference to the actual robot</li>
<li>delegate each method call to the robot</li>
<li>on every method call create a new instance from the class describing the method that was executed</li>
<li>add that instance to the list</li>
</ul>
<h2 id="challenge">Challenge</h2>
<p>Calling developers to write a post showing an implementation on another language (ruby/javascript)</p>
<p><em>The principle of the <a href="http://en.wikipedia.org/wiki/Command_pattern">command pattern</a> can be used to implement an undo/redo feature but you also need to think of any <a href="https://qnoid.com/2011/01/19/state-machine.html#main" title="An introduction to the state machine">state changes</a></em></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/ttrj">Source</a></em></p>
]]></description>
        <pubDate>Mon, 14 Mar 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>On reusability (Part 2) ...Misconceptions</title>
        <link>https://qnoid.com/2011/03/09/On-reusability-part-2-Misconceptions.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/03/09/On-reusability-part-2-Misconceptions.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * An interface defining a single method you want to reuse
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">MathOperation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * All available operators
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">MathOperations</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * In an OO world an Object is a first class citizen.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * To have an object you need a class
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Multiplication</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">MathOperation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="nf">Multiplication</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">multiplier</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Addition</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">MathOperation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">amount</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="nf">Addition</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">amount</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">amount</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">amount</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">amount</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Reusable! operations  
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">MathOperation</span><span class="w"> </span><span class="n">MULTIPLY_BY_2</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">Multiplication</span><span class="p">(</span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">MathOperation</span><span class="w"> </span><span class="n">MULTIPLY_BY_PI</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">Multiplication</span><span class="p">(</span><span class="n">Math</span><span class="p">.</span><span class="na">PI</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">Addition</span><span class="w"> </span><span class="nf">addition</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">amount</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Addition</span><span class="p">(</span><span class="n">amount</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">MathOperation</span><span class="w"> </span><span class="nf">multiplication</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Multiplication</span><span class="p">(</span><span class="n">multiplier</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * All available formulas for your perusal
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Formulas</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Formula</span><span class="w"> </span><span class="n">AREA_OF_CIRCLE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Formula</span><span class="p">.</span><span class="na">newFormula</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">MULTIPLY_BY_2</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">MULTIPLY_BY_PI</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Describes a list of operations
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Formula</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Create a new formula which applies the operators in the order
</span></span></span><span class="line"><span class="cl"><span class="cm">         * specified
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param operators the operators to apply in sequence
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new formula for the spcified operators
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see MathOperations
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Formula</span><span class="w"> </span><span class="nf">newFormula</span><span class="p">(</span><span class="n">MathOperation</span><span class="p">...</span><span class="w"> </span><span class="n">operators</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Formula</span><span class="p">(</span><span class="w"> </span><span class="n">Lists</span><span class="p">.</span><span class="na">newArrayList</span><span class="p">(</span><span class="n">operators</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">MathOperation</span><span class="o">&gt;</span><span class="w"> </span><span class="n">operations</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">Formula</span><span class="p">(</span><span class="n">List</span><span class="o">&lt;</span><span class="n">MathOperation</span><span class="o">&gt;</span><span class="w"> </span><span class="n">operators</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">operations</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operators</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">apply</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">MathOperation</span><span class="w"> </span><span class="n">operation</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">operations</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operation</span><span class="p">.</span><span class="na">op</span><span class="p">(</span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Code that is fun to use
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FormulaTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">areaOfCircle</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">double</span><span class="w"> </span><span class="n">r</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">2</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">Math</span><span class="p">.</span><span class="na">PI</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Formulas</span><span class="p">.</span><span class="na">AREA_OF_CIRCLE</span><span class="p">.</span><span class="na">apply</span><span class="p">(</span><span class="n">r</span><span class="p">));</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">formula</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">9</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Formula</span><span class="w"> </span><span class="n">formula</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Formula</span><span class="p">.</span><span class="na">newFormula</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">addition</span><span class="p">(</span><span class="n">1</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">multiplication</span><span class="p">(</span><span class="n">n</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">division</span><span class="p">(</span><span class="n">2</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">45</span><span class="p">.</span><span class="na">0</span><span class="p">,</span><span class="w"> </span><span class="n">formula</span><span class="p">.</span><span class="na">apply</span><span class="p">(</span><span class="n">n</span><span class="p">));</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">areaOfTriangle</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">base</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">10</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">height</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">10</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Formula</span><span class="w"> </span><span class="n">areaOfTriangle</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Formula</span><span class="p">.</span><span class="na">newFormula</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">multiplication</span><span class="p">(</span><span class="n">height</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">MathOperations</span><span class="p">.</span><span class="na">division</span><span class="p">(</span><span class="n">2</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">50</span><span class="p">.</span><span class="na">0</span><span class="p">,</span><span class="w"> </span><span class="n">areaOfTriangle</span><span class="p">.</span><span class="na">apply</span><span class="p">(</span><span class="n">base</span><span class="p">));</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><a href="https://qnoid.com/2011/03/07/On-reusability-part-1-misconceptions.html#main">Methods aren&rsquo;t reusable</a>. Objects are.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">MathOperation</span><span class="w"> </span><span class="n">MULTIPLY_BY_2</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">new</span><span class="w"> </span><span class="n">Multiplication</span><span class="p">(</span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">MathOperation</span><span class="w"> </span><span class="n">MULTIPLY_BY_PI</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">new</span><span class="w"> </span><span class="n">Multiplication</span><span class="p">(</span><span class="n">Math</span><span class="p">.</span><span class="na">PI</span><span class="p">);</span></span></span></code></pre></div>
<p>Notice how</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">multiplyBy</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>turned into a class</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Multiplication</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Multiplication</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">multiplier</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">multiply</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>At first <a href="https://qnoid.com/2011/02/23/Why-cant-programmers-design-software.html#main" title="How a FizzBuzz design created a mayhem">you might gasp</a> that a single method has turned into a class. <a href="http://misko.hevery.com/about/" title="Misko works as an Agile Coach at Google where he is responsible for coaching Googlers to maintain the high level of automated testing culture">Misko Hevery</a> actually has <a href="http://misko.hevery.com/2010/04/07/move-over-java-i-have-fallen-in-love-with-javascript/">something
to say about this</a></p>
<blockquote>
<p>Recently I got an email from someone pointing out that doing proper Single Responsibility Principle, often resulted in classes which had exactly one method. Odd? Well, actually, it is a function in disguise.</p>
</blockquote>
<p>There isn&rsquo;t such a thing as a class that does too little. If there is a reason for a class to exist it will manifest in your code whether you choose to ignore it or not. Worse it won&rsquo;t stay hidden but will plague the design of the rest of your code.</p>
<p>Classes not only aid in your design but also sed light on the problem domain you are currently trying to solve. They allow you to see further. If you don&rsquo;t have classes, you can&rsquo;t think of relationships.</p>
<p>Adding methods, whether <a href="http://forrst.com/posts/Parse_a_date_with_a_variable_format_Following-7ev#comment-104855">static</a> or not, keep your code from evolving. They are not extensible since you need to
add a new one every time and don&rsquo;t allow your code to be treated uniformly creating unnecessary complexity which could have been avoided otherwise.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">MathOperation</span><span class="w"> </span><span class="n">operation</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">operations</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operation</span><span class="p">.</span><span class="na">op</span><span class="p">(</span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span></span></span></code></pre></div>
<p>So the next time you are tempted to add a new method, stop. <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main" title="A series on how to think in OO - Don't lose your train of thoughts">Think</a> whether it really makes sense or is a mere illusion to feed your <a href="http://en.wikipedia.org/wiki/Appetite_for_Destruction" title="Love Guns N' Roses as I was born in the 80s">appetite</a> for code.</p>
<p><em>Notice how you can easily introduce more Operations effectively extending Formula through <a href="https://qnoid.com/2011/01/16/inheritance.html#main">composition</a></em></p>
<p><strong>Disclaimer</strong>
This might look like a trivial example that rarely applies in a real life scenario. In my experience this is not the case. Think of bytes and sockets, sql and jdbc connections, <a href="https://qnoid.com/2011/02/10/Take-a-step-back.-Take-a-deep-breath.-Take-pen-and-paper.html#main">queries and services</a>, http requests and clients, messages and message dispatchers.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tt1q">Source</a></em></p>
]]></description>
        <pubDate>Wed, 09 Mar 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>On reusability (Part 1) ...Misconceptions</title>
        <link>https://qnoid.com/2011/03/07/On-reusability-part-1-misconceptions.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/03/07/On-reusability-part-1-misconceptions.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * This isn&#39;t OO
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Numbers</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double multiplyBy1(double number)
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double multiplyBy10(double number)    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double multiplyBy100(double number)    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double multiplyBy1000(double number)
</span></span></span><span class="line"><span class="cl"><span class="cm">        */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">multiplyBy</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double add1(double number)
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double add10(double number)    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double add100(double number)    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public static double add1000(double number)    
</span></span></span><span class="line"><span class="cl"><span class="cm">        */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">value</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Naive identification of a class
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Number</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Number</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double multiplyBy1()
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double multiplyBy10()    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double multiplyBy100()    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double multiplyBy1000()
</span></span></span><span class="line"><span class="cl"><span class="cm">        */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">multiplyBy</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">multiplier</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double add1()
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double add10()    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double add100()    
</span></span></span><span class="line"><span class="cl"><span class="cm">        public double add1000()    
</span></span></span><span class="line"><span class="cl"><span class="cm">        */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">value</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * This is the result of failing to identify a class in {@link Numbers} 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * that models a math operation thus having to handle different types of
</span></span></span><span class="line"><span class="cl"><span class="cm">     * formulas.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AbusingTheIfFormula</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">AREA_OF_CIRCLE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">AREA_OF_TRIANGLE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">3</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">base</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * On which type does it make sense?
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">AbusingTheIfFormula</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">base</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">0</span><span class="p">.</span><span class="na">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param base only related to a specific type
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">AbusingTheIfFormula</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">base</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">base</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">base</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * You are forced to abuse the if now
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">type</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">AREA_OF_CIRCLE</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">type</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">Math</span><span class="p">.</span><span class="na">PI</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">AREA_OF_TRIANGLE</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">type</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">if</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">base</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="n">0</span><span class="p">.</span><span class="na">0</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">base</span><span class="p">,</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">N</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">type</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kt">double</span><span class="w"> </span><span class="n">original</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">original</span><span class="p">,</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnsupportedOperationException</span><span class="p">(</span><span class="s">&#34;Uknown type: &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Trying to come up with a way out of this mess
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * An interface is forced to handle different kinds of formulas since 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * we failed to identify an Operation class from {@link Numbers} 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * that we can actually reuse.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Formula</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Is it really about different formula implementations? Unfortunately since 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * there isn&#39;t an &lt;b&gt;operation class&lt;/b&gt; to have a relationship with a 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * formula one, the only way is to implement different classes for different 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * formulas. Naively &#34;reusing&#34; {@link Numbers#multiplyBy(double, double)} 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * affecting any class related to it while still losing on actual reusability of
</span></span></span><span class="line"><span class="cl"><span class="cm">     * operations. 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Formulas</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AreaOfCircleFormula</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Formula</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">radius</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kt">double</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">radius</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="n">Math</span><span class="p">.</span><span class="na">PI</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AreaOfTriangleFormula</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Formula</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="n">height</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="nf">AreaOfTriangleFormula</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">height</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">height</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">height</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">base</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kt">double</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">base</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">height</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">NFormula</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Formula</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">double</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">double</span><span class="w"> </span><span class="n">n</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kt">double</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Numbers</span><span class="p">.</span><span class="na">multiplyBy</span><span class="p">(</span><span class="n">value</span><span class="p">,</span><span class="w"> </span><span class="n">n</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><em>Or why extracting a method is overrated and abused</em></p>
<p>One of the most frequent [eureka][7] moments we get as developers when writing code is when finding a method to extract in order to reuse it.</p>
<p><strong>In an OO world</strong> however there is only as much gain since you can only use that method within that class. The <em>problem</em> resides in that a function is not a <a href="http://en.wikipedia.org/wiki/First-class_function" title="this means that the language supports passing functions as arguments to other functions, returning them as the values of other functions, and storing them in data structures">first class</a> citizen.</p>
<p>Simply put, you need to carry the class that defines that method in every place you want to use it. This is easier said than done though depending on how you&rsquo;ve <a href="https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html#main">designed your class</a>. Especially if you&rsquo;ve assigned more than [1 responsibilities][8] to it.</p>
<p>So what you end up doing &ldquo;at best&rdquo; is introduce a <a href="http://en.wikipedia.org/wiki/Method_(computer_programming)#Static_methods">static method</a>, at worst copy and paste. There is a real issue here though and that is <strong>failing to identify a class that has manifest in your code</strong> leading to an explosion of methods.</p>
<p>This not only makes your API hard to use but also forces you to <strong>write more, sometimes even complicated</strong> code. Solely on the fact that <strong>in an OO world</strong> you have the concept of <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">class relationships</a> which is equally important to <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">the class</a>.</p>
<p>When you see procedural code, you only think procedural. So next time you start coding, look for the class!</p>
<p><a href="https://qnoid.com/2011/03/09/On-reusability-part-2-Misconceptions.html#main">Try it with your code</a> to see what objects you come up with and how a correctly identified class simplifies things.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/ttXT">Source</a></em></p>
<p>[7]: <a href="http://en.wikipedia.org/wiki/Eureka_(word)">http://en.wikipedia.org/wiki/Eureka_(word)</a> &ldquo;This exclamation is most famously attributed to the ancient Greek scholar Archimedes; he reportedly proclaimed &ldquo;Eureka!&rdquo; when he stepped into a bath and noticed that the water level rose — he suddenly understood that the volume of water displaced must be equal to the volume of the part of his body he had submerged.&rdquo;
[8]: <a href="http://en.wikipedia.org/wiki/Single_responsibility_principle">http://en.wikipedia.org/wiki/Single_responsibility_principle</a> &ldquo;The single responsibility principle states that every object should have a single responsibility, and that responsibility should be entirely encapsulated by the class&rdquo;</p>
]]></description>
        <pubDate>Mon, 07 Mar 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Why can&#39;t programmers... design software?</title>
        <link>https://qnoid.com/2011/02/23/Why-cant-programmers-design-software.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/02/23/Why-cant-programmers-design-software.html</guid>
        <description><![CDATA[<blockquote>
<p>There is a followup to this post. <a href="https://qnoid.com/2013/12/20/We-need-to-talk-about-fizzbuzz.html#main">We need to talk about FizzBuzz</a>.</p>
</blockquote>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Use to convert numbers to fizz/buzz representations
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FizzBuzzOperator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">FizzBuzzStrategy</span><span class="w"> </span><span class="n">fizzbuzzStrategy</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param fizzbuzzStrategy the strategy to use to find the 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * {@link FizzBuzzOperation}
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">FizzBuzzOperator</span><span class="p">(</span><span class="n">FizzBuzzStrategy</span><span class="w"> </span><span class="n">fizzbuzzStrategy</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">fizzbuzzStrategy</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">fizzbuzzStrategy</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Returns the fizz/buzz representation of the given number
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param number the number to use
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">fizzbuzzStrategy</span><span class="p">.</span><span class="na">fizzBuzzOf</span><span class="p">(</span><span class="n">number</span><span class="p">).</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>First time I found out about FizzBuzz was when I came across Jeff Atwood&rsquo;s blog post <em><a href="http://www.codinghorror.com/blog/2007/02/why-cant-programmers-program.html">Why Can&rsquo;t Programmers.. Program?</a></em>.
As you would expect (since CodingHorror draws a lot of developers) answers begun to spur on how you can go on implementing it.
On a closer look however you will notice that most (if not all) of those answers are on the basis of a switch/if statement and then
try to apply the most obscure &ldquo;optimisation&rdquo; to come up with fewer lines and less characters failling to see the real issue. [Disclaimer]</p>
<p>What if I told you that the answer to the FizzBuzz algorithm is only one line of code <em>without any if</em> and it looks like that</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">op</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">fizzBuzzOf</span><span class="p">(</span><span class="n">number</span><span class="p">).</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><a href="https://qnoid.com/2011/02/20/software-design.html#main">Not surprisingly</a> it starts out with a single interface</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">FizzBuzzOperation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">applies</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>With 3 enums</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">ModFizzBuzz</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">FizzBuzzOperation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">FizzBuzz</span><span class="p">(</span><span class="n">15</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">Buzz</span><span class="p">(</span><span class="n">5</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">Fizz</span><span class="p">(</span><span class="n">3</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">mod</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">  
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="nf">ModFizzBuzz</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">mod</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">      </span><span class="k">this</span><span class="p">.</span><span class="na">mod</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">mod</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">applies</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">%</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">mod</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>And that&rsquo;s all. Really.
What&rsquo;s left out is <a href="https://qnoid.com/2011/01/16/inheritance.html#main">what strategy</a> you need to use to find the corresponding FizzBuzzOperation. So here is one:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">FizzBuzzStrategy</span><span class="w"> </span><span class="n">DEFAULT</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">FizzBuzzStrategy</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">ModFizzBuzz</span><span class="o">&gt;</span><span class="w"> </span><span class="n">fizzbuzzes</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Lists</span><span class="p">.</span><span class="na">newArrayList</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">ModFizzBuzz</span><span class="p">.</span><span class="na">FizzBuzz</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">ModFizzBuzz</span><span class="p">.</span><span class="na">Buzz</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">ModFizzBuzz</span><span class="p">.</span><span class="na">Fizz</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">FizzBuzzOperation</span><span class="w"> </span><span class="nf">fizzBuzzOf</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">FizzBuzzOperation</span><span class="w"> </span><span class="n">fizzbuzz</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">fizzbuzzes</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">if</span><span class="p">(</span><span class="n">fizzbuzz</span><span class="p">.</span><span class="na">applies</span><span class="p">(</span><span class="n">number</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">return</span><span class="w"> </span><span class="n">fizzbuzz</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Default FizzBuzzOperation - if none applies - 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * returns the number as a String
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">FizzBuzzOperation</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">applies</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">valueOf</span><span class="p">(</span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">  
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">};</span></span></span></code></pre></div>
<p><strong>So here a new challenge. Find the most efficient FizzBuzzStrategy and get a postcard from Edinburgh</strong> as well as a budge(1) on truly mastering FizzBuzz.</p>
<p>Here is the interface you need to implement</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Implementations should provide an algorithm to find a 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * {@link FizzBuzzOperation} for a number
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">FizzBuzzStrategy</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">         </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Given a number we need to find the corresponding 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * {@link FizzBuzzOperation}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param number an arbitary number
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the {@link FizzBuzzOperation} to apply
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">FizzBuzzOperation</span><span class="w"> </span><span class="nf">fizzBuzzOf</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><em>As with every software engineering problem you don&rsquo;t really see the big picture if you are always in &ldquo;low level&rdquo; code. Another reason why you need to <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">think in terms of objects</a></em></p>
<p><em>Note: There is also a &ldquo;<a href="http://forrst.com/posts/FizzBuzz-R33">FizzBuzz</a>&rdquo; post that can be used to post solutions in the forrst started by @acrookston which got my attention and decided to write this post</em></p>
<p><strong>Disclaimer</strong>: Jeff was really trying to make a point about writing an algorithm not doing software design, which is a <a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html">personal view</a>.</p>
<p><em>1:</em> Wish there was a way to award budges @kyle</p>
<p><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tgOg"><em>Source</em></a></p>
]]></description>
        <pubDate>Wed, 23 Feb 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>It&#39;s about software design - IASD</title>
        <link>https://qnoid.com/2011/02/20/software-design.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/02/20/software-design.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/* 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * IASD (It&#39;s about software design)
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FilterTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">findByName</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">john</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">20</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">markos</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;Markos&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">30</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">isNamedJohn</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Conditions</span><span class="p">.</span><span class="na">hasName</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">actual</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Filters</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">john</span><span class="p">,</span><span class="w"> </span><span class="n">markos</span><span class="p">).</span><span class="na">find</span><span class="p">(</span><span class="w"> </span><span class="n">isNamedJohn</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">john</span><span class="p">,</span><span class="w"> </span><span class="n">actual</span><span class="p">);</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">findByAge</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">john</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">20</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">markos</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;Markos&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">30</span><span class="p">);</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">between17and25</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">IntegerConditionChain</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">gt</span><span class="p">(</span><span class="n">17</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">lt</span><span class="p">(</span><span class="n">25</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">agedBetween17and25</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Conditions</span><span class="p">.</span><span class="na">age</span><span class="p">(</span><span class="w"> </span><span class="n">between17and25</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">actual</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Filters</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">john</span><span class="p">,</span><span class="w"> </span><span class="n">markos</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">find</span><span class="p">(</span><span class="w"> </span><span class="n">agedBetween17and25</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">john</span><span class="p">,</span><span class="w"> </span><span class="n">actual</span><span class="p">);</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">findByNameAndAge</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">johnAged20</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">20</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">johnAged21</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">21</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">johnAged29</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">29</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">johnAged30</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">30</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">markosAged30</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="s">&#34;Markos&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">29</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">between20and30</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">IntegerConditionChain</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">gt</span><span class="p">(</span><span class="n">20</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">lt</span><span class="p">(</span><span class="n">30</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">namedJohnBetween20And30</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">PersonConditionChain</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">hasName</span><span class="p">(</span><span class="s">&#34;John&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">age</span><span class="p">(</span><span class="n">between20and30</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">actual</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Filters</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">johnAged20</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">johnAged21</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">johnAged29</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">johnAged30</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">markosAged30</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">list</span><span class="p">(</span><span class="w"> </span><span class="n">namedJohnBetween20And30</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">actual</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Lists</span><span class="p">.</span><span class="na">newArrayList</span><span class="p">(</span><span class="n">johnAged21</span><span class="p">,</span><span class="w"> </span><span class="n">johnAged29</span><span class="p">),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">actual</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Find it amazing how a single method interface can be the inspiration to a good software design.</p>
<p>Here is the culprit.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Condition</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">apply</span><span class="p">(</span><span class="n">T</span><span class="w"> </span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>The idea is that you can apply a condition to any type and see if it adheres to that.</p>
<p>Notice how the usage of generics elevates the design. Using an Object instead would have made the
code vulnerable to ClassCastException and fragile to piece together with other classes. An
interface instead would force client code to implement it, pose a limit on the conditions you can
apply and is rather stiff.</p>
<p>Then came the Filter allowing you to extract the types that satisfy the conditions of yours.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Filter</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">find</span><span class="p">(</span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">condition</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">list</span><span class="p">(</span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">condition</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>Then the requirement to apply a list of Conditions.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">ConditionChain</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">apply</span><span class="p">(</span><span class="n">T</span><span class="w"> </span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">ConditionChain</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">addCondition</span><span class="p">(</span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">condition</span><span class="p">);</span><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>Without differentiating from the Condition interface thus being able to accomodate for it in the
existing API.</p>
<p>With implementations providing public methods to specific conditions that make sense on the type</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">IntegerConditionChain</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">ConditionChain</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">IntegerConditionChain</span><span class="w"> </span><span class="nf">gt</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">that</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="k">this</span><span class="p">.</span><span class="na">addCondition</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">apply</span><span class="p">(</span><span class="n">Integer</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">that</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="p">});</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">IntegerConditionChain</span><span class="w"> </span><span class="nf">lt</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">that</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="k">this</span><span class="p">.</span><span class="na">addCondition</span><span class="p">(</span><span class="k">new</span><span class="w"> </span><span class="n">Condition</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">apply</span><span class="p">(</span><span class="n">Integer</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">that</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">				</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="p">});</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>It&rsquo;s your turn now to <a href="http://en.wikipedia.org/wiki/Don't_repeat_yourself">DRY</a> the design by introducing a class that encapsulates the implementation
of the methods related to the ConditionChain thus increasing <a href="http://en.wikipedia.org/wiki/Cohesion_(computer_science)">cohesion</a> and lowering <a href="http://en.wikipedia.org/wiki/Coupling_(computer_programming)">coupling</a>
for creating specific conditions <a href="https://qnoid.com/2011/01/16/inheritance.html#main">without abusing inheritance</a>.</p>
<p><strong>While doing so you get to win a postcard from Edinburgh.</strong></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tgyO">Source</a></em></p>
]]></description>
        <pubDate>Sun, 20 Feb 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Take a step back. Take a deep breath. Take pen and paper</title>
        <link>https://qnoid.com/2011/02/10/Take-a-step-back.-Take-a-deep-breath.-Take-pen-and-paper.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/02/10/Take-a-step-back.-Take-a-deep-breath.-Take-pen-and-paper.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CRUDServiceImpl</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">CRUDService</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">PersistenceManager</span><span class="w"> </span><span class="n">pm</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">CRUDServiceImpl</span><span class="p">(</span><span class="n">PersistenceManager</span><span class="w"> </span><span class="n">pm</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">pm</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pm</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">store</span><span class="p">(</span><span class="n">T</span><span class="w"> </span><span class="n">model</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">pm</span><span class="p">.</span><span class="na">makePersistent</span><span class="p">(</span><span class="n">model</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">list</span><span class="p">(</span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">queryStrategy</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Query</span><span class="w"> </span><span class="n">query</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pm</span><span class="p">.</span><span class="na">newQuery</span><span class="p">(</span><span class="n">queryStrategy</span><span class="p">.</span><span class="na">type</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">queryStrategy</span><span class="p">.</span><span class="na">configure</span><span class="p">(</span><span class="n">query</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Effective Java 2nd Edition, Joshua Bloch, Item 24, page 116
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@SuppressWarnings</span><span class="p">(</span><span class="s">&#34;unchecked&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">)</span><span class="n">query</span><span class="p">.</span><span class="na">executeWithArray</span><span class="p">(</span><span class="n">queryStrategy</span><span class="p">.</span><span class="na">arguments</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">result</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">unique</span><span class="p">(</span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">queryStrategy</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">list</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">list</span><span class="p">(</span><span class="n">queryStrategy</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">list</span><span class="p">.</span><span class="na">isEmpty</span><span class="p">())</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * It is a good idea to provide as much information as possible 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * to the exception. That way the client code can take action. 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ObjectNotFoundException</span><span class="p">(</span><span class="n">queryStrategy</span><span class="p">.</span><span class="na">type</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">list</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * QueryStrategies ready for consumption
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">QueryStrategies</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">GreetingStrategies</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">latestByAuthor</span><span class="p">(</span><span class="n">User</span><span class="w"> </span><span class="n">author</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">QueryConfiguration</span><span class="w"> </span><span class="n">configuration</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">new</span><span class="w"> </span><span class="n">QueryConfigurationBuilder</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">filter</span><span class="p">(</span><span class="s">&#34;author == :author&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">ordering</span><span class="p">(</span><span class="s">&#34;date desc&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">QueryStrategyBuilder</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Greeting</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">args</span><span class="p">(</span><span class="n">author</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">configuration</span><span class="p">(</span><span class="w"> </span><span class="n">configuration</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">mostRecent</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">toExl</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">QueryConfiguration</span><span class="w"> </span><span class="n">configuration</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">new</span><span class="w"> </span><span class="n">QueryConfigurationBuilder</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">filter</span><span class="p">(</span><span class="s">&#34;date desc&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">toExl</span><span class="p">(</span><span class="n">toExl</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">QueryStrategyBuilder</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Greeting</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">.</span><span class="na">configuration</span><span class="p">(</span><span class="w"> </span><span class="n">configuration</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">QueryStrategies</span><span class="p">(){}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s see how it looks from the client side
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CRUDServiceImplTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">PersistenceManager</span><span class="w"> </span><span class="n">pm</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pmf</span><span class="p">.</span><span class="na">getPersistenceManager</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">CRUDService</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="w"> </span><span class="n">service</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">CRUDServiceImpl</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="p">(</span><span class="n">pm</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">getLatestByAythor</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">User</span><span class="w"> </span><span class="n">author</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">User</span><span class="p">()</span><span class="w"> </span><span class="p">{};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="w"> </span><span class="n">queryStrategy</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">GreetingStrategies</span><span class="p">.</span><span class="na">latestByAuthor</span><span class="p">(</span><span class="n">author</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Greeting</span><span class="w"> </span><span class="n">greeting</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">service</span><span class="p">.</span><span class="na">unique</span><span class="p">(</span><span class="n">queryStrategy</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">mostRecent</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">count</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">10</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="w"> </span><span class="n">queryStrategy</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">GreetingStrategies</span><span class="p">.</span><span class="na">mostRecent</span><span class="p">(</span><span class="n">count</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Greeting</span><span class="o">&gt;</span><span class="w"> </span><span class="n">greetings</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">service</span><span class="p">.</span><span class="na">list</span><span class="p">(</span><span class="n">queryStrategy</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><em>The inspiration for this post comes from @sirsean <a href="http://forrst.com/posts/Writing_DAO_classes_for_JDO_on_Google_Appengine-4D5">&ldquo;Writing DAO classes for JDO on Google Appengine
just got easier&rdquo;</a>.</em></p>
<p>Whenever you realize you are writing too many if(s) or you somehow <a href="http://en.wikipedia.org/wiki/Don't_repeat_yourself" title="DRY">repeat yourself</a>,
you need to TTT.</p>
<ul>
<li>Take a step back</li>
<li>Take a deep breath</li>
<li>Take pen and paper</li>
</ul>
<p>But hey <a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main">I don&rsquo;t have time for that!</a>. I don&rsquo;t have to think about <a href="https://qnoid.com/2011/01/28/Revelations-o-is-for-object-part-3.html#main">extensibility, reusability,
maintenance or testing</a>. I just need <a href="https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html#main">something quick and dirty</a> this is trivial!</p>
<p>Back to code. It seems like everytime we use the <em>Query</em> instance, we
have to <strong>configure</strong> it. The problem however is that <em>Query</em> is
something we don&rsquo;t get access to until we hit that line of code</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="n">Query</span><span class="w"> </span><span class="n">query</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pm</span><span class="p">.</span><span class="na">newQuery</span><span class="p">(</span><span class="n">vhQuery</span><span class="p">.</span><span class="na">getClazz</span><span class="p">());</span></span></span></code></pre></div>
<p>which unfortunately is within that <em>BaseVHDao</em> class and specifically in the <em>BaseVHDao#list</em> method.
That leaves us with no option but to <strong>configure</strong> it right there with little room for extending or
reusing that configuration as we are limited to:</p>
<ul>
<li>Modify that method slightly (violating <a href="http://en.wikipedia.org/wiki/Open/closed_principle">Open/Closed Principle</a>)</li>
<li>Extend from BaseVHDao (abusing inheritance)</li>
<li>Create a new method by copying/pasting and changing it slightly (maintenance nightmare)</li>
<li>Create a new method which encapsulates the common code and re-use (not fun)</li>
</ul>
<p>OR use <a href="http://en.wikipedia.org/wiki/Delegation_pattern">delegation</a>.</p>
<p>There are 2 advantages of using delegation in this case.</p>
<ul>
<li>Don&rsquo;t have to expose <em>Query</em> to client code</li>
<li>It is easily extensible</li>
</ul>
<p>Since we need to support different <strong>configurations</strong> we introduce a
simple interface like</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">QueryStrategy</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">         </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">configure</span><span class="p">(</span><span class="n">Query</span><span class="w"> </span><span class="n">query</span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<blockquote>
<p><strong>Java Note:</strong> By making the QueryStrategy typed as well notice how we enforce a strong typing with the CRUDService. That way we effectively only pass valid QueryStrategy(ies)</p>
</blockquote>
<p>Now what about <em>args</em> and <em>clazz</em> that we also need to have available? Let&rsquo;s add them to that interface.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">QueryStrategy</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">configure</span><span class="p">(</span><span class="n">Query</span><span class="w"> </span><span class="n">query</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">type</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="n">Object</span><span class="o">[]</span><span class="w"> </span><span class="nf">arguments</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>That looks great. However, what started as a one method interface to configure the query ended up somewhat &ldquo;stiff&rdquo; <a href="https://qnoid.com/2011/01/16/inheritance.html#main">should we wish to extend a QueryStrategy</a> for the
same type and arguments. So let&rsquo;s add the final piece in the puzzle. (Disclaimer)</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">QueryConfiguration</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">configure</span><span class="p">(</span><span class="n">Query</span><span class="w"> </span><span class="n">query</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>In case you can&rsquo;t see the <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">relationship</a> between them, it&rsquo;s composition. Let me make it clearer.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">QueryStrategyImpl</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">QueryStrategy</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">QueryConfiguration</span><span class="w"> </span><span class="n">configuration</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">configure</span><span class="p">(</span><span class="n">Query</span><span class="w"> </span><span class="n">query</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">			</span><span class="k">this</span><span class="p">.</span><span class="na">configuration</span><span class="p">.</span><span class="na">configure</span><span class="p">(</span><span class="n">query</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t4NG">Source</a></em></p>
<p><strong>Disclaimer</strong> In this example it&rsquo;s not that big of a deal but it&rsquo;s good to keep an eye for things that might change and draw your lines early. The good thing is that even if you don&rsquo;t add the extra interface right now, your API is designed to accept that change without affecting the client and with minimal refactoring cost.</p>
<p><strong><a href="https://qnoid.com/2011/02/02/The-beauty-of-software-design-Designers-Challenge.html#main">If you are a designer here is a challenge to win a postcard from Edinburgh</a></strong></p>
]]></description>
        <pubDate>Thu, 10 Feb 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How To Think Of... Aspects</title>
        <link>https://qnoid.com/2011/02/03/aspects.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/02/03/aspects.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AspectSets</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Create a new Set which is strong on duplicates 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param &lt;E&gt; the type of the {@link Set}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param elements the elements to create the set from
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new Set which is only keen on holding added 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * elements more than once.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Set</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newSetOnDuplicates</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">E</span><span class="o">[]</span><span class="w"> </span><span class="n">elements</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">final</span><span class="w"> </span><span class="n">Aspect</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">isUnique</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Aspects</span><span class="p">.</span><span class="na">uniqueAspect</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Using a set to handle multiple duplicates
</span></span></span><span class="line"><span class="cl"><span class="cm">             * (elements that occur more than 2 times)
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashSet</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="p">(</span><span class="w"> </span><span class="n">Lists</span><span class="p">.</span><span class="na">newArrayList</span><span class="p">(</span><span class="n">elements</span><span class="p">)</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">long</span><span class="w"> </span><span class="n">serialVersionUID</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                                      </span><span class="o">-</span><span class="n">8073479479226481874L</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * Add the element only if its a duplicate
</span></span></span><span class="line"><span class="cl"><span class="cm">                 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="n">E</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">if</span><span class="p">(</span><span class="n">isDuplicate</span><span class="p">(</span><span class="n">e</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="k">return</span><span class="w"> </span><span class="kd">super</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">e</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">private</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isDuplicate</span><span class="p">(</span><span class="n">E</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="o">!</span><span class="n">isUnique</span><span class="p">.</span><span class="na">apply</span><span class="p">(</span><span class="n">e</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Aspects</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param &lt;E&gt; the type of the objects
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new Aspect on unique objects
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Aspect</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">uniqueAspect</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Aspect</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * Holding all unique elements
</span></span></span><span class="line"><span class="cl"><span class="cm">                 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Set</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">uniques</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashSet</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * @return true if element is unique
</span></span></span><span class="line"><span class="cl"><span class="cm">                 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">apply</span><span class="p">(</span><span class="n">E</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">uniques</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">e</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Survival of the fittest
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AspectSetsTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">newSetOnDuplicates</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">animals</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="s">&#34;dog&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;dog&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="s">&#34;parrot&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="s">&#34;lion&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="s">&#34;zebra&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;zebra&#34;</span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Set</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">duplicatesOnly</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">AspectSets</span><span class="p">.</span><span class="na">newSetOnDuplicates</span><span class="p">(</span><span class="n">animals</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">3</span><span class="p">,</span><span class="w"> </span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Sets</span><span class="p">.</span><span class="na">newHashSet</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="p">{</span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;dog&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;zebra&#34;</span><span class="p">}),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="n">duplicatesOnly</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="s">&#34;lion&#34;</span><span class="p">));</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Sets</span><span class="p">.</span><span class="na">newHashSet</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="p">{</span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;dog&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;zebra&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;lion&#34;</span><span class="p">}),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="n">duplicatesOnly</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="s">&#34;monkey&#34;</span><span class="p">));</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Sets</span><span class="p">.</span><span class="na">newHashSet</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="p">{</span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;dog&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;zebra&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;lion&#34;</span><span class="p">}),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="n">duplicatesOnly</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="s">&#34;monkey&#34;</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">5</span><span class="p">,</span><span class="w"> </span><span class="n">duplicatesOnly</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Sets</span><span class="p">.</span><span class="na">newHashSet</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="p">{</span><span class="s">&#34;cat&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;dog&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;zebra&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;lion&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;monkey&#34;</span><span class="p">}),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                            </span><span class="n">duplicatesOnly</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><em>As inspired by @sealabcore&rsquo;s <a href="http://forrst.com/posts/Return_only_duplicate_values_from_ruby_array-RA8">&ldquo;Return only duplicate values from ruby array.&rdquo;</a></em></p>
<p>Instead of extending from HashSet (Disclaimer)</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">DuplicatesOnlySet</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">HashSet</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Set</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">uniques</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashSet</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w">  </span><span class="nf">DuplicatesOnlySet</span><span class="p">(</span><span class="n">Collection</span><span class="o">&lt;?</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">c</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">super</span><span class="p">(</span><span class="n">c</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="n">E</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * This is getting called at the constructor 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * thus you will get a NPE since
</span></span></span><span class="line"><span class="cl"><span class="cm">             * {@link #uniques} isn&#39;t initialised yet.
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="k">this</span><span class="p">.</span><span class="na">uniques</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">e</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                 </span><span class="k">return</span><span class="w"> </span><span class="kd">super</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">e</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>and falling into the trap of a <a href="https://qnoid.com/2010/07/22/Everytime-you-write-an-init-method-a-developer-gets-an-Exception-simply-dont.html#main">NullPointerException</a>.</p>
<p>Or using composition forcing you to create delegate calls to the backing Set and making sure all necessary method calls go through your modified <em>#add(E e)</em> method, you can use the notion of <a href="http://en.wikipedia.org/wiki/Aspect-oriented_programming">aspects</a>.</p>
<p>Note that the constructor</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="nf">HashSet</span><span class="p">(</span><span class="n">Collection</span><span class="o">&lt;?</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">c</span><span class="p">)</span></span></span></code></pre></div>
<p>is actually calling the <em>#addAll(Collection&lt;? extends E&gt; c)</em> method which in return calls <em>#add(E e)</em> thus filtering the elements on construction.</p>
<p>What&rsquo;s cool is that the way its integrated, any method used to traverse the returned Set will give you the expected elements. (Note)</p>
<p>Although we haven&rsquo;t effectively changed the contract of the Set (&ldquo;A collection that contains no duplicate elements&rdquo;), its implementation certainly differs, so make sure you document that</p>
<h2 id="disclaimer">Disclaimer</h2>
<p>Technically speaking we do extend from HashSet only anonymously</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tRZe">Source</a></em></p>
]]></description>
        <pubDate>Thu, 03 Feb 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The beauty of software design - Designers Challenge</title>
        <link>https://qnoid.com/2011/02/02/The-beauty-of-software-design-Designers-Challenge.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/02/02/The-beauty-of-software-design-Designers-Challenge.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">GrindTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">grindMelons</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">noOfMelons</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Fruit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">melons</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Fruits</span><span class="p">.</span><span class="na">nFruits</span><span class="p">(</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                            </span><span class="n">noOfMelons</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                            </span><span class="n">Fruits</span><span class="p">.</span><span class="na">newFruit</span><span class="p">(</span><span class="n">Seed</span><span class="p">.</span><span class="na">MELON</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Grinder</span><span class="o">&lt;</span><span class="n">Fruit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">newGrinder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Grinders</span><span class="p">.</span><span class="na">newGrinder</span><span class="p">(</span><span class="n">melons</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Let&#39;s do some grinding
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Iterable</span><span class="o">&lt;</span><span class="n">Seed</span><span class="o">&gt;</span><span class="w"> </span><span class="n">seeds</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newGrinder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                    </span><span class="p">.</span><span class="na">grind</span><span class="p">(</span><span class="w"> </span><span class="n">Blades</span><span class="p">.</span><span class="na">FRUIT</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                    </span><span class="p">.</span><span class="na">items</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">noOfMelons</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">Seed</span><span class="p">.</span><span class="na">MELON</span><span class="p">.</span><span class="na">noOfSeeds</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Iterables</span><span class="p">.</span><span class="na">size</span><span class="p">(</span><span class="n">seeds</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">grindBoxes</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">noOfLoquats</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">10</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">noOfBoxes</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Fruit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">loquats</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Fruits</span><span class="p">.</span><span class="na">nFruits</span><span class="p">(</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                            </span><span class="n">noOfLoquats</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                            </span><span class="n">Fruits</span><span class="p">.</span><span class="na">newFruit</span><span class="p">(</span><span class="n">Seed</span><span class="p">.</span><span class="na">LOQUAT</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Box</span><span class="o">&gt;</span><span class="w"> </span><span class="n">boxes</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Boxes</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="w"> </span><span class="n">loquats</span><span class="w"> </span><span class="p">).</span><span class="na">times</span><span class="p">(</span><span class="n">noOfBoxes</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Grinder</span><span class="o">&lt;</span><span class="n">Box</span><span class="o">&gt;</span><span class="w"> </span><span class="n">newGrinder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Grinders</span><span class="p">.</span><span class="na">newGrinder</span><span class="p">(</span><span class="n">boxes</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Grinding till we get the seeds 
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Iterable</span><span class="o">&lt;</span><span class="n">Seed</span><span class="o">&gt;</span><span class="w"> </span><span class="n">seeds</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newGrinder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                    </span><span class="p">.</span><span class="na">grind</span><span class="p">(</span><span class="w"> </span><span class="n">Blades</span><span class="p">.</span><span class="na">BOX</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                    </span><span class="p">.</span><span class="na">grind</span><span class="p">(</span><span class="w"> </span><span class="n">Blades</span><span class="p">.</span><span class="na">FRUIT</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                    </span><span class="p">.</span><span class="na">items</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">noOfBoxes</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">noOfLoquats</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">Seed</span><span class="p">.</span><span class="na">LOQUAT</span><span class="p">.</span><span class="na">noOfSeeds</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Iterables</span><span class="p">.</span><span class="na">size</span><span class="p">(</span><span class="n">seeds</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>It seems that designers draw all the attention in the forrst.
Can&rsquo;t blame them, their designs are pleasant to the eyes. They show emotion. They have soul.
Code listings look really borring, lacking any enthusiasm or creativity.</p>
<p>This post won&rsquo;t bother you with principles on <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">how to think of object oriented code</a>.
It&rsquo;s about the art of <a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main">software design</a>.</p>
<p><strong>Challenging designers to come up with a design that visualises the code above and reflects its quality</strong> and win a postcard from Edinburgh.</p>
<p><strong>Calling all developers to come up with code that&rsquo;s <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">fun to use</a>, <a href="https://qnoid.com/2010/08/05/the-reason-behind-finally.html#main">tells a story</a> and elevates software design.</strong></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tRcn">Source</a></em></p>
]]></description>
        <pubDate>Wed, 02 Feb 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Urban Legends ...O Is For Object (Part 1)</title>
        <link>https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html</guid>
        <description><![CDATA[<blockquote>
<p>An urban legend, urban myth, urban tale, or contemporary legend,<br>
is a form of modern folklore consisting of stories usually believed by<br>
their tellers to be true.</p>
</blockquote>
<p>After all these years of <a href="http://en.wikipedia.org/wiki/Object-oriented_programming">Object Oriented Programming</a> being taught at universities, <a href="https://archive.org/details/TIJ4CcR1/page/n749">cou</a>-<a href="http://en.wikipedia.org/wiki/Design_Patterns_(book)">nt</a>-<a href="http://en.wikipedia.org/wiki/Robert_C._Martin">less</a> number of books written on the subject, <a href="http://en.wikipedia.org/wiki/Martin_Fowler">advocates</a>, <a href="http://www.devoxx.com/">conferences</a> et. al. you would expect that pretty much by now developers would be convinced of its merits and know to a great extend how to apply its <a href="http://www.butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod">principles</a>.</p>
<p>However this is not the case. Every now and then a discussion will spur about how it&rsquo;s OK to violate basic principles, how OO makes code difficult to understand and the main argument usually boils down to &ldquo;<a href="http://en.wikipedia.org/wiki/Overengineering">there is no need to over-engineer</a>&rdquo;. Then comes the drama. There isn&rsquo;t enough time, it costs money, there is no need to do it.</p>
<p>After all this time as developers we fail to see the facts and accept hard core evidence that <a href="http://en.wikipedia.org/wiki/Ivar_Jacobson" title="Uncle Bob">other computer scientists</a> are presenting us with. Stop pretending like it&rsquo;s a matter of &ldquo;personal taste&rdquo;. This is about <a href="http://en.wikipedia.org/wiki/Software_engineering">software engineering</a>.</p>
<blockquote>
<p>Software engineering (SE) is a profession dedicated to designing, implementing, and modifying software so that it is of higher quality, more affordable, maintainable, and faster to build. It is a &ldquo;systematic approach to the analysis, design, assessment, implementation, test, maintenance and reengineering of software, that is, the application of engineering to software.&rdquo;</p>
</blockquote>
<p>As a developer you should care and feel responsible for <a href="https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html#main">the code you are producing</a>.</p>
]]></description>
        <pubDate>Fri, 28 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The Myth ...O Is For Object (Part 2)</title>
        <link>https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The result of a myth
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">UrbanLegend</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">one</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">another</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="n">status</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">UrbanLegend</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">one</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">another</span><span class="p">,</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="p">,</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="n">status</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;ddMMyyyy&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">StringBuilder</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">status</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">one</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">another</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">another</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">one</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">dateFormat</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">date</span><span class="p">.</span><span class="na">getTime</span><span class="p">()));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">builder</span><span class="p">.</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">one</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">one</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">another</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">another</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">date</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">status</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">status</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">string</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">string</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">tell</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;dd/MM/yyyy&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">oneName</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">anotherName</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">one</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s">&#34;EDI&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">oneName</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;edinburgh&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">one</span><span class="w"> </span><span class="o">==</span><span class="s">&#34;LON&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">oneName</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;london&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">another</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s">&#34;EDI&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">anotherName</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;edinburgh&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">another</span><span class="w"> </span><span class="o">==</span><span class="s">&#34;LON&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">anotherName</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;london&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">from</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">to</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">status</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">from</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">oneName</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">to</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">anotherName</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">from</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">anotherName</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">to</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">oneName</span><span class="p">;</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">switch</span><span class="w"> </span><span class="p">(</span><span class="n">type</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">case</span><span class="w"> </span><span class="n">0</span><span class="p">:</span><span class="w">                    
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Walking down to &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">to</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="s">&#34; from &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">from</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">case</span><span class="w"> </span><span class="n">1</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Flying down to &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">to</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="s">&#34; from &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">from</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="s">&#34; in &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="s">&#34; class on &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">dateFormat</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">date</span><span class="p">.</span><span class="na">getTime</span><span class="p">()));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">if</span><span class="p">(</span><span class="n">string</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s">&#34;economy&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">return</span><span class="w"> </span><span class="n">200</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="n">string</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="s">&#34;business&#34;</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">return</span><span class="w"> </span><span class="n">500</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">default</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Exception</span><span class="p">(</span><span class="s">&#34;Invalid type &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * You have to live with it
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">UrbanLegendTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;ddMMyyyy&#34;</span><span class="p">);</span><span class="w">  
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">now</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">();</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">STRING</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;%s%s%s&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Destination</span><span class="p">.</span><span class="na">EDINBURGH</span><span class="p">.</span><span class="na">code</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Destination</span><span class="p">.</span><span class="na">LONDON</span><span class="p">.</span><span class="na">code</span><span class="p">(),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">dateFormat</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">now</span><span class="p">.</span><span class="na">getTime</span><span class="p">()));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">tell</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">boolean</span><span class="w"> </span><span class="n">status</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w"> </span><span class="c1">//making a choice!</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;business&#34;</span><span class="p">;</span><span class="w"> </span><span class="c1">//making a choice!</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">type</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w"> </span><span class="c1">//making a choice!</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">one</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;EDI&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">another</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;LON&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">UrbanLegend</span><span class="w"> </span><span class="n">myth</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UrbanLegend</span><span class="p">(</span><span class="n">one</span><span class="p">,</span><span class="w"> </span><span class="n">another</span><span class="p">,</span><span class="w"> </span><span class="n">date</span><span class="p">,</span><span class="w"> </span><span class="n">status</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">STRING</span><span class="p">,</span><span class="w"> </span><span class="n">myth</span><span class="p">.</span><span class="na">string</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">500</span><span class="p">,</span><span class="w"> </span><span class="n">myth</span><span class="p">.</span><span class="na">tell</span><span class="p">(</span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">string</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Though the code is fictional its characteristics unfortunately aren&rsquo;t. You&rsquo;ve most likely encountered code like this before plenty of times. In your code base, over at github in startups and large corporations. It has no boundaries. You most likely wrote something like this yourself in the past. Why do you keep writing it?</p>
<p>You struggle as you make an effort to understand it. Align with it as you go back and forth. Trying to digest it all at once. Don&rsquo;t blame you. This code is hard to follow. The fact that you don&rsquo;t know the problem is trying to solve doesn&rsquo;t make it any easier. Can you even tell what the <a href="http://en.wikipedia.org/wiki/Business_domain" title="Α set of classes for the problem you are trying to solve">business domain</a> is?</p>
<p>How much time did it take you to write it? Go back and read it again. Can you tell now? Again. How much time did it take you to understand it? Now go away and come back tomorrow. Read it again. Do you still remember what it does? How much time in total do you think it takes everyone reading that code to understand it? How much time will it take you to extend it? To maintain it? To test it. Can you test it? It will only get messy. You want to throw it away. How much time will it take you to write it again? How much time have you wasted?</p>
<p>Ask yourself. What&rsquo;s wrong with it? It must be something really great this code is doing. Why else would it look that horrible?</p>
<p><strong>Code doesn&rsquo;t have to look like that.</strong></p>
<p>This isn&rsquo;t about not knowing what problem is trying to solve. Nor how complicated it might be.</p>
<p>What does</p>
<pre><code>    int type = 1;
</code></pre>
<p>even mean? How is this related (if so) to</p>
<pre><code>    String string = &quot;business&quot;;
</code></pre>
<p>All you can tell is that 1 leads to</p>
<pre><code>    case 1:
        System.out.println(&quot;Flying down to &quot; + to + &quot; from &quot; + from + &quot; in &quot; + string + &quot; class on &quot; + dateFormat.format(date.getTime()));
</code></pre>
<p>You have to follow all that code down to <em>switch</em> just to find out what it means. Looking back, you knew right there when you made the choice, you don&rsquo;t need that <em>switch</em>! But there is only that much you can do with an int in an OO world.</p>
<p>Like that <em>string</em>. With a no clear cut relationship between that and the <em>type</em>. Will changing one break the other? Is it relevant? How do you enforce their relationship?</p>
<p>What about all that unrelated code that you have to move out of the way to get a clear picture of what this is all about?</p>
<p>Writing code isn&rsquo;t subjective. It&rsquo;s about <a href="https://qnoid.com/2011/01/28/Revelations-o-is-for-object-part-3.html#main">software design</a>.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/forrst/java/tRvO">Source</a></em></p>
]]></description>
        <pubDate>Fri, 28 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Revelations ...O Is For Object (Part 3)</title>
        <link>https://qnoid.com/2011/01/28/Revelations-o-is-for-object-part-3.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/28/Revelations-o-is-for-object-part-3.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * It&#39;s a revelation
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Route</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">RouteBuilder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">from</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">to</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="nf">RouteBuilder</span><span class="p">(</span><span class="n">Destination</span><span class="w"> </span><span class="n">from</span><span class="p">,</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">to</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">from</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">from</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">to</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">to</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">RouteBuilder</span><span class="w"> </span><span class="nf">onDate</span><span class="p">(</span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">date</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Route</span><span class="w"> </span><span class="nf">build</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Route</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">from</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">to</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">date</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;ddMMyyyy&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">from</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">to</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">Route</span><span class="p">(</span><span class="n">Destination</span><span class="w"> </span><span class="n">from</span><span class="p">,</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">to</span><span class="p">,</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">date</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">from</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">from</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">to</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">to</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">date</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">appendDate</span><span class="p">(</span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="n">date</span><span class="p">,</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="w"> </span><span class="n">dateFormat</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">date</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">appendCode</span><span class="p">(</span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">code</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">code</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">via</span><span class="p">(</span><span class="n">TransportMethod</span><span class="w"> </span><span class="n">method</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">method</span><span class="p">.</span><span class="na">route</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">from</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">to</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">date</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">bookingCode</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">StringBuilder</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">appendCode</span><span class="p">(</span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">from</span><span class="p">.</span><span class="na">code</span><span class="p">());</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">appendCode</span><span class="p">(</span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">to</span><span class="p">.</span><span class="na">code</span><span class="p">());</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">appendDate</span><span class="p">(</span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">date</span><span class="p">.</span><span class="na">getTime</span><span class="p">(),</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">dateFormat</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">builder</span><span class="p">.</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * And a well thought design
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">RouteTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;ddMMyyyy&#34;</span><span class="p">);</span><span class="w">  
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">now</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">();</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">BOOKING_CODE</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;%s%s%s&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Destination</span><span class="p">.</span><span class="na">EDINBURGH</span><span class="p">.</span><span class="na">code</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Destination</span><span class="p">.</span><span class="na">LONDON</span><span class="p">.</span><span class="na">code</span><span class="p">(),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">dateFormat</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">now</span><span class="p">.</span><span class="na">getTime</span><span class="p">()));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">via</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">TransportMethod</span><span class="w"> </span><span class="n">transportMethod</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">TransportMethods</span><span class="p">.</span><span class="na">BUSINESS_FLYING</span><span class="p">;</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Destination</span><span class="w"> </span><span class="n">from</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Destination</span><span class="p">.</span><span class="na">EDINBURGH</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Destination</span><span class="w"> </span><span class="n">to</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Destination</span><span class="p">.</span><span class="na">LONDON</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Route</span><span class="w"> </span><span class="n">route</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">RouteBuilder</span><span class="p">(</span><span class="n">from</span><span class="p">,</span><span class="w"> </span><span class="n">to</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">BOOKING_CODE</span><span class="p">,</span><span class="w"> </span><span class="n">route</span><span class="p">.</span><span class="na">bookingCode</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">500</span><span class="p">,</span><span class="w"> </span><span class="n">route</span><span class="p">.</span><span class="na">via</span><span class="p">(</span><span class="n">transportMethod</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><a href="https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main">This isn&rsquo;t about time, money or need</a>. This is about <a href="http://en.wikipedia.org/wiki/Software_design">software design</a></p>
<p>The code above isn&rsquo;t &ldquo;better&rdquo; because it&rsquo;s eloquent. Nor because it adheres to <a href="http://en.wikipedia.org/wiki/Solid_(object-oriented_design)">SOLID</a> principles. It&rsquo;s because it uses the most basic concept in OO. The Object.</p>
<p>It didn&rsquo;t derive thinking about <a href="http://en.wikipedia.org/wiki/Extensibility">extensibility</a>, <a href="http://en.wikipedia.org/wiki/Reusability">reusability</a>, <a href="http://en.wikipedia.org/wiki/Software_maintenance">maintenance</a> or <a href="http://en.wikipedia.org/wiki/Software_testing">testing</a>. It wasn&rsquo;t conceived after a long architectural design discussion. This is OO at its purest form.</p>
<p>Don&rsquo;t ignore it. Embrace it. It&rsquo;s liberating.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tRPu">Source</a></em></p>
]]></description>
        <pubDate>Fri, 28 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>The constructor ...Don&#39;t abuse the constructor</title>
        <link>https://qnoid.com/2011/01/22/constructor.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/22/constructor.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/** 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Don&#39;t abuse the constructor
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Person</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Person</span><span class="p">(</span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">args</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">args</span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Integer</span><span class="p">.</span><span class="na">parseInt</span><span class="p">(</span><span class="w"> </span><span class="n">args</span><span class="o">[</span><span class="n">1</span><span class="o">]</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Person</span><span class="p">(</span><span class="kt">byte</span><span class="o">[]</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">dob</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">UnsupportedEncodingException</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="p">(</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;UTF-8&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Years</span><span class="p">.</span><span class="na">yearsBetween</span><span class="p">(</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DateTime</span><span class="p">(</span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">()),</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DateTime</span><span class="p">(</span><span class="n">dob</span><span class="p">)).</span><span class="na">getYears</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * How do you test that without getting in the constructor mess? 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isOlderThan</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">howOldAreYou</span><span class="p">()</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">age</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">howOldAreYou</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">age</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">whatsYourName</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * It&#39;s a pain to test!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PersonTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">newPersonOfArray</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;Markos&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">30</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">args</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">valueOf</span><span class="p">(</span><span class="n">age</span><span class="p">)};</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">person</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="n">args</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">age</span><span class="p">,</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">howOldAreYou</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">whatsYourName</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">newPersonOfByteArrayAndCalendar</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">byte</span><span class="o">[]</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="kt">byte</span><span class="o">[]</span><span class="p">{</span><span class="sc">&#39;I&#39;</span><span class="p">,</span><span class="w"> </span><span class="sc">&#39;n&#39;</span><span class="p">,</span><span class="w"> </span><span class="sc">&#39;f&#39;</span><span class="p">,</span><span class="w"> </span><span class="sc">&#39;a&#39;</span><span class="p">,</span><span class="w"> </span><span class="sc">&#39;n&#39;</span><span class="p">,</span><span class="w"> </span><span class="sc">&#39;t&#39;</span><span class="p">};</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Calendar</span><span class="w"> </span><span class="n">dob</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">person</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">dob</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">howOldAreYou</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="s">&#34;Infant&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">whatsYourName</span><span class="p">());</span><span class="w">              
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Nice and clean
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Person</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Person</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">age</span><span class="p">;</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isOlderThan</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">howOldAreYou</span><span class="p">()</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="n">age</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">howOldAreYou</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">age</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">whatsYourName</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">   
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Persons</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">Person</span><span class="w"> </span><span class="nf">valueOf</span><span class="p">(</span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">args</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">args</span><span class="o">[</span><span class="n">0</span><span class="o">]</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Integer</span><span class="p">.</span><span class="na">parseInt</span><span class="p">(</span><span class="w"> </span><span class="n">args</span><span class="o">[</span><span class="n">1</span><span class="o">]</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">age</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">Person</span><span class="w"> </span><span class="nf">valueOf</span><span class="p">(</span><span class="kt">byte</span><span class="o">[]</span><span class="w"> </span><span class="n">itsName</span><span class="p">,</span><span class="w"> </span><span class="n">Calendar</span><span class="w"> </span><span class="n">dob</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">UnsupportedEncodingException</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">String</span><span class="p">(</span><span class="n">itsName</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;UTF-8&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">age</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Years</span><span class="p">.</span><span class="na">yearsBetween</span><span class="p">(</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DateTime</span><span class="p">(</span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">()),</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DateTime</span><span class="p">(</span><span class="n">dob</span><span class="p">)).</span><span class="na">getYears</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">age</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Smooth and clean testing!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PersonTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">howOldAreYou</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Person</span><span class="w"> </span><span class="n">person</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Person</span><span class="p">(</span><span class="kc">null</span><span class="p">,</span><span class="w"> </span><span class="n">30</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">isOlderThan</span><span class="p">(</span><span class="n">29</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">isOlderThan</span><span class="p">(</span><span class="n">30</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> </span><span class="n">person</span><span class="p">.</span><span class="na">isOlderThan</span><span class="p">(</span><span class="n">31</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>It&rsquo;s a common misconception that since constructors are there to construct an object it&rsquo;s only resonable to have related code also there. You should do well to keep your constructors for assignments and nothing more. Depending on the amount of &ldquo;work&rdquo; done in a constructor you&rsquo;ll either <a href="http://forrst.com/posts/Everytime_you_-rite_an_init_method_a_developer_g-ePJ#comment-94254">end up wasting resources when you shouldn&rsquo;t or deal with some nasty bugs</a> while also <a href="http://misko.hevery.com/code-reviewers-guide/flaw-constructor-does-real-work/">making testing
much harder</a>.</p>
<p>In this example although a Person is defined by its name and age a String array is passed in instead. Indeed this might well be what you have (through a main method or an input field) and might think that saves you from having to convert it every time you want a Person but think again.</p>
<p>All you really need to construct a Person is a name (String) and an age (int). So even if you do have those, you still need to convert them to a String array only to have the constructor convert them back. That means knowing how the array is constructed, (name at index 0, age at index 1) which is an irrelevant and possible fragile invariant to have on the Person.</p>
<p>In the same manner you force unrelated dependencies (Calendar?) leading to <a href="http://en.wikipedia.org/wiki/Coupling_(computer_programming)">high coupling</a>, making your code harder to understand (how&rsquo;s a byte array related to a Person?) and sacrificing <a href="http://download.oracle.com/javase/tutorial/java/IandI/super.html">constructor chaining</a>. You also risk exposing that burden to any classes related to Person. Especially subclasses which don&rsquo;t have a choice but to accept those constructors.</p>
<p>In most cases all you need is some <a href="https://qnoid.com/2010/10/11/factory-type-dont-lose-your-train-of-thoughts.html#main">factory</a> methods that do the conversions for you. That way you&rsquo;ve effectively seperated conversion and construction and kept your class clean. Depending on how complicated the conversion is you may realise you need a new class altogether, like a <a href="http://en.wikipedia.org/wiki/Parsing">parser</a>.</p>
<p>On stackoverlow there is a great answer in case things get really out of hand and you start throwing <a href="http://stackoverflow.com/questions/1371369/about-constructors-in-java">exceptions from the constructor</a>.</p>
<h2 id="kudos">Kudos</h2>
<p><a href="http://en.wikipedia.org/wiki/Joel_Spolsky">Joel Spolsky</a> and <a href="http://en.wikipedia.org/wiki/Jeff_Atwood">Jeff Atwood</a> for their contributtion of StackOverflow.<br>
<a href="http://joda-time.sourceforge.net/">Yoda Time</a> for an excellent replacement to the abysmal date API.</p>
<p><em>PS. When creating a String from a byte array make sure <strong>you always specify the encoding</strong>!</em></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/tRm1">Source</a></em></p>
]]></description>
        <pubDate>Sat, 22 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>State Machine ...Don&#39;t Abuse The If</title>
        <link>https://qnoid.com/2011/01/19/state-machine.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/19/state-machine.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Abusing if like there is no tomorrow
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">User</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">REGISTERING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;registering user &#39;%s&#39;&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">NOT_REGISTERED</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;user &#39;%s&#39; not registered&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">ALREADY_REGISTERED</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;User %s already registered&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">ALREADY_LOGGED_IN</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;User %s already logged in&#34;</span><span class="p">;</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Notice how your class is filled with non-final fields making it harder to
</span></span></span><span class="line"><span class="cl"><span class="cm">         * debug, make it thread-safe and extend.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="n">registered</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="n">loggedIn</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param username
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">User</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">username</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">username</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">registered</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">loggedIn</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">void</span><span class="w"> </span><span class="nf">nowRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">registered</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">void</span><span class="w"> </span><span class="nf">nowLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">loggedIn</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">register</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">isRegistered</span><span class="p">()){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">IllegalStateException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">ALREADY_REGISTERED</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">REGISTERING</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">nowRegistered</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">login</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">isLoggedIn</span><span class="p">()){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">IllegalStateException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">ALREADY_LOGGED_IN</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="k">this</span><span class="p">.</span><span class="na">isRegistered</span><span class="p">()){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnregisteredUserException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">NOT_REGISTERED</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;&#39;%s&#39; logged in&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">nowLoggedIn</span><span class="p">();</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">registered</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">loggedIn</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Define your states
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">UserState</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">UNREGISTERED</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">REGISTERED</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">LOGGED_IN</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Common interface for your User and its states
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">User</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">register</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">login</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isRegistered</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoggedIn</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * User can only register
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">class</span> <span class="nc">Unregistered</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">User</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">REGISTERING</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;registering user &#39;%s&#39;&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">NOT_REGISTERED</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;user &#39;%s&#39; not registered&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Unregistered</span><span class="p">(</span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">register</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">REGISTERING</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">.</span><span class="na">nowRegistered</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">login</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnregisteredUserException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">NOT_REGISTERED</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * User can only login
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">class</span> <span class="nc">Registered</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">User</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">ALREADY_REGISTERED</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;User %s already registered&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Registered</span><span class="p">(</span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">register</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">IllegalStateException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">ALREADY_REGISTERED</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">login</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;&#39;%s&#39; logged in&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">.</span><span class="na">nowLoggedIn</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * User cannot login or register
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">class</span> <span class="nc">LoggedIn</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">User</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">ALREADY_REGISTERED</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;User %s already registered&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">ALREADY_LOGGED_IN</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;User %s already logged in&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">LoggedIn</span><span class="p">(</span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">register</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">IllegalStateException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">ALREADY_REGISTERED</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">login</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">IllegalStateException</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">ALREADY_LOGGED_IN</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">user</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A user implemented as a state machine
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TheUser</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">User</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TheUserBuilder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="nf">TheUserBuilder</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">username</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">username</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @return a new unregistered user
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">TheUser</span><span class="w"> </span><span class="nf">build</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">TheUser</span><span class="w"> </span><span class="n">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">TheUser</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">username</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">User</span><span class="w"> </span><span class="n">unregistered</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Unregistered</span><span class="p">(</span><span class="n">user</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">User</span><span class="w"> </span><span class="n">registered</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Registered</span><span class="p">(</span><span class="n">user</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">User</span><span class="w"> </span><span class="n">loggedin</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">LoggedIn</span><span class="p">(</span><span class="n">user</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">user</span><span class="p">.</span><span class="na">addState</span><span class="p">(</span><span class="n">UserState</span><span class="p">.</span><span class="na">UNREGISTERED</span><span class="p">,</span><span class="w"> </span><span class="n">unregistered</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">user</span><span class="p">.</span><span class="na">addState</span><span class="p">(</span><span class="n">UserState</span><span class="p">.</span><span class="na">REGISTERED</span><span class="p">,</span><span class="w"> </span><span class="n">registered</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">user</span><span class="p">.</span><span class="na">addState</span><span class="p">(</span><span class="n">UserState</span><span class="p">.</span><span class="na">LOGGED_IN</span><span class="p">,</span><span class="w"> </span><span class="n">loggedin</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">user</span><span class="p">.</span><span class="na">setState</span><span class="p">(</span><span class="n">unregistered</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">user</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * All possible states
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">EnumMap</span><span class="o">&lt;</span><span class="n">UserState</span><span class="p">,</span><span class="w"> </span><span class="n">User</span><span class="o">&gt;</span><span class="w"> </span><span class="n">states</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">EnumMap</span><span class="o">&lt;</span><span class="n">UserState</span><span class="p">,</span><span class="w"> </span><span class="n">User</span><span class="o">&gt;</span><span class="p">(</span><span class="n">UserState</span><span class="p">.</span><span class="na">class</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * The current state and only nonwfinal field
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="n">state</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">User</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">username</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">username</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">addState</span><span class="p">(</span><span class="n">UserState</span><span class="w"> </span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="n">state</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">states</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">state</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">setState</span><span class="p">(</span><span class="n">User</span><span class="w"> </span><span class="n">state</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">state</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">state</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="nf">getState</span><span class="p">(</span><span class="n">UserState</span><span class="w"> </span><span class="n">type</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">User</span><span class="w"> </span><span class="n">state</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">states</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">state</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">UNSPECIFIED_STATE</span><span class="p">,</span><span class="w"> </span><span class="n">state</span><span class="p">,</span><span class="w"> </span><span class="n">state</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">state</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="nf">registeredState</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">getState</span><span class="p">(</span><span class="n">UserState</span><span class="p">.</span><span class="na">REGISTERED</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">User</span><span class="w"> </span><span class="nf">loggedInState</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">getState</span><span class="p">(</span><span class="n">UserState</span><span class="p">.</span><span class="na">LOGGED_IN</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">void</span><span class="w"> </span><span class="nf">nowRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">setState</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">registeredState</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">void</span><span class="w"> </span><span class="nf">nowLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">setState</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">loggedInState</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">register</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">state</span><span class="p">.</span><span class="na">register</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">login</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">state</span><span class="p">.</span><span class="na">login</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">state</span><span class="p">.</span><span class="na">isRegistered</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">state</span><span class="p">.</span><span class="na">isLoggedIn</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">username</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s put it to the test
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TheUserTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="p">(</span><span class="n">expected</span><span class="o">=</span><span class="n">UnregisteredUserException</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">testUnregistered</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">User</span><span class="w"> </span><span class="n">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">TheUserBuilder</span><span class="p">(</span><span class="s">&#34;cherouvim&#34;</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">user</span><span class="p">.</span><span class="na">login</span><span class="p">();</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">testRegister</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">User</span><span class="w"> </span><span class="n">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">TheUserBuilder</span><span class="p">(</span><span class="s">&#34;cherouvim&#34;</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">user</span><span class="p">.</span><span class="na">register</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">user</span><span class="p">.</span><span class="na">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> </span><span class="n">user</span><span class="p">.</span><span class="na">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">testLogin</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">User</span><span class="w"> </span><span class="n">user</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">TheUserBuilder</span><span class="p">(</span><span class="s">&#34;cherouvim&#34;</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">user</span><span class="p">.</span><span class="na">register</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">user</span><span class="p">.</span><span class="na">login</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">user</span><span class="p">.</span><span class="na">isRegistered</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">user</span><span class="p">.</span><span class="na">isLoggedIn</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>This is possibly the most hideous usage of if since not only makes your code hard to follow but also you have to keep track of your <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main" title="Why not having to worry about state is the best thing than can happen to you">object&rsquo;s state</a> since execution flow changes every time. All in your head that is.</p>
<p>In addition it&rsquo;s hard to figure out how the object behaves at each state as well as how the transitions between them happen. Because of that it makes it a pain to debug and to extend.</p>
<p>What you need to do instead is think of all the possible states your object can have and create an implementation for each. This way each state effectively encapsulates only what&rsquo;s responsible for. Notice how each state also sets the next valid state of your object depending on what method you called, making your object look as if it&rsquo;s a different one. For that you need to have a reference to your actual class.</p>
<p>As a result each state mirrors your class interface. If a method isn&rsquo;t valid for a particular state make sure that you throw an <a href="http://download.oracle.com/javase/6/docs/api/java/lang/IllegalStateException.html">IllegalStateException</a>. In that case you&rsquo;ll know early that <a href="https://qnoid.com/2010/08/05/the-reason-behind-finally.html#main" title="A reminder on exceptions">something unexpected happened</a>, which is most likely an error on how you wired your code.</p>
<p>Effectively you end up with <em>state</em> being the only non final field in your class.</p>
<p><strong>Summary</strong></p>
<ul>
<li>Create an interface with all the methods related to the object&rsquo;s state</li>
<li>Create an implementation for each state</li>
<li>Have a single field in your actual class holding the current state</li>
<li>Delegate each call to the current state</li>
</ul>
<p>As to how to identify the state machine itself, it really goes back to <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main" title="You need to know grammar">the beginning</a></p>
<h2 id="kudos">Kudos</h2>
<p><a href="http://blog.cherouvim.com/">Ioannis Cherouvim</a> who is a Java developer and regularly writes blogs posts about using Java effectively.</p>
<p><em>The <a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t1fE">source code</a> is available on github as <a href="https://qnoid.com/2011/01/16/inheritance.html#main">stated previously</a>. Feel free to fork it and add a LoggedOut state which allows the user to logout and set the appropriate state</em></p>
]]></description>
        <pubDate>Wed, 19 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Inheritance ...Don&#39;t Abuse Inheritance</title>
        <link>https://qnoid.com/2011/01/16/inheritance.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/16/inheritance.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The Terminator feels no pain, 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * has no emotions, 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * and will stop at nothing to accomplish its mission.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Terminator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Reduces the health of the terminator by the damage taken as specified 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * by this terminator.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Note that this terminator takes no damage after the fight.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param terminator the terminator to take the damage
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return true if terminated
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see #damageBy(int)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return how much health the terminator has
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">health</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Reduces the health of the terminator by the damage taken.
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param damage the damage to take
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return true if terminated
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see #health()
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">damageBy</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return true if health equals or below 0
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isTerminated</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Can only give punches
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">StiffTerminator</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Terminator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">model</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Is that the only thing a terminator can destroy with?
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Punch</span><span class="w"> </span><span class="n">punch</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">health</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Forced &#39;protected&#39; by the fact that we need to extend the 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * {@link #destroy(Terminator)} method
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">protected</span><span class="w"> </span><span class="nf">StiffTerminator</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">model</span><span class="p">,</span><span class="w"> </span><span class="n">Punch</span><span class="w"> </span><span class="n">punch</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">health</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">model</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">model</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">health</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">health</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">punch</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">punch</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Will need to accommodate for a change in the destruction
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">punch</span><span class="p">.</span><span class="na">punch</span><span class="p">(</span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">health</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">health</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">damageBy</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">health</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">isTerminated</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isTerminated</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">health</span><span class="w"> </span><span class="o">&lt;=</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">model</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * You don&#39;t really need another terminator for this...
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ShakyTerminator</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">StiffTerminator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Shotgun</span><span class="w"> </span><span class="n">shotgun</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">protected</span><span class="w"> </span><span class="nf">ShakyTerminator</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">model</span><span class="p">,</span><span class="w"> </span><span class="n">Shotgun</span><span class="w"> </span><span class="n">shotgun</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">health</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Notice how you are forced to use null for the punch which reveals
</span></span></span><span class="line"><span class="cl"><span class="cm">             * a not well thought class design
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">super</span><span class="p">(</span><span class="n">model</span><span class="p">,</span><span class="w"> </span><span class="kc">null</span><span class="p">,</span><span class="w"> </span><span class="n">health</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">shotgun</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">shotgun</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">shotgun</span><span class="p">.</span><span class="na">shoot</span><span class="p">(</span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The menacing terminator
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TheTerminator</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Terminator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TheTerminatorBuilder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * See /2010/09/30/Honour-your-builders-Don&#39;t-lose-your-train-of-thoughts.html#main
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">TheTerminator</span><span class="w"> </span><span class="nf">build</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">TheTerminator</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">model</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">destructionMode</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">health</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">model</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DestructionMode</span><span class="w"> </span><span class="n">destructionMode</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">health</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">TheTerminator</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">model</span><span class="p">,</span><span class="w"> </span><span class="n">DestructionMode</span><span class="w"> </span><span class="n">destructionMode</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">health</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">model</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">model</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">health</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">health</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">destructionMode</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">destructionMode</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">destructionMode</span><span class="p">.</span><span class="na">destroy</span><span class="p">(</span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/* cont. */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Use to define different destruction modes for the terminator.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     *  @see DestructionModes
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">DestructionMode</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * This has been extracted as a result of the 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * {@link Terminator#destroy(Terminator)} method likely to change to 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * accommodate different destruction modes.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;br&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Thus it mirrors the method in its whole.
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param terminator to destroy
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return true if terminated
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * All available destruction modes
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">DestructionModes</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Logs in memory any terminators encountered
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DestructionMode</span><span class="w"> </span><span class="n">NONE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DestructionMode</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">       
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">MEMORY</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">StringBuilder</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">MEMORY</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/* (non-Javadoc)
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @see java.lang.Object#toString()
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">MEMORY</span><span class="p">.</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new destruction mode with a punch
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">DestructionMode</span><span class="w"> </span><span class="nf">punch</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">Punch</span><span class="w"> </span><span class="n">punch</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DestructionMode</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">punch</span><span class="p">.</span><span class="na">punch</span><span class="p">(</span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new destruction mode with a shotgun
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">DestructionMode</span><span class="w"> </span><span class="nf">shotgun</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">Shotgun</span><span class="w"> </span><span class="n">shotgun</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">DestructionMode</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">destroy</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">shotgun</span><span class="p">.</span><span class="na">shoot</span><span class="p">(</span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Testing TheTerminator
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TheTerminatorTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Skynet</span><span class="w"> </span><span class="n">SKYNET</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Skynet</span><span class="p">.</span><span class="na">instance</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">fight</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">TheTerminator</span><span class="w"> </span><span class="n">t800</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">SKYNET</span><span class="p">.</span><span class="na">newT800</span><span class="p">(</span><span class="n">Punches</span><span class="p">.</span><span class="na">WEAK</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">TheTerminator</span><span class="w"> </span><span class="n">t1000</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">SKYNET</span><span class="p">.</span><span class="na">newT1000</span><span class="p">(</span><span class="n">Punches</span><span class="p">.</span><span class="na">STRONG</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">TheTerminator</span><span class="w"> </span><span class="n">hkScout</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">SKYNET</span><span class="p">.</span><span class="na">newHKScount</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Terminator &#39;%s&#39; is destroyed by &#39;%s&#39;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">t1000</span><span class="p">,</span><span class="w"> </span><span class="n">t800</span><span class="p">),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">t800</span><span class="p">.</span><span class="na">destroy</span><span class="p">(</span><span class="n">t1000</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Terminator &#39;%s&#39; not destroyed by %s&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">t800</span><span class="p">,</span><span class="w"> </span><span class="n">t1000</span><span class="p">),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">t1000</span><span class="p">.</span><span class="na">destroy</span><span class="p">(</span><span class="n">t800</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Terminator &#39;%s&#39; not destroyed by %s&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">t800</span><span class="p">,</span><span class="w"> </span><span class="n">hkScout</span><span class="p">),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">hkScout</span><span class="p">.</span><span class="na">destroy</span><span class="p">(</span><span class="n">t800</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="s">&#34;Terminator shouldn&#39;t be destroyed&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">hkScout</span><span class="p">.</span><span class="na">destroy</span><span class="p">(</span><span class="n">t800</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">Inheritance</a> is one of the most popular class relationships and really powerful indeed. After
all it allows you to reuse whole classes. However, <a href="http://en.wikipedia.org/wiki/Uncle_Ben#.22With_great_power_comes_great_responsibility.22" title="Snap, that's from another movie!">with great power comes great responsibility</a>
and it&rsquo;s good to keep inheritance as the last resort or as part of a <a href="https://qnoid.com/2010/10/12/conclusion-dont-lose-your-train-of-thoughts.html#main">well thought</a> design.</p>
<p>Take a look at the <em>StiffTerminator#destroy(Terminator)</em> method. You can tell there is a need for
different ways to destroy a terminator. Yet at the same time you don&rsquo;t want to duplicate the rest of
the code. Thus the first thing that comes to mind is to inherit.</p>
<p>ShakyTerminator extends StiffTerminator adding a Shotgun as a field therefore making Punch not
only obsolete but also irrelevant. Yet due to the nature of inheritance it is required that you
specify its value. You can choose to pass in null. However you do have to make sure null is a valid
value by the StiffTerminator design which may well affect any of your subclasses. Else you have to
introduce it as an argument to your ShakyTerminator constructor,</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="nf">ShakyTerminator</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">model</span><span class="p">,</span><span class="w"> </span><span class="n">Punch</span><span class="w"> </span><span class="n">punch</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">health</span><span class="p">,</span><span class="w"> </span><span class="n">Shotgun</span><span class="w"> </span><span class="n">shotgun</span><span class="p">)</span><span class="w"> </span></span></span></code></pre></div>
<p>introducing extra and unnecessary complexity.</p>
<p>In addition you need to elevate the access modifier of the StiffTerminator from private to protected.
You start sacrificing <a href="http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming)">encapsulation</a>. Not only you&rsquo;ve made all those sacrifices but your code
starts to looks messy.</p>
<p>The truth is that you don&rsquo;t have to create a new Terminator class! If you look closely you&rsquo;ll see
that you need to somehow make the <em>Punch#punch(Terminator)</em> <a href="https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html#main">polymorphic</a>. That is definitely one
way to look at it. In that case you need to introduce an interface</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">DestructionMode</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">punch</span><span class="p">(</span><span class="n">Terminator</span><span class="w"> </span><span class="n">terminator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span></span></span></code></pre></div>
<p>and have your Punch implement it</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Punch</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">DestructionMode</span></span></span></code></pre></div>
<p>as well as any other classes.</p>
<p>Though this will work in some cases it&rsquo;s not always possible (3rd party classes), not in context or
there are a couple classes involved. The fact of the matter is <strong>it&rsquo;s more about composition and
less of polymorphism.</strong></p>
<p>Now, you still need to introduce an interface but your classes don&rsquo;t need to directly implement it.
Rather you introduce a new class - implementing that interface - for each composition. <a href="http://download.oracle.com/javase/tutorial/java/javaOO/innerclasses.html">Anonymous
classes</a> can be of great use in this case.</p>
<p>What you end up with allows you to have more readable, flexible and high reusable code instead.</p>
<h2 id="summary">Summary</h2>
<ul>
<li>Identify the method(s) that are subject to change in your class</li>
<li>Introduce a new interface with all the identified methods</li>
<li>Add a new field of that type in your class and as an argument to the constructor</li>
<li>Delegate each call to your interface method respectively</li>
<li>Create one class for every implementation using composition to encapsulate the dependencies</li>
</ul>
<p><em>Inheritance on the other hand is really good with <a href="https://qnoid.com/2010/08/02/abstract-class.html#main">abstract classes</a></em></p>
<h2 id="kudos">Kudos</h2>
<p><a href="http://www.imdb.com/name/nm0000116/">James Cameron</a> for <a href="http://www.imdb.com/title/tt0088247/">the Terminator</a><br>
<a href="http://creativecommons.org/">Creative Commons</a> for making sharing easier<br>
<a href="https://github.com/">Gihub</a> for making a truly amazing social code repository</p>
<p><em>Starting with this post, the complete source code will be available in github for every post I make under a Creative Commons Licence with an attribution that requires a link back to the qnoid. Will also try and add the source code for all my previous posts. Hope this will give you better understanding and allow you to experiment further</em></p>
<p><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t1Jc">Source Code</a></p>
]]></description>
        <pubDate>Sun, 16 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Encapsulation ...Don&#39;t Abuse The If</title>
        <link>https://qnoid.com/2011/01/11/encapsulation.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/11/encapsulation.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Destined to sink
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Titanic</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">WallStreet</span><span class="w"> </span><span class="n">wallstreet</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">WallStreet</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pharaoh</span><span class="w"> </span><span class="n">pharaoh</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Pharaoh</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Oilwell</span><span class="w"> </span><span class="n">oilwell</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Oilwell</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Cowboy</span><span class="o">[]</span><span class="w"> </span><span class="n">cowboys</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Cowboy</span><span class="o">[]</span><span class="p">{</span><span class="k">new</span><span class="w"> </span><span class="n">Cowboy</span><span class="p">()};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">direction</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;NORTH&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">direction</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">wallstreet</span><span class="p">.</span><span class="na">moneyNeverSleeps</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;SOUTH&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">direction</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">pharaoh</span><span class="p">.</span><span class="na">curse</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;EAST&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">direction</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">oilwell</span><span class="p">.</span><span class="na">drill</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;WEST&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">direction</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Cowboy</span><span class="w"> </span><span class="n">cowboy</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">cowboys</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">cowboy</span><span class="p">.</span><span class="na">shoot</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnknownDestination</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Smooth sailing
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CruiseLiner</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">UNKNOWN_DESTINATION</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="s">&#34;There is no destination in the direction &#39;%s&#39;. &#34;</span><span class="w"> </span><span class="o">+</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="s">&#34;Did you specify it as such in CruiseLiner#newCruiseLiner &#34;</span><span class="w"> </span><span class="o">+</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="s">&#34;when constructing the cruise liner?&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Create a new {@link CruiseLiner} which is able to sail to the specified
</span></span></span><span class="line"><span class="cl"><span class="cm">         * destinations
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param destinations the destinations that can set sail to
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new {@link CruiseLiner}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see Destinations
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">CruiseLiner</span><span class="w"> </span><span class="nf">newCruiseLiner</span><span class="p">(</span><span class="n">Destination</span><span class="p">...</span><span class="w"> </span><span class="n">destinations</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">EnumMap</span><span class="o">&lt;</span><span class="n">Direction</span><span class="p">,</span><span class="w"> </span><span class="n">Destination</span><span class="o">&gt;</span><span class="w"> </span><span class="n">map</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">EnumMap</span><span class="o">&lt;</span><span class="n">Direction</span><span class="p">,</span><span class="w"> </span><span class="n">Destination</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Direction</span><span class="p">.</span><span class="na">class</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Destination</span><span class="w"> </span><span class="n">destination</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">destinations</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">map</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">destination</span><span class="p">.</span><span class="na">direction</span><span class="p">(),</span><span class="w"> </span><span class="n">destination</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">CruiseLiner</span><span class="p">(</span><span class="n">map</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * A map by direction for each destination 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * No need to specify any other dependencies here. Great!
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">EnumMap</span><span class="o">&lt;</span><span class="n">Direction</span><span class="p">,</span><span class="w"> </span><span class="n">Destination</span><span class="o">&gt;</span><span class="w"> </span><span class="n">map</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">CruiseLiner</span><span class="p">(</span><span class="n">EnumMap</span><span class="o">&lt;</span><span class="n">Direction</span><span class="p">,</span><span class="w"> </span><span class="n">Destination</span><span class="o">&gt;</span><span class="w"> </span><span class="n">map</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">map</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">map</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">Direction</span><span class="w"> </span><span class="n">direction</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">//Use the map to get the destination you want for the given direction</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Destination</span><span class="w"> </span><span class="n">destination</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">map</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">direction</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">destination</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="kc">null</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnknownDestination</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">UNKNOWN_DESTINATION</span><span class="p">,</span><span class="w"> </span><span class="n">direction</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">//let the destination specify what to do once the cruise liner sails there</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">destination</span><span class="p">.</span><span class="na">sail</span><span class="p">(</span><span class="k">this</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Get your directions together
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">Direction</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">NORTH</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">SOUTH</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">EAST</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">WEST</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">UKNOWN</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Encapsulate your destinations by introducing a common interface 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Destination</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Direction</span><span class="w"> </span><span class="nf">direction</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">       </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">        * Implement this method with what you would do at each destination
</span></span></span><span class="line"><span class="cl"><span class="cm">        */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Constant destinations with each specifying its required dependencies
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Destinations</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">NORTH_AMERICA</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Destination</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">WallStreet</span><span class="w"> </span><span class="n">wallstreet</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">WallStreet</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">wallstreet</span><span class="p">.</span><span class="na">moneyNeverSleeps</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Direction</span><span class="w"> </span><span class="nf">direction</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">NORTH</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">SOUTH_AFRICA</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Destination</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pharaoh</span><span class="w"> </span><span class="n">pharaoh</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Pharaoh</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">pharaoh</span><span class="p">.</span><span class="na">curse</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Direction</span><span class="w"> </span><span class="nf">direction</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">SOUTH</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">MIDDLE_EAST</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Destination</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Oilwell</span><span class="w"> </span><span class="n">oilwell</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Oilwell</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">oilwell</span><span class="p">.</span><span class="na">drill</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Direction</span><span class="w"> </span><span class="nf">direction</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">EAST</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="w"> </span><span class="n">GREAT_WEST</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Destination</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Cowboy</span><span class="o">[]</span><span class="w"> </span><span class="n">cowboys</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Cowboy</span><span class="o">[]</span><span class="p">{</span><span class="k">new</span><span class="w"> </span><span class="n">Cowboy</span><span class="p">()};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">(</span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Cowboy</span><span class="w"> </span><span class="n">cowboy</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">cowboys</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">cowboy</span><span class="p">.</span><span class="na">shoot</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Direction</span><span class="w"> </span><span class="nf">direction</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">WEST</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s cruise
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CruiseLinerTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Destination</span><span class="o">[]</span><span class="w"> </span><span class="n">DESTINATIONS</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">Destination</span><span class="o">[]</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * Use constants!
</span></span></span><span class="line"><span class="cl"><span class="cm">                 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Destinations</span><span class="p">.</span><span class="na">NORTH_AMERICA</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Destinations</span><span class="p">.</span><span class="na">SOUTH_AFRICA</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Destinations</span><span class="p">.</span><span class="na">MIDDLE_EAST</span><span class="p">,</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Destinations</span><span class="p">.</span><span class="na">WILD_WEST</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sail</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">CruiseLiner</span><span class="p">.</span><span class="na">newCruiseLiner</span><span class="p">(</span><span class="w"> </span><span class="n">DESTINATIONS</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">cruiseLiner</span><span class="p">.</span><span class="na">sail</span><span class="p">(</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">NORTH</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">cruiseLiner</span><span class="p">.</span><span class="na">sail</span><span class="p">(</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">SOUTH</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">cruiseLiner</span><span class="p">.</span><span class="na">sail</span><span class="p">(</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">EAST</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">cruiseLiner</span><span class="p">.</span><span class="na">sail</span><span class="p">(</span><span class="w"> </span><span class="n">Direction</span><span class="p">.</span><span class="na">WEST</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="p">(</span><span class="n">expected</span><span class="o">=</span><span class="n">UnknownDestination</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">sailUnknown</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">CruiseLiner</span><span class="w"> </span><span class="n">cruiseLiner</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">CruiseLiner</span><span class="p">.</span><span class="na">newCruiseLiner</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">cruiseLiner</span><span class="p">.</span><span class="na">sail</span><span class="p">(</span><span class="n">Direction</span><span class="p">.</span><span class="na">UKNOWN</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>It is shocking to see this basic abuse of an if so frequently. In the @qnoid, over at github and bitbucket, on freshly baked projects. Especially when all it takes is to use a <a href="http://download.oracle.com/javase/6/docs/api/java/util/Map.html">Map</a> instead of an long if statement and take advantage of <a href="http://en.wikipedia.org/wiki/Delegation_pattern">delegation</a>.</p>
<p>It usually manifests in the controller where you have a single method to handle different operations and though it resembles <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">polymorphism</a> is less about it and more about <a href="http://en.wikipedia.org/wiki/Object_composition">composition</a>.</p>
<p>Again you might say it is nothing serious and you can <a href="https://qnoid.com/2010/10/05/Parse-a-date-with-a-variable-format.html#main" title="A tale about following principles">choose to ignore it</a> but it does make your code less extensible, harder to maintain, less readable and <a href="http://en.wikipedia.org/wiki/RMS_Titanic">destined to sink</a>.</p>
<p>If (pun intended) you add all the dependencies related to the different actions for each block you end up with one monolithic class. That&rsquo;s ugly. On a lighter note, using strings isn&rsquo;t type safe and thus error prone. Think how many times in the past you&rsquo;ve had to debug for hours because of a single typo. Not fun.</p>
<p>Assuming you&rsquo;ve used an <a href="http://download.oracle.com/javase/tutorial/java/javaOO/enum.html">enum</a> you shouldn&rsquo;t have any troubling mapping it with</p>
<pre><code>    Direction direction = Direction.valueOf( name );
</code></pre>
<p>So next time you are tempted to use a long if block just <strong>use a map</strong> where each <strong>key is the name of your action</strong> and the corresponding value is an object of a class implementing a <strong>common interface with a single method</strong>.</p>
<p><em>PS. Get used to the habit of <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">creating constants out of your classes</a>.</em></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t11z">Source</a></em></p>
]]></description>
        <pubDate>Tue, 11 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... JSON (Part 3)</title>
        <link>https://qnoid.com/2011/01/09/heterogenous-containers-JSON-part-3.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/09/heterogenous-containers-JSON-part-3.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * A collection of pairs ordered based on the order of their {@link Element}s
</span></span></span><span class="line"><span class="cl"><span class="cm"> * 
</span></span></span><span class="line"><span class="cl"><span class="cm"> * @see ElementBuilder
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PairSet</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Iterable</span><span class="o">&lt;</span><span class="n">Pair</span><span class="o">&lt;?&gt;&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Create a new JSON object with the specified pairs
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param pairs the pairs to the JSON object
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @return a JsonObject with the specified pairs
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">PairSet</span><span class="w"> </span><span class="nf">of</span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="p">...</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairSet</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PairSet</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">pairSet</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">pair</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">pairSet</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Using TreeMap implementation for sorting
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Element</span><span class="o">&lt;?&gt;</span><span class="p">,</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;&gt;</span><span class="w"> </span><span class="n">pairs</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">new</span><span class="w"> </span><span class="n">TreeMap</span><span class="o">&lt;</span><span class="n">Element</span><span class="o">&lt;?&gt;</span><span class="p">,</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Adds a new pair value
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param &lt;T&gt; the pair type
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param pair the pair to add
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">PairSet</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">pair</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="na">element</span><span class="p">(),</span><span class="w"> </span><span class="n">pair</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">Iterator</span><span class="o">&lt;</span><span class="n">Pair</span><span class="o">&lt;?&gt;&gt;</span><span class="w"> </span><span class="n">iterator</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="p">.</span><span class="na">values</span><span class="p">().</span><span class="na">iterator</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param &lt;T&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param element the type of the pair
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @return the pair instance
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Element#type()
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">element</span><span class="p">.</span><span class="na">type</span><span class="p">().</span><span class="na">cast</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">element</span><span class="p">).</span><span class="na">value</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">size</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="p">.</span><span class="na">size</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * A non-complex JSON object
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">JsonObject</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">JsonObject</span><span class="w"> </span><span class="nf">of</span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="p">...</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">JsonObject</span><span class="p">(</span><span class="w"> </span><span class="n">PairSet</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">pairs</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Type</span><span class="o">&gt;</span><span class="w"> </span><span class="n">LAST_ELEMENT</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">TYPE</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">LEFT_BRACE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;{&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">RIGHT_BRACE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;}&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">COMMA</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;,&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairs</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">JsonObject</span><span class="p">(</span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pairs</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">isLast</span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">pair</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">LAST_ELEMENT</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="na">element</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">appendEveryPairOf</span><span class="p">(</span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="p">);</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">appendCommaIfNotLast</span><span class="p">(</span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">appendCommaIfNotLast</span><span class="p">(</span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">pair</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">boolean</span><span class="w"> </span><span class="n">isLast</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">isLast</span><span class="p">(</span><span class="n">pair</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">isLast</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="w"> </span><span class="n">COMMA</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param &lt;T&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param element the element which is present in the JSON object
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @return its value
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">valueOf</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">element</span><span class="p">);</span><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">   	  </span><span class="n">StringBuilder</span><span class="w"> </span><span class="n">builder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">StringBuilder</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">	  </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">LEFT_BRACE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">	  </span><span class="n">appendEveryPairOf</span><span class="p">(</span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pairs</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">	  </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="n">RIGHT_BRACE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="n">builder</span><span class="p">.</span><span class="na">toString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="nd">@RunWith</span><span class="p">(</span><span class="n">Theories</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PairSetTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Integer</span><span class="w"> </span><span class="n">ID_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ID_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	    </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">ID</span><span class="p">,</span><span class="w"> </span><span class="n">ID_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">NAME_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;Kyle Bragger&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">NAME_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	    </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">NAME</span><span class="p">,</span><span class="w"> </span><span class="n">NAME_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="n">DATE_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	    </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">().</span><span class="na">getTime</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DATE_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	    </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">DATE</span><span class="p">,</span><span class="w"> </span><span class="n">DATE_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Type</span><span class="w"> </span><span class="n">TYPE_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Type</span><span class="p">.</span><span class="na">DEVELOPER</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Type</span><span class="o">&gt;</span><span class="w"> </span><span class="n">TYPE_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	    </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">TYPE</span><span class="p">,</span><span class="w"> </span><span class="n">TYPE_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;[]</span><span class="w"> </span><span class="n">PAIRS</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">new</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;[]</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ID_PAIR</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">NAME_PAIR</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">DATE_PAIR</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">TYPE_PAIR</span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@DataPoints</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;?&gt;[]</span><span class="w"> </span><span class="n">ELEMENTS</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="n">Elements</span><span class="p">.</span><span class="na">ID</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">NAME</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">TYPE</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">DATE</span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param pairs
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param element
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">assertNotNull</span><span class="p">(</span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairs</span><span class="p">,</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    	</span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pairs</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">element</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	    
</span></span></span><span class="line"><span class="cl"><span class="w">    	</span><span class="n">Assert</span><span class="p">.</span><span class="na">assertNotNull</span><span class="p">(</span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">of</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairs</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">PairSet</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="w"> </span><span class="n">PairSetTest</span><span class="p">.</span><span class="na">PAIRS</span><span class="w"> </span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">pairs</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Theory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">PairSet</span><span class="w"> </span><span class="n">pairs</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">PairSet</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="w"> </span><span class="n">PairSetTest</span><span class="p">.</span><span class="na">PAIRS</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">assertNotNull</span><span class="p">(</span><span class="n">pairs</span><span class="p">,</span><span class="w"> </span><span class="n">element</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">JsonObjectTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Integer</span><span class="w"> </span><span class="n">ID_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ID_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">ID</span><span class="p">,</span><span class="w"> </span><span class="n">ID_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">NAME_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;Kyle Bragger&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">NAME_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">NAME</span><span class="p">,</span><span class="w"> </span><span class="n">NAME_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="n">DATE_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">().</span><span class="na">getTime</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DATE_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">DATE</span><span class="p">,</span><span class="w"> </span><span class="n">DATE_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Type</span><span class="w"> </span><span class="n">TYPE_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Type</span><span class="p">.</span><span class="na">DEVELOPER</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Type</span><span class="o">&gt;</span><span class="w"> </span><span class="n">TYPE_PAIR</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">Elements</span><span class="p">.</span><span class="na">TYPE</span><span class="p">,</span><span class="w"> </span><span class="n">TYPE_VALUE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;[]</span><span class="w"> </span><span class="n">PAIRS</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">new</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;?&gt;[]</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ID_PAIR</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">NAME_PAIR</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">DATE_PAIR</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">TYPE_PAIR</span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">toString</span><span class="w"> </span><span class="o">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">({{</span><span class="s">&#34;{%s&#34;</span><span class="p">}},</span><span class="o">%</span><span class="n">s</span><span class="p">,</span><span class="o">%</span><span class="n">s</span><span class="p">,</span><span class="o">%</span><span class="n">s</span><span class="p">}</span><span class="s">&#34;, ID_PAIR, NAME_PAIR, DATE_PAIR, TYPE_PAIR);
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">    @Test
</span></span></span><span class="line"><span class="cl"><span class="s">    public void string() throws Exception 
</span></span></span><span class="line"><span class="cl"><span class="s">    {
</span></span></span><span class="line"><span class="cl"><span class="s"> 	JsonObject jsonObject = JsonObject.of( PAIRS );
</span></span></span><span class="line"><span class="cl"><span class="s">		
</span></span></span><span class="line"><span class="cl"><span class="s">	Assert.assertEquals(toString, jsonObject.toString());
</span></span></span><span class="line"><span class="cl"><span class="s">    }
</span></span></span><span class="line"><span class="cl"><span class="s">	
</span></span></span><span class="line"><span class="cl"><span class="s">    @Test
</span></span></span><span class="line"><span class="cl"><span class="s">    public void valueOfId() throws Exception 
</span></span></span><span class="line"><span class="cl"><span class="s">    {
</span></span></span><span class="line"><span class="cl"><span class="s">    	  JsonObject jsonObject = JsonObject.of( PAIRS );
</span></span></span><span class="line"><span class="cl"><span class="s">		
</span></span></span><span class="line"><span class="cl"><span class="s">	  Assert.assertEquals(ID_VALUE, jsonObject.valueOf(Elements.ID));
</span></span></span><span class="line"><span class="cl"><span class="s">    }
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">    @Test
</span></span></span><span class="line"><span class="cl"><span class="s">    public void valueOfName() throws Exception 
</span></span></span><span class="line"><span class="cl"><span class="s">    {
</span></span></span><span class="line"><span class="cl"><span class="s">   	  JsonObject jsonObject = JsonObject.of( PAIRS );
</span></span></span><span class="line"><span class="cl"><span class="s">		
</span></span></span><span class="line"><span class="cl"><span class="s">	  Assert.assertEquals(NAME_VALUE, jsonObject.valueOf(Elements.NAME));
</span></span></span><span class="line"><span class="cl"><span class="s">    }
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">    @Test
</span></span></span><span class="line"><span class="cl"><span class="s">    public void valueOfType() throws Exception 
</span></span></span><span class="line"><span class="cl"><span class="s">    {
</span></span></span><span class="line"><span class="cl"><span class="s"> 	  JsonObject jsonObject = JsonObject.of( PAIRS );
</span></span></span><span class="line"><span class="cl"><span class="s">		
</span></span></span><span class="line"><span class="cl"><span class="s">	  Assert.assertEquals(TYPE_VALUE, jsonObject.valueOf(Elements.TYPE));
</span></span></span><span class="line"><span class="cl"><span class="s">    }
</span></span></span><span class="line"><span class="cl"><span class="s">
</span></span></span><span class="line"><span class="cl"><span class="s">    @Test
</span></span></span><span class="line"><span class="cl"><span class="s">    public void valueOfDate() throws Exception 
</span></span></span><span class="line"><span class="cl"><span class="s">    {
</span></span></span><span class="line"><span class="cl"><span class="s">	  JsonObject jsonObject = JsonObject.of( PAIRS );
</span></span></span><span class="line"><span class="cl"><span class="s">		
</span></span></span><span class="line"><span class="cl"><span class="s">	  Assert.assertEquals(DATE_VALUE, jsonObject.valueOf(Elements.DATE));
</span></span></span><span class="line"><span class="cl"><span class="s">    }
</span></span></span><span class="line"><span class="cl"><span class="s">}</span></span></span></code></pre></div>
<p>This is the final post of the <a href="https://qnoid.com/2011/01/07/heterogenous-containers-JSON-part-2.html#main">&ldquo;How to think of JSON&rdquo; series</a> using heterogeneous containers.</p>
<p>In this example the PairSet plays the role of <a href="https://qnoid.com/2010/12/12/heterogenous-containers-preamble.html#main" title="An introduction to heterogeneous containers">such a container</a> backed by a <a href="http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html">TreeMap</a>. The TreeMap implementation is used to keep our elements sorted based on their <a href="https://qnoid.com/2011/01/05/heterogenous-containers-JSON-part-1.html#main" title="The Element class implements the Comparable interface">natural ordering</a> which in this case merely helps us assert the <em>JsonObject#toString</em> method.</p>
<p>Note how the PairSet class also implements the <a href="http://download.oracle.com/javase/6/docs/api/java/lang/Iterable.html">Iterable<T></a> interface thus the</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="n">Iterator</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">iterator</span><span class="p">();</span></span></span></code></pre></div>
<p>method which allows us to use the <a href="http://download.oracle.com/javase/1.5.0/docs/guide/language/foreach.html">enhanced for loop</a>.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">pairs</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">builder</span><span class="p">.</span><span class="na">append</span><span class="p">(</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="p">);</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">appendCommaIfNotLast</span><span class="p">(</span><span class="n">builder</span><span class="p">,</span><span class="w"> </span><span class="n">pair</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span></span></span></code></pre></div>
<p>Make sure you incorporate it in classes that represent collections of objects.</p>
<p>As it all comes together (Element, ElementFormat, Pair, PairSet) we end up with a JsonObject class which not only allows us to query for any JSON element to get its value back to the right type but get a properly formatted String representation.</p>
<p>Once acquainted feel free to leave your comments below on how heterogeneous containers think can aid your design.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t1XE">Source</a></em></p>
]]></description>
        <pubDate>Sun, 09 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... JSON (Part 2)</title>
        <link>https://qnoid.com/2011/01/07/heterogenous-containers-JSON-part-2.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/07/heterogenous-containers-JSON-part-2.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Each {@link Element} has one format which is used to return its string 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * representation.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Implementations should provide the corresponding format.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see ElementFormats#defaultFormat()
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see ElementFormats#newDateFormat(java.text.DateFormat) 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param &lt;T&gt; the type of the element
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param element the element related to the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value its value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a String representation
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">format</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">,</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A resource for various element formats
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ElementFormats</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * A default JSON format as
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;code&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &#34;name&#34;:&#34;value&#34;
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;/code&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">defaultFormat</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">format</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">,</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;\&#34;%s\&#34;:\&#34;%s\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">element</span><span class="p">.</span><span class="na">name</span><span class="p">(),</span><span class="w"> </span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Creates a new format for Date {@link Element}s. 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * The specified date format will be used to format the date of the element. 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see DateFormat#format(Date)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newDateFormat</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">format</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">,</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;\&#34;%s\&#34;:\&#34;%s\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">element</span><span class="p">.</span><span class="na">name</span><span class="p">(),</span><span class="w"> </span><span class="n">dateFormat</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">value</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A JSON pair that is associated with an element and has a value
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param &lt;T&gt; the type of the pair which derives from the Element is associated with
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Element
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Pair</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Create a new JSON pair
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param &lt;T&gt; the type of the JSON pair 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param element the element of the pair
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value its value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new Pair
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see Elements
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newPair</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">,</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">element</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">(</span><span class="n">element</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param element
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">Pair</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">,</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">element</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">element</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">element</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">element</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">value</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">value</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">element</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Effective Java 2nd Edition, Joshua Bloch, Item 8
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">hashCode</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">17</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">37</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">result</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">element</span><span class="p">.</span><span class="na">hashCode</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">result</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">37</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">result</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">value</span><span class="p">.</span><span class="na">hashCode</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">result</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">equals</span><span class="p">(</span><span class="n">Object</span><span class="w"> </span><span class="n">that</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="k">this</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">that</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">that</span><span class="w"> </span><span class="k">instanceof</span><span class="w"> </span><span class="n">Pair</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">Pair</span><span class="o">&lt;?&gt;</span><span class="p">)</span><span class="n">that</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">element</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="na">element</span><span class="p">)</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">value</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">pair</span><span class="p">.</span><span class="na">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Testing the format of elements
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ElementTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="n">DATE_VALUE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Dates</span><span class="p">.</span><span class="na">of</span><span class="p">(</span><span class="n">22</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2010</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">formatId</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="s">&#34;\&#34;id\&#34;:\&#34;1\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">ID</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">1</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">formatName</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="s">&#34;\&#34;name\&#34;:\&#34;Kyle\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">NAME</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Kyle&#34;</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">formatType</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="s">&#34;\&#34;type\&#34;:\&#34;developer\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">TYPE</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">Type</span><span class="p">.</span><span class="na">DEVELOPER</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">formatDate</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="s">&#34;\&#34;date\&#34;:\&#34;Jan 22, &#39;10\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">DATE</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="n">DATE_VALUE</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>During the <a href="https://qnoid.com/2011/01/05/heterogenous-containers-JSON-part-1.html#main">first part</a> on &ldquo;How to think of JSON&rdquo; we identified the <em>Element</em> as the heterogeneous type that we need to handle. Also talked briefly about <em>ElementFormat</em>.</p>
<p>In this part we introduce the <em>Pair</em> class which merely holds an element and its value. This will allow us to come up with a <a href="http://www.json.org/" title="An object is an unordered set of name/value pairs">JSON object</a> next.</p>
<p>As you can see <a href="http://download.oracle.com/javase/tutorial/java/javaOO/innerclasses.html">anonymous classes</a> support the ElementFormat <a href="https://qnoid.com/2010/09/13/Can-an-Abstract-Class-and-an-Interface-play-nice-together.html#main">interface</a> with their dependencies listed as arguments to the static method (e.g. DateFormat)</p>
<p>In this case there is no reason to have separate classes since all your relationships are tied to the interface and as a result you reduce the API noise.</p>
<p>Bare in mind that you <strong>have to use final</strong> for arguments that are used in an anonymous class or you get a compiler error.</p>
<p>A nice way to concatenate strings is to use the <a href="http://bit.ly/fYLQsq">String#format()</a> method which sort of <a href="http://en.wikipedia.org/wiki/Printf#1970s:_C.2C_Lisp">mimics the C way</a></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;\&#34;%s\&#34;:\&#34;%s\&#34;&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">element</span><span class="p">.</span><span class="na">name</span><span class="p">(),</span><span class="w"> </span><span class="n">value</span><span class="p">);</span></span></span></code></pre></div>
<p>Notice the <strong>backslash</strong> used for escaping a quote.</p>
<p>There is also 2 things to consider here about generics. The method</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">     </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">defaultFormat</span><span class="p">()</span></span></span></code></pre></div>
<p>has a type <T> which makes it a <a href="http://download.oracle.com/javase/tutorial/extra/generics/methods.html">generic method</a> allowing us to use it in the generic <em>Element</em> class as the default. Note however that T of Element<T> and T of defaultFormat are still considered different types and in no way enforced by the Java compiler. It&rsquo;s our implementation of the <em>Element</em> class that makes the connection between them.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ElementBuilder</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">format</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ElementFormats</span><span class="p">.</span><span class="na">defaultFormat</span><span class="p">();</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">build</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">type</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">order</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">format</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">format</span><span class="p">;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>In the same way the type of the Pair defines the type for the value which is also the same as that of the Element</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">        </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">dateElement</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Elements</span><span class="p">.</span><span class="na">DATE</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Date</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Calendar</span><span class="p">.</span><span class="na">getInstance</span><span class="p">().</span><span class="na">getTime</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Pair</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">pair</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Pair</span><span class="p">.</span><span class="na">newPair</span><span class="p">(</span><span class="n">dateElement</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">);</span></span></span></code></pre></div>
<p><em><a href="https://qnoid.com/2011/01/09/heterogenous-containers-JSON-part-3.html#main">Continue to Part 3</a></em></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t0El">Source</a></em></p>
]]></description>
        <pubDate>Fri, 07 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... JSON (Part 1)</title>
        <link>https://qnoid.com/2011/01/05/heterogenous-containers-JSON-part-1.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2011/01/05/heterogenous-containers-JSON-part-1.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A JSON element describing its type and name.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @param &lt;T&gt; the type of the element
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Elements#newStringType(String)
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Elements#newNumericType(String)
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Elements#newDateType(String, java.text.DateFormat)
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Elements#newBooleanType(String)
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see Elements#newEnumType(Class, String)
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Comparable</span><span class="o">&lt;</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * By default ordering isn&#39;t taken into account and the element&#39;s format is
</span></span></span><span class="line"><span class="cl"><span class="cm">         * {@link ElementFormats#defaultFormat()}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see Element#format(Object)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ElementBuilder</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">format</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ElementFormats</span><span class="p">.</span><span class="na">defaultFormat</span><span class="p">();</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="n">Integer</span><span class="w"> </span><span class="n">order</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @param type the element type
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @param name its name
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="nf">ElementBuilder</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">type</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">type</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Use to specify a custom format
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @param format the format of the element
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @see ElementFormats
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">ElementBuilder</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">format</span><span class="p">(</span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">format</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">format</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">format</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">format</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Use to specify the ordering of the elements
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @param order will be taken into account when iterating over a 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * {@link PairSet}
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">ElementBuilder</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">order</span><span class="p">(</span><span class="n">Integer</span><span class="w"> </span><span class="n">order</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">order</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">order</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">order</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @return a new Element the specified type
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">build</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">type</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">order</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">format</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">format</span><span class="p">;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Integer</span><span class="w"> </span><span class="n">order</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Element</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="n">Integer</span><span class="w"> </span><span class="n">order</span><span class="p">,</span><span class="w"> </span><span class="n">ElementFormat</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">format</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">type</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">type</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">order</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">order</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">format</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">format</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">type</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">type</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">name</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">toString</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Formats the value of this element based on the format specified. 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * This will be used when creating its string representation  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value the value to format
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a String formatted as specified by the {@link ElementFormat}
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">format</span><span class="p">(</span><span class="n">T</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">format</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="k">this</span><span class="p">,</span><span class="w"> </span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">equals</span><span class="p">(</span><span class="n">Object</span><span class="w"> </span><span class="n">that</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">if</span><span class="p">(</span><span class="k">this</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">that</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">that</span><span class="w"> </span><span class="k">instanceof</span><span class="w"> </span><span class="n">Element</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Element</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">element</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;?&gt;</span><span class="p">)</span><span class="n">that</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">element</span><span class="p">.</span><span class="na">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">hashCode</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="p">.</span><span class="na">hashCode</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/* (non-Javadoc)
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see java.lang.Comparable#compareTo(java.lang.Object)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">compareTo</span><span class="p">(</span><span class="n">Element</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">element</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">order</span><span class="p">.</span><span class="na">compareTo</span><span class="p">(</span><span class="n">element</span><span class="p">.</span><span class="na">order</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">  
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Access to constant JSON elements and creation
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Elements</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ID</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newNumericType</span><span class="p">(</span><span class="s">&#34;id&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">NAME</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">newStringType</span><span class="p">(</span><span class="s">&#34;name&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DATE</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">newDateType</span><span class="p">(</span><span class="s">&#34;date&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;MMM dd, &#39;&#39;yy&#34;</span><span class="p">),</span><span class="w"> </span><span class="n">3</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Type</span><span class="o">&gt;</span><span class="w"> </span><span class="n">TYPE</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">newEnumType</span><span class="p">(</span><span class="n">Type</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;type&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">4</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="o">&lt;</span><span class="n">E</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">Enum</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;&gt;</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newEnumType</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">order</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ElementBuilder</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="p">(</span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">).</span><span class="na">order</span><span class="p">(</span><span class="n">order</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newStringType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">order</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ElementBuilder</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="p">(</span><span class="n">String</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">).</span><span class="na">order</span><span class="p">(</span><span class="n">order</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newDateType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">dateFormat</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">order</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ElementBuilder</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Date</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">).</span><span class="na">order</span><span class="p">(</span><span class="n">order</span><span class="p">).</span><span class="na">format</span><span class="p">(</span><span class="w"> </span><span class="n">ElementFormats</span><span class="p">.</span><span class="na">newDateFormat</span><span class="p">(</span><span class="n">dateFormat</span><span class="p">)</span><span class="w"> </span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Element</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newNumericType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">order</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ElementBuilder</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Integer</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">).</span><span class="na">order</span><span class="p">(</span><span class="n">order</span><span class="p">).</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>You should already be familiar with the idea of <a href="https://qnoid.com/2010/12/12/heterogenous-containers-preamble.html#main">heterogeneous containers</a> and what it takes to <a href="https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-1.html#main">kick off</a>. In the next series of posts we&rsquo;ll see how we can think of <a href="http://www.json.org/">JSON</a> in such terms.</p>
<p>In the <em>Element</em> class above there are a couple more things other than the type and the name like a <a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main">builder</a>, an <em>ElementFormat</em>, an equals/hashCode implementation and a <a href="http://download.oracle.com/javase/6/docs/api/java/lang/Comparable.html">Comparable</a> interface so let&rsquo;s talk about them one at a time.</p>
<p>The builder is there to help us create new Element(s). The main advantage over using the constructor is that it provides reasonable defaults for the ordering of an element and its format. Thus from the client code it looks like only a type and a name is needed for an Element.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">ElementBuilder</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">checkNotNull</span><span class="p">(</span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">type</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">type</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span></span></span></code></pre></div>
<p>The <em>ElementFormat</em> is used for creating the string representation of an <em>Element</em> for a given value. The need for a formatter comes from the fact that some values (e.g. a Date) need to be formatted outside of their <a href="http://download.oracle.com/javase/6/docs/api/java/lang/Object.html#toString()">#toString</a> implementation. Nevertheless the string format is always of</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="s">&#34;name&#34;</span><span class="p">:</span><span class="s">&#34;value&#34;</span></span></span></code></pre></div>
<p>with the value being formatted each time.
Bare in mind that the <em>Element</em> class merely describes a JSON element in terms of its type and name without holding its actual value.</p>
<p>You should do well to override equals/hashCode, especially when dealing with the <a href="http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html">Collections framework</a> as you might be getting some unexpected results when doing add/remove operations.</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">    </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">that</span><span class="w"> </span><span class="k">instanceof</span><span class="w"> </span><span class="n">Element</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<pre><code>Element&lt;?&gt; element = (Element&lt;?&gt;)that;
</code></pre>
<p>Notice how the equals/hashCode implementation uses the raw type of the <em>Element</em> class for the <strong><a href="http://do-nload.oracle.com/javase/tutorial/java/nutsandbolts/op2.html">instanceOf</a></strong> operator but the wildcard type for the cast. <a href="http://bit.ly/fO9Hp9">Josh Bloch once again has a thorough explanation on this</a>.</p>
<p>Finally Comparable used with the <em>order</em> property is merely for making testing slightly easier (coming later on) and not really a requirement. Unless you do want your JSON elements sorted in which case is an easy way to go :) In that case you could have instead opted for the builder to increment the ordering for every element created.</p>
<h2 id="kudos">Kudos</h2>
<p>Google for the <a href="http://code.google.com/p/guava-libraries/">guava-libraries</a> (see <a href="http://guava-libraries.googlecode.com/svn/trunk/javadoc/com/google/common/base/Preconditions.html">Preconditions</a>)</p>
<p><em><a href="https://qnoid.com/2011/01/07/heterogenous-containers-JSON-part-2.html#main">Continue to Part 2</a></em></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t0Qu">Source</a></em></p>
]]></description>
        <pubDate>Wed, 05 Jan 2011 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... JDBC (Part 3)</title>
        <link>https://qnoid.com/2010/12/23/heterogenous-containers-JDBC-part-3.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/12/23/heterogenous-containers-JDBC-part-3.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Use to query for {@link Person}s
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PersonService</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * All columns related to the person.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Columns</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">ID</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Column</span><span class="p">.</span><span class="na">newIntegerType</span><span class="p">(</span><span class="s">&#34;id&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="n">NAME</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Column</span><span class="p">.</span><span class="na">newStringType</span><span class="p">(</span><span class="s">&#34;name&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DATE</span><span class="w"> </span><span class="o">=</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Column</span><span class="p">.</span><span class="na">newDateType</span><span class="p">(</span><span class="s">&#34;date&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Column</span><span class="o">&lt;?&gt;&gt;</span><span class="w"> </span><span class="n">ALL</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Column</span><span class="o">&lt;?&gt;&gt;</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="k">this</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">ID</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="k">this</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">NAME</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="k">this</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">DATE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Implementation of a template handler 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * to create a new Person out of a Row
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ResultSetHandler</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">PERSON_TEMPLATE_HANDLER</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">ResultSetListHandler</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">ALL</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">protected</span><span class="w"> </span><span class="n">Person</span><span class="w"> </span><span class="nf">newType</span><span class="p">(</span><span class="n">Row</span><span class="w"> </span><span class="n">row</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Integer</span><span class="w"> </span><span class="n">id</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">row</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">ID</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">row</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">NAME</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">Date</span><span class="w"> </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">row</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">Columns</span><span class="p">.</span><span class="na">DATE</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                    
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PersonBuilder</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">id</span><span class="p">(</span><span class="n">id</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">date</span><span class="p">(</span><span class="n">date</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">                               
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Handler to use when retrieving a list of {@link Person}s
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ResultSetHandler</span><span class="o">&lt;</span><span class="n">List</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;&gt;</span><span class="w"> </span><span class="n">PERSONS_HANDLER</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">ResultSetListHandler</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="p">(</span><span class="n">PERSON_TEMPLATE_HANDLER</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">SELECT_PERSONS</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="s">&#34;SELECT id, name, date, FROM person&#34;</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DataSource</span><span class="w"> </span><span class="n">datasource</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">PersonService</span><span class="p">(</span><span class="n">DataSource</span><span class="w"> </span><span class="n">datasource</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">datasource</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">datasource</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">list</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">SQLException</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">QueryRunner</span><span class="w"> </span><span class="n">queryRunner</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">QueryRunner</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">datasource</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">queryRunner</span><span class="p">.</span><span class="na">query</span><span class="p">(</span><span class="n">SELECT_PERSONS</span><span class="p">,</span><span class="w"> </span><span class="n">PERSONS_HANDLER</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
On our quest to explore the possibilities of <a href="https://qnoid.com/2010/12/12/heterogenous-containers-preamble.html#main">heterogeneous containers</a> under JDBC we introduced two higher level concepts above a ResultSet. Those of a <a href="https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-1.html#main">Column and a Row</a>, adding to the existing <a href="http://commons.apache.org/dbutils/">dbutils apache framework</a> by taking <a href="https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-2.html#main">advantage of ResultSetHandler</a>(s).</p>
<p>From the client code side all we have to do is define the columns related to the type we&rsquo;d like to query on as well as implement <em>TemplateResultSetHandler</em> to create an instance of it from a <em>Row</em>. Finally use a <em>MultipleResultSetHandler</em> to list all using a <a href="http://commons.apache.org/dbutils/apidocs/org/apache/commons/dbutils/QueryRunner.html" title="Part of DbUtils">QueryRunner</a>.</p>
<p>Going further you could introduce an annotation</p>
<pre><code>@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column
{
    Class&lt;?&gt; type();
    String name();
}
</code></pre>
<p>to define columns on the actual type like</p>
<pre><code>public class Person
{
      @Column(type=Integer.class, name=&quot;id&quot;)
      private final Integer id;
}
</code></pre>
<p>and with a little help from <a href="http://commons.apache.org/beanutils/">BeanUtils</a> you can <a href="http://commons.apache.org/beanutils/apidocs/org/apache/commons/beanutils/package-summary.html#overview">map them to your type</a> thus making a step towards creating a simple <a href="http://en.wikipedia.org/wiki/Create,_read,_update_and_delete">CRUD</a> framework.</p>
<p>Hopefully these posts gave you a better understanding over heterogeneous containers as well as spur some ideas on how to use them to your benefit.</p>
<p>Next on Heterogenous Containers, <strong><a href="https://qnoid.com/2011/01/05/heterogenous-containers-JSON-part-1.html#main">How to think of JSON</a></strong>.</p>
<p><em>You can read more about the <a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main" title="Honour your builders - Don't lose your train of thoughts">builder pattern</a> as part of the <a href="https://qnoid.com/2010/10/12/conclusion-dont-lose-your-train-of-thoughts.html#main">Don&rsquo;t lose your train of thoughts</a> series</em></p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t0RZ">Source</a></em></p>
]]></description>
        <pubDate>Thu, 23 Dec 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... JDBC (Part 2)</title>
        <link>https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-2.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-2.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * This class provides a way to retrieve all the values in a result set based
</span></span></span><span class="line"><span class="cl"><span class="cm">     * on the columns specified and create a new object of type {@code T} based on 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * that values
</span></span></span><span class="line"><span class="cl"><span class="cm">     *
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Classes extending this class should provide an implementation for the 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * template method {@link #newType(Row)} which must return the object based on 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * the row&#39;s columns
</span></span></span><span class="line"><span class="cl"><span class="cm">     * @see ResultSetHandler
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TemplateResultSetHandler</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">ResultSetHandler</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Column</span><span class="o">&lt;?&gt;&gt;</span><span class="w"> </span><span class="n">columns</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param columns all columns available in the ResultSet
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">TemplateResultSetHandler</span><span class="p">(</span><span class="n">List</span><span class="o">&lt;</span><span class="n">Column</span><span class="o">&lt;?&gt;&gt;</span><span class="w"> </span><span class="n">columns</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">columns</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">columns</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * This method will iterate through all the columns 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * (as specified in the constructor) in the result set and provide a single 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * callback to the {@link #newType(Row)} with a Row object holding all the 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * column values.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param rs a ResultSet pointing to the row holding the next instance of {@code T}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return an object of type T as returned by the {@link #newType(Row)}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see ResultSet#next()
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">handle</span><span class="p">(</span><span class="n">ResultSet</span><span class="w"> </span><span class="n">rs</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">SQLException</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Row</span><span class="w"> </span><span class="n">row</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Row</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Column</span><span class="o">&lt;?&gt;</span><span class="w"> </span><span class="n">column</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">columns</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">row</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">column</span><span class="p">,</span><span class="w"> </span><span class="n">rs</span><span class="p">.</span><span class="na">getObject</span><span class="p">(</span><span class="n">column</span><span class="p">.</span><span class="na">name</span><span class="p">())</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">newType</span><span class="p">(</span><span class="w"> </span><span class="n">row</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Template method to be overridden and provide the type of object related
</span></span></span><span class="line"><span class="cl"><span class="cm">         * to the given row.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param row the row 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new object based on the column 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see Row#get(Column)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">protected</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">newType</span><span class="p">(</span><span class="n">Row</span><span class="w"> </span><span class="n">row</span><span class="p">);</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Our implementation of a ResultSetHandler (part of DbUtils)
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ResultSetListHandler</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">ResultSetHandler</span><span class="o">&lt;</span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">ResultSetHandler</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">handler</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param handler
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">ResultSetListHandler</span><span class="p">(</span><span class="n">ResultSetHandler</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">handler</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">handler</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">handler</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * This method will iterate through the result set and return a list of 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * objects as defined in the {@link ResultSetHandler} used in the 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * constructor
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see ResultSet#next()
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see ResultSetHandler#handle(ResultSet)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">handle</span><span class="p">(</span><span class="n">ResultSet</span><span class="w"> </span><span class="n">rs</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">SQLException</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">results</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">while</span><span class="p">(</span><span class="n">rs</span><span class="p">.</span><span class="na">next</span><span class="p">()){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">results</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">handler</span><span class="p">.</span><span class="na">handle</span><span class="p">(</span><span class="n">rs</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">results</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>During the <a href="https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-1.html#main">first part</a> of this post we identified 2 classes that we&rsquo;ll use as the corner stone for taking advantage of a heterogeneous container under JDBC.</p>
<p>DbUtils has a <a href="http://commons.apache.org/dbutils/apidocs/org/apache/commons/dbutils/ResultSetHandler.html">ResultSetHandler</a> interface where it clearly states that</p>
<blockquote>
<p>Implementations of this interface convert ResultSets into other objects.</p>
</blockquote>
<p>which pinpoints exactly where we would want to write the algorithm which populates the a Row instance as well as have a callback to a <a href="http://en.wikipedia.org/wiki/Template_method_pattern">template method</a> to create its corresponding object.</p>
<p>That template method is what will allow subclasses to create objects with the given Row which is populated with all the values required in a type safe manner!</p>
<p>You may notice that we call <em><a href="http://download.oracle.com/javase/6/docs/api/java/sql/ResultSet.html#getObject(java.lang.String)">ResultSet#getObject(String)</a></em> to retrieve the value for a given column and think that this is wrongly specified. If you read the Javadoc closely though you will notice that the type of the object is right there and is what allows us to take advantage of the heterogeneous container concept.</p>
<blockquote>
<p>This method will return the value of the given column as a Java object.  The type of the Java object will be the default Java object type corresponding to the column&rsquo;s SQL type, following the mapping for builtwin types specified in the JDBC specification.</p>
</blockquote>
<p>However in order to fail early we choose to <a href="https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-1.html#main">cast the object</a> in <em>Row#put</em>.</p>
<p>Also the reason to have the call to <em>ResultSet#next</em> outside of the <em>TemplateResultSetHandler</em> is to handle both single (mostly unique) results and list queries.</p>
<p>In the third and final part of the post we&rsquo;ll see how it all looks like from the <a href="https://qnoid.com/2010/12/23/heterogenous-containers-JDBC-part-3.html#main">client code side</a>.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t0mR">Source</a></em></p>
]]></description>
        <pubDate>Mon, 20 Dec 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... JDBC (Part 1)</title>
        <link>https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-1.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-1.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Defines a column in a table of a specified type under a given name.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Column</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newIntegerType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Integer</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Integer</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Long</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newLongType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Long</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Long</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newDateType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">Date</span><span class="o">&gt;</span><span class="p">(</span><span class="n">Date</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newStringType</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span><span class="p">(</span><span class="n">String</span><span class="p">.</span><span class="na">class</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">newColumn</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">clazz</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Column</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="p">(</span><span class="n">clazz</span><span class="p">,</span><span class="w"> </span><span class="n">name</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">clazz</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">Column</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">clazz</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">name</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">clazz</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">clazz</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">name</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">type</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">clazz</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">name</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">name</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">     * This class emulates a database row holding the columns&#39; values
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Row</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * A column can be of arbitrary type therefore we use 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * a heterogeneous map
</span></span></span><span class="line"><span class="cl"><span class="cm">         * to hold the different types of values 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Column</span><span class="o">&lt;?&gt;</span><span class="p">,</span><span class="w"> </span><span class="n">Object</span><span class="o">&gt;</span><span class="w"> </span><span class="n">columns</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Row</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">columns</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HashMap</span><span class="o">&lt;</span><span class="n">Column</span><span class="o">&lt;?&gt;</span><span class="p">,</span><span class="w"> </span><span class="n">Object</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Returns the value for the specified column 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param column the column to get the value for
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the value of the column
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="n">Column</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">column</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">column</span><span class="p">.</span><span class="na">type</span><span class="p">().</span><span class="na">cast</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">columns</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">column</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Adds a new column value
</span></span></span><span class="line"><span class="cl"><span class="cm">         *
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param column the column related to the value
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param value the value under that column
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @throws InvalidColumnType if the column type specified for 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * the value is wrong
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">put</span><span class="p">(</span><span class="n">Column</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">column</span><span class="p">,</span><span class="w"> </span><span class="n">Object</span><span class="w"> </span><span class="n">value</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">column</span><span class="p">.</span><span class="na">type</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * early cast just in case the column type is wrongly specified
</span></span></span><span class="line"><span class="cl"><span class="cm">             * as opposed to the actual
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">try</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">T</span><span class="w"> </span><span class="n">typed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">type</span><span class="p">.</span><span class="na">cast</span><span class="p">(</span><span class="n">value</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">columns</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">column</span><span class="p">,</span><span class="w"> </span><span class="n">typed</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">catch</span><span class="p">(</span><span class="n">ClassCastException</span><span class="w"> </span><span class="n">e</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">InvalidColumnType</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="s">&#34;Actual type for column &#39;%s&#39; is %s&#34;</span><span class="p">,</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="n">column</span><span class="p">.</span><span class="na">name</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="n">value</span><span class="p">.</span><span class="na">getClass</span><span class="p">().</span><span class="na">getSimpleName</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                </span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>On the <a href="https://qnoid.com/2010/12/12/heterogenous-containers-preamble.html#main" title="A heterogeneous typesafe List">preamble</a> we identified a list that allows us to add <strong>any type</strong> of object and retrieve it back to its actual type. Let&rsquo;s see how we can benefit from a similar typesafe heterogeneous container in conjuction with <a href="http://en.wikipedia.org/wiki/Java_Database_Connectivity">JDBC</a> which has been around well before generics.</p>
<p>First thing is to define a <em>Column</em> class which merely describes a table column. All it takes is its <em>name</em> and its <em>type</em>. In JDBC you use a <a href="http://download.oracle.com/javase/6/docs/api/java/sql/ResultSet.html">ResultSet</a> to <a href="http://download.oracle.com/javase/6/docs/api/java/sql/ResultSet.html#getObject(java.lang.String)">retrieve the value</a> of a column as you <a href="http://download.oracle.com/javase/6/docs/api/java/sql/ResultSet.html#next()">iterate</a> through it.</p>
<p>So the Column class not only specifies the column name you need to get the value from but will also give you the right class to cast it to the correct type!</p>
<p>Second is a <em>Row</em> class which is the actual heterogeneous container holding each column and its value. We&rsquo;ll use that as we iterate through the ResultSet to put the value for each column. This Row instance is what we&rsquo;ll also use to query for a column and get its value in the actual type.</p>
<p>In general when thinking of such containers there are two things to have in mind.</p>
<ul>
<li>a <a href="http://download.oracle.com/javase/6/docs/api/java/util/Map.html" title="All about key/value">Map</a> that&rsquo;s used as a storage for your heterogeneous type objects</li>
<li>a <a href="http://download.oracle.com/javase/6/docs/api/java/lang/Class.html">Class</a> instance to allow you to cast to the actual type</li>
</ul>
<p><a href="https://qnoid.com/2010/12/20/heterogenous-containers-JDBC-part-2.html#main">In the second part</a> we&rsquo;ll see how it all comes together in conjunction with <a href="http://commons.apache.org/dbutils/">Apache&rsquo;s DbUtils</a> library to make plain JDBC fun.</p>
<p><strong>Kudos</strong> to the <a href="http://www.apache.org/">Apache Foundation</a> which has been around since 1999 providing all that great open source software making developers&rsquo; lives easier.</p>
<p><em><a href="https://github.com/qnoid/qnoid/tree/master/src/main/java/com/qnoid/java/t0SA">Source</a></em></p>
]]></description>
        <pubDate>Mon, 20 Dec 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Heterogenous Containers... Preamble</title>
        <link>https://qnoid.com/2010/12/12/heterogenous-containers-preamble.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/12/12/heterogenous-containers-preamble.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Person</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Designer</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Person</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Developer</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Person</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A heterogenous list
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">HeterogenousList</span><span class="o">&lt;</span><span class="n">E</span><span class="o">&gt;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Map</span><span class="o">&lt;</span><span class="n">Class</span><span class="o">&lt;?&gt;</span><span class="p">,</span><span class="w"> </span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">elements</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">HashMap</span><span class="o">&lt;</span><span class="n">Class</span><span class="o">&lt;?&gt;</span><span class="p">,</span><span class="w"> </span><span class="n">E</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="n">E</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">this</span><span class="p">.</span><span class="na">elements</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="n">e</span><span class="p">.</span><span class="na">getClass</span><span class="p">(),</span><span class="w"> </span><span class="n">e</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="o">&lt;</span><span class="n">T</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">E</span><span class="o">&gt;</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="nf">get</span><span class="p">(</span><span class="n">Class</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><span class="w"> </span><span class="n">type</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">E</span><span class="w"> </span><span class="n">element</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">elements</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">type</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">element</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="kc">null</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">NoSuchElementException</span><span class="p">(</span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;No element of type: %s&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">type</span><span class="p">.</span><span class="na">getSimpleName</span><span class="p">()));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">type</span><span class="p">.</span><span class="na">cast</span><span class="p">(</span><span class="w"> </span><span class="n">element</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s see how it feels like
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PersonsTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">homogeneous</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Developer</span><span class="w"> </span><span class="n">developer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Developer</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Designer</span><span class="w"> </span><span class="n">designer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Designer</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">persons</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="p">();</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">persons</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">developer</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">persons</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">designer</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="n">DEVELOPER_INDEX</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kt">int</span><span class="w"> </span><span class="n">DESIGNER_INDEX</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Person</span><span class="w"> </span><span class="n">theDeveloper</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">persons</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">DEVELOPER_INDEX</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Person</span><span class="w"> </span><span class="n">theDesigner</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">persons</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">DESIGNER_INDEX</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">developer</span><span class="p">,</span><span class="w"> </span><span class="n">theDeveloper</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">designer</span><span class="p">,</span><span class="w"> </span><span class="n">theDesigner</span><span class="p">);</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">heterogeneous</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Developer</span><span class="w"> </span><span class="n">developer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Developer</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Designer</span><span class="w"> </span><span class="n">designer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Designer</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">HeterogenousList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">persons</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HeterogenousList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="p">();</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">persons</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">developer</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">persons</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">designer</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">Developer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DEVELOPER_INDEX</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Developer</span><span class="p">.</span><span class="na">class</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">Designer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DESIGNER_INDEX</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Designer</span><span class="p">.</span><span class="na">class</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Developer</span><span class="w"> </span><span class="n">theDeveloper</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">persons</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">DEVELOPER_INDEX</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Designer</span><span class="w"> </span><span class="n">theDesigner</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">persons</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">DESIGNER_INDEX</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">developer</span><span class="p">,</span><span class="w"> </span><span class="n">theDeveloper</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">designer</span><span class="p">,</span><span class="w"> </span><span class="n">theDesigner</span><span class="p">);</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="p">(</span><span class="n">expected</span><span class="o">=</span><span class="n">NoSuchElementException</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">noSuchElementException</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">HeterogenousList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">persons</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HeterogenousList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="p">();</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">persons</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Developer</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Class</span><span class="o">&lt;</span><span class="n">Designer</span><span class="o">&gt;</span><span class="w"> </span><span class="n">DESIGNER_INDEX</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Designer</span><span class="p">.</span><span class="na">class</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">persons</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">DESIGNER_INDEX</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">incorrectType</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">HeterogenousList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="w"> </span><span class="n">persons</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HeterogenousList</span><span class="o">&lt;</span><span class="n">Person</span><span class="o">&gt;</span><span class="p">();</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">//compile error</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">persons</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">String</span><span class="p">.</span><span class="na">class</span><span class="p">);</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<a href="http://twitter.com/joshbloch">Joshua Bloch</a> asked us to consider <a href="http://books.google.co.uk/books?id=ka2VUBqHiWkC&amp;pg=PA142&amp;lpg=PA142#v=onepage&amp;q&amp;f=false" title="Effective Java, 2nd Edition, Item 29">typesafe heterogenous containers</a>. You should do well to read about them but loosely speaking you can think of such a data structure as a list. A heterogenous that is.</p>
<p>Since Java 5 with the introduction of generics you could specify the type of a list.</p>
<p>That way the compiler makes sure you don&rsquo;t accidentaly add an object of different type than expected as well as you get the right one back when you ask for it.</p>
<p>However, you are still limited to the inherited type of the object you add.</p>
<p>Instead with a heterogenous container you get the <strong>actual</strong> type back.</p>
<p>The only difference is that the index of your list now becomes the type rather an int specifying its position.</p>
<p>The</p>
<pre><code>T extends E
</code></pre>
<p>merely specifies that any type requested must be a subclass of the type specified in the list. This saves you from passing arbitrary types, yet you still need to accommodate asking for valid types that aren&rsquo;t added to the list.</p>
<p>In the posts to come we&rsquo;ll explore the possibilities of such containers.</p>
<p><em><a href="https://github.com/qnoid/forrst/tree/master/src/main/java/com/forrst/java/tBUU">Source</a></em></p>
]]></description>
        <pubDate>Sun, 12 Dec 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>What Type Of Msc Do You Think Will Prove More Valuable?</title>
        <link>https://qnoid.com/2010/10/21/What-type-of-MSc-do-you-think-will-prove-more-valuable.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/21/What-type-of-MSc-do-you-think-will-prove-more-valuable.html</guid>
        <description><![CDATA[<p>Coming from a BSc Information Technology degree (class of 2003) I didn&rsquo;t do an MSc at the time so as to get some experience first before actually deciding on one. So I really see it both as an opportunity to extend my knowledge further and as an asset for what I&rsquo;d like to achieve.</p>
<p>The degree that I have is not a strong computer science degree. It hasn&rsquo;t really become a limiting factor so far in terms of finding a job or getting things done, though I do fail miserably when it comes to data structures and algorithms.</p>
<p>Moving forward I&rsquo;d like to venture into starting my own company so I&rsquo;m really looking for the most valuable MSc to achieve my goal.</p>
<p>The most obvious choice is an MSc in <a href="http://www.courses.napier.ac.uk/W31612.htm">Business Management with Entrepreneurship</a> which will help me understand more about what it takes to start your own business. Napier University seems to be <a href="http://www.napier.ac.uk/business-school/SchoolsandCentres/Pages/CentreforEntrepreneurship.aspx">closely tied to entrepreneurship</a> which might also help during take off. On the other hand there are many examples of people that didn&rsquo;t really need an MSc for their succesful startup, so it doesn&rsquo;t look like it&rsquo;s that &ldquo;valuable&rdquo;.</p>
<p>The second choice is doing a purely technical skill driven MSc like <a href="http://www.inf.ed.ac.uk/postgraduate/lfd/">Learning from Data</a>. Managing data is becoming more important than ever and it doesn&rsquo;t look like it&rsquo;s going to become obsolete any time soon. The nature of the startup that I&rsquo;d like to kickoff will rely heavily on data so it&rsquo;s probably an important MSc to have. Also, in case I crush and burn this MSc will probably prove more valuable in exploring new job opportunities.</p>
<p>The third one is a joined one between IT and Philosopy or Social Sciences in general. Definitely the less valuable from all three but will help in broadening my ideas on how IT can help local societies grow. (which is also part of what I&rsquo;d like to achieve through the startup)</p>
<p>So I&rsquo;d really like to take an advice based on your experiences.
Whether you already have a startup and think one of the (two) MSc did or could help you or purely from your own perspective.</p>
<p>Do you hold an MSc yourself? Did it prove valuable and how?</p>
]]></description>
        <pubDate>Thu, 21 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>How To Think Of... Recursion</title>
        <link>https://qnoid.com/2010/10/18/recursion.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/18/recursion.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * An integer with extended operations 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ForrstInteger</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param number
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">ForrstInteger</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">number</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">number</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Multiply the number that many times.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param number the number to multiply
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param times how many times to multiply it
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the total after multiplying the number or 0 if times is 0
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">multiply</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">times</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">times</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="n">0</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">number</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">multiply</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="o">--</span><span class="n">times</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Multiplies the number by times
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param times how many times to multiple the number
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the multiple of the number
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">multiply</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">times</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">multiply</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">number</span><span class="p">,</span><span class="w"> </span><span class="n">times</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s prove our recursion theory
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@RunWith</span><span class="p">(</span><span class="n">Theories</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ForrstNumberTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@DataPoints</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="o">[]</span><span class="w"> </span><span class="n">numbers</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">3</span><span class="p">,</span><span class="w"> </span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">5</span><span class="p">,</span><span class="w"> </span><span class="n">6</span><span class="p">,</span><span class="w"> </span><span class="n">7</span><span class="p">,</span><span class="w"> </span><span class="n">8</span><span class="p">,</span><span class="w"> </span><span class="n">9</span><span class="p">,</span><span class="w"> </span><span class="n">10</span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Theory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">multiplyByOne</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">actual</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ForrstInteger</span><span class="p">(</span><span class="n">number</span><span class="p">).</span><span class="na">multiply</span><span class="p">(</span><span class="n">1</span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">actual</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Theory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">multiplyByZero</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">actual</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ForrstInteger</span><span class="p">(</span><span class="n">number</span><span class="p">).</span><span class="na">multiply</span><span class="p">(</span><span class="n">0</span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">actual</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Theory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">multiplyByTimes</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">times</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">print</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;%s * %s = &#34;</span><span class="p">,</span><span class="w"> </span><span class="n">number</span><span class="p">,</span><span class="w"> </span><span class="n">multiply</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">actual</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ForrstInteger</span><span class="p">(</span><span class="n">number</span><span class="p">).</span><span class="na">multiply</span><span class="p">(</span><span class="n">times</span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="n">actual</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">number</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">times</span><span class="p">,</span><span class="w"> </span><span class="n">actual</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Recursion seems to scare people away but if you follow these simple rules it can become your best friend.
Although it does sound complicated, its sole purpose is <strong>to simplify</strong> a problem.</p>
<p>The most difficult thing about a <a href="http://www.google.com/search?q=recursion">recursion</a> is to identify a problem as such.
You will know you have encountered a recursion when you see a pattern being repeated again and again.</p>
<p>Isn&rsquo;t that a loop you say?
Well the main difference with a normal loop is that the result of a recursion solely depends on the outcome of the recursion itself. Confused?</p>
<p>Take for example multiplication. If you think about it, multiplication is a disguised addition.</p>
<pre><code>2 * 4 = 2 + 2 + 2 + 2 = 8
</code></pre>
<p>So to come up with 8 as the result you had to follow this pattern</p>
<pre><code>0 + 2 = 2
2 + 2 = 4 
4 + 2 = 6 
6 + 2 = 8 
</code></pre>
<p>Which means <strong>add 2 everytime, 4 times</strong> starting with 0.</p>
<p>Let&rsquo;s take it backwards for a minute.</p>
<pre><code>6 + 2 = 8 //how did you come up with 6?
4 + 2 = 6 //how did you come up with 4?
2 + 2 = 4 //how did you come up with 2?
0 + 2 = 2 //You don't have to calculate 0! (**Hint**)
</code></pre>
<p>The problem is that you don&rsquo;t know which number to add to 2 every time since you haven&rsquo;t calculated yet! So what you really have is something like this</p>
<pre><code>2 + x = 8 
2 + x = 6 
2 + x = 4
2 + 0 = 2 //notice the pattern changing by adding 0 this time.
</code></pre>
<p>Do you notice the recursion?</p>
<pre><code>2 + x
</code></pre>
<p>where x is <strong>the next number to add</strong> until it&rsquo;s the 0 which ends the recursion. Which is your stop condition!</p>
<p>So in essence once you have identified a recursion problem there are 2 things you have to think.</p>
<ul>
<li>What is the recursion</li>
<li>What is the stop condition</li>
</ul>
<p>Failing to identify a stop condition will most likely lead to an infinite loop and a possible <a href="http://downloadwllnw.oracle.com/javase/6/docs/api/java/lang/StackOverflowError.html">StackOverFlowError</a> or <a href="http://downloadwllnw.oracle.com/javase/6/docs/api/java/lang/OutOfMemoryError.html">OutOfMemoryException</a>. Both pretty nasty.</p>
<p>Now try and identify the recursion needed to raise a number to a given integer power. (don&rsquo;t bother more than an integer power,  <a href="http://bit.ly/dlZcP6">though it involves much more than that</a>)</p>
<p><em>The first one to reply to this post with a solution (<strong>and a test to prove it!</strong>) will receive a Kudoz postcard from Edinburgh :)</em></p>
<p>Can you find any other recursions? Leave your comments below.</p>
<p><strong>Update:</strong> Don&rsquo;t bother with NaN or infinite values like the <em>Math#pow(double, double)</em>, just do it for 0 to 10 like the test above. Just follow the recursion example and it&rsquo;s easy to come up with it :)</p>
<p><em><a href="https://github.com/qnoid/forrst/tree/master/src/main/java/com/forrst/java/t7cW">Source</a></em></p>
]]></description>
        <pubDate>Mon, 18 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Evaluation ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/10/13/evaluation-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/13/evaluation-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<blockquote>
<p>It&rsquo;s time for your code</p>
</blockquote>
<p>The <a href="https://qnoid.com/2010/10/12/conclusion-dont-lose-your-train-of-thoughts.html#main">Don&rsquo;t lose your train of thoughts</a> started out with <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">quite an excitement</a> and <a href="http://forrst.com/posts/You_need_to_kno-_grammar_not_math_to_do_Object_Or-unm#comment-61695">some early critisism</a> :) (even became a popular post at the time!) but unfortunately didn&rsquo;t stir the community as mush as I would have hoped. Wishing there was more interaction with people leaving comments, raising their concerns or providing just some feedback.</p>
<p>It did however create enough content with 8 posts about software design all coming out <strong>from a single paragraph</strong> of text.</p>
<p>Some <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">liked by many but talked by none</a>, other <a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main">didn&rsquo;t seem as popular</a>.</p>
<p>As far as the community goes, one <a href="http://forrst.com/posts/Preamble_-_Don_t_lose_your_train_of_thoughts-uZU#comment-64014">went missing</a>, <a href="http://forrst.com/posts/Introduction_-_Don_t_lose_your_train_of_thoughts-uZ8#comment-69124">one was bitter</a>, couple <a href="http://forrst.com/posts/Class_Relationships_-_Don_t_lose_your_train_of_tho-yO2#comment-69458">had a go at things</a> and shared <a href="http://forrst.com/posts/Class_Relationships_-_Don_t_lose_your_train_of_tho-yO2#comment-94405">their thoughts</a>, while others were <a href="http://forrst.com/posts/Apply_reasoning_-_Don_t_lose_your_train_of_thought-XeP#comment-78495">puzzled</a> and <a href="http://forrst.com/posts/Don_t_underestimate_the_factories_-_Don_t_lose_you-7zo#comment-106806">confused</a>.</p>
<p>It even <a href="http://forrst.com/posts/Strive_for_reusability_-_Don_t_lose_your_train_of-hPx#comment-96574">managed to inspire</a> so as to write object oriented code and that&rsquo;s quite an achievement.</p>
<p>Each post would usually take around 45&rsquo; to write. Though there was a rough idea where it was going, it was <strong>written on the spot</strong> and only went through some editting to get the form and style right making sure it&rsquo;s coherent and easy to follow.</p>
<p>Was surpised that although the examples were Java based they didn&rsquo;t scare people away and even coders with a different background liked them.</p>
<p>It lasted roughly a month at an approximate average rate of 1 post per 3 days generating in total (at the time of writing)</p>
<ul>
<li>86   Likes</li>
<li>23   Comments</li>
<li>552 Views</li>
</ul>
<p>Also identified what I refer to as the the @kyle <a href="https://qnoid.com/2010/10/08/marker-interfaces-dont-lose-your-train-of-thoughts.html#main">effect</a>. It looks like every time kyle liked a post it spur the interest of people as there was a tremendous spike on views. Trying to interprent that, is either because @kyle has a lot of followers and people usually look for posts through the &ldquo;Activity from friends&rdquo; tab (hence more exposure) or that @kyle has a greater appeal :)</p>
<p>There is <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">one exception to that rule</a> when he was &ldquo;late to the party&rdquo;.</p>
<p>That might also mean that as the community grows it might get more difficult to discover relevant posts.</p>
<p>In any case the above are only personal guesses as I don&rsquo;t have any metrics on how people interact with the site.</p>
<p><strong>Kudoz</strong> to YOU for participating in this!</p>
]]></description>
        <pubDate>Wed, 13 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Conclusion ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/10/12/conclusion-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/12/conclusion-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<p>The <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">Don&rsquo;t lose your train of thoughts</a> series is over. In case this is the first time you hear about it, it was a series of posts about how you go on designing software in an OO world. All the way from analysing requirements to design, development and testing along with <strong>a lot of reasoning</strong> on how to go on about things.</p>
<p>It all started with the SurvivalKit specification. The great thing about the series was that nothing was scripted, and there were no actors or stooges leaving a comment, or asking all the questions :)</p>
<p>Each post was &ldquo;created on the fly&rdquo; trying to mimic real world software development conditions.
Still bare in mind that it was example code and not complete by any means.</p>
<p>Another characteristic was making the code as &ldquo;copy/paste safe&rdquo; as possible. Example code shouldn&rsquo;t violate basic principles which could cause people inheriting bad practices.</p>
<p>Finally, tried not to go astray so as not to confuse people with superflous details. A non technical jargon was also used for greater appeal.</p>
<p>Below is the TOC for the series</p>
<ul>
<li><a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">Preamble</a> - What is an Object?</li>
<li><a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">Introduction</a> - Where to start</li>
<li><a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">Class Relationships</a> - The importance of a healthy relationship</li>
<li><a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">Design for Immutability</a> - Consider your state</li>
<li><a href="https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html#main">Design decisions</a> - Think before you act</li>
<li><a href="https://qnoid.com/2010/09/27/reusability-dont-lose-your-train-of-thoughts.html#main">The controller</a> - Introducing the controller</li>
<li><a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main">Builder pattern</a> - Creating objects the fun way</li>
<li><a href="https://qnoid.com/2010/10/08/marker-interfaces-dont-lose-your-train-of-thoughts.html#main">How to think of interfaces</a> - How an interface can help</li>
<li><a href="https://qnoid.com/2010/10/11/factory-type-dont-lose-your-train-of-thoughts.html#main">The Factory</a> - A valuable cliche</li>
</ul>
<p>Don&rsquo;t get sad as there are plenty of posts in the queue to write about, expanding on some ideas roughly touched in the series.
There is still the <a href="https://qnoid.com/2010/08/30/types.html#main">Don&rsquo;t Abuse The If</a> and coming up the <a href="https://qnoid.com/2011/01/16/inheritance.html#main">Don&rsquo;t Abuse Inheritance</a> and Don&rsquo;t Abuse The For as well as plenty other standalone but <a href="https://qnoid.com/2010/08/05/the-reason-behind-finally.html#main">hopefully as inspiring</a>.</p>
<p>Do get in touch on <strong>what you are interested</strong> in seeing on <code>qnoid.com</code> when it comes to object oriented and software design or even write your own code that you want to talk about!</p>
<p><em>An aftermath post will follow with some <a href="https://qnoid.com/2010/10/13/evaluation-dont-lose-your-train-of-thoughts.html#main">general remarks and statistics about the series</a></em></p>
]]></description>
        <pubDate>Tue, 12 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Factory type ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/10/11/factory-type-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/11/factory-type-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Use it to create survival kits!
</span></span></span><span class="line"><span class="cl"><span class="cm">     * 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Don&#39;t be afraid to use the {@link SurvivalKitBuilder} to create your own
</span></span></span><span class="line"><span class="cl"><span class="cm">     * custom configuration of a kit! 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKitFactory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * By default a survival kit contains a t-shirt of your specified size, 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * a mug, a wristband and 2 stickers. Hubba, hubba!
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param size the size of your kit
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a freshly made survival kit just for you
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="w"> </span><span class="nf">newSurvivalKit</span><span class="p">(</span><span class="n">Size</span><span class="w"> </span><span class="n">size</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKitBuilder</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">new</span><span class="w"> </span><span class="n">TShirt</span><span class="p">(</span><span class="n">size</span><span class="p">,</span><span class="w"> </span><span class="n">Material</span><span class="p">.</span><span class="na">COTTON</span><span class="p">),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">new</span><span class="w"> </span><span class="n">Mug</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">new</span><span class="w"> </span><span class="n">Wristband</span><span class="p">())</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">Collections</span><span class="p">.</span><span class="na">nCopies</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Sticker</span><span class="p">(</span><span class="n">Material</span><span class="p">.</span><span class="na">VINYL</span><span class="p">))</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a SurvivalKit without the TShirt
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="w"> </span><span class="nf">newValueSurvivalKit</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKitBuilder</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">Mug</span><span class="p">(),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">new</span><span class="w"> </span><span class="n">Wristband</span><span class="p">())</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">Collections</span><span class="p">.</span><span class="na">nCopies</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Sticker</span><span class="p">(</span><span class="n">Material</span><span class="p">.</span><span class="na">VINYL</span><span class="p">))</span><span class="w"> </span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>The <a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main">builder</a> for the SurvivalKit came handy for as long as we had <strong>only a single configuration</strong> to create.</p>
<p>However, <a href="https://qnoid.com/2010/10/08/marker-interfaces-dont-lose-your-train-of-thoughts.html#main">defining the SurvivalKitItem</a> now allows us to have kits with varying items. Thus different configurations.</p>
<p>So how can our builder accomodate for that change? Let&rsquo;s find out.</p>
<p>You could put in a flag along with a switch statement which produces a different kit every time but that would mean that <a href="https://qnoid.com/2010/08/30/types.html#main">you are abusing the if</a>.
Could you use the Strategy pattern then in the same manner? You could, but there is a much more elegant way to go about it, that is use a factory.</p>
<p>You might think that the factory makes the builder obsolete. Far from it. It&rsquo;s actually complementary by <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">using the builder</a> to create different configurations for the kit.</p>
<p>Notice how the builder provides the methods to customize the kit in addition to reasonable constants and defaults.
The factory on the other hand holds all the new operators that make up a kit each time.</p>
<p>Not only you have encapsulated construction of the SurvivalKit that way but also provided custom instances.</p>
<p>Be careful not to abuse it by providing every possible custom configuration for the kit. Your client code should still be able to use the <a href="http://bit.ly/cvjAWv">builder as intended</a>.</p>
]]></description>
        <pubDate>Mon, 11 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Marker Interfaces ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/10/08/marker-interfaces-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/08/marker-interfaces-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A new and improved SurvivalKit supporting any items you like!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKit</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Helps you build a survival kit and customize it the way you like!
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKitBuilder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">Size</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">TWO_XL</span><span class="p">,</span><span class="w"> </span><span class="n">XL</span><span class="p">,</span><span class="w"> </span><span class="n">LARGE</span><span class="p">,</span><span class="w"> </span><span class="n">MEDIUM</span><span class="p">,</span><span class="w"> </span><span class="n">SMALL</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">COST</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">29</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Collection</span><span class="w"> </span><span class="o">&lt;</span><span class="n">SurvivalKitItem</span><span class="o">&gt;</span><span class="w"> </span><span class="n">items</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="nf">SurvivalKitBuilder</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">items</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">SurvivalKitItem</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @param items the items to add
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @return the builder for chaining
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKitBuilder</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="n">SurvivalKitItem</span><span class="p">...</span><span class="w"> </span><span class="n">items</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">Arrays</span><span class="p">.</span><span class="na">asList</span><span class="p">(</span><span class="n">items</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @param items the items to add
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @return the builder for chaining
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKitBuilder</span><span class="w"> </span><span class="nf">add</span><span class="p">(</span><span class="n">List</span><span class="o">&lt;?</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">SurvivalKitItem</span><span class="o">&gt;</span><span class="w"> </span><span class="n">items</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">items</span><span class="p">.</span><span class="na">addAll</span><span class="p">(</span><span class="n">items</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @return a new SurvivalKit containing all the items
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="w"> </span><span class="nf">build</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">items</span><span class="p">,</span><span class="w"> </span><span class="n">COST</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Having a collection of items will eliminate the need for null
</span></span></span><span class="line"><span class="cl"><span class="cm">         * plus we can use the {@link SurvivalKit} to include even more
</span></span></span><span class="line"><span class="cl"><span class="cm">         * items in the future without changing a single line of code!
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Future items can be added to the survival kit!
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Collection</span><span class="w"> </span><span class="o">&lt;</span><span class="n">SurvivalKitItem</span><span class="o">&gt;</span><span class="w"> </span><span class="n">items</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param items what will your kit have
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param cost what it costs
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">SurvivalKit</span><span class="p">(</span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKitItem</span><span class="o">&gt;</span><span class="w"> </span><span class="n">items</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">cost</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">items</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">items</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">cost</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the items
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKitItem</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">getItems</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">items</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the cost
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">getCost</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The &#34;marker&#34; interface
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">SurvivalKitItem</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Mark your items!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">TShirt</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">SurvivalKitItem</span><span class="p">{}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Wristband</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">SurvivalKitItem</span><span class="p">{}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Sticker</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">SurvivalKitItem</span><span class="p">{}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Mug</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">SurvivalKitItem</span><span class="p">{}</span></span></span></code></pre></div>
<p>The survival kit has been great so far. We identified <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">its class</a> and also defined a <a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main">builder</a> to help us create new kits the fun way.</p>
<p>That was until <a href="http://twitter.com/kylebragger">Kyle</a> decided that there can be <a href="http://forrst.com/posts/Update_Okay_so_the_cat_s_out_of_the_bag_The-uDm#comment-57038">one without a TShirt</a>.
So how would you go on about it?</p>
<p>There is the option to create a new SurvivalKit class without the TShirt. But in doing so you have to also think of all the relationships that it has. Like <a href="https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html#main">SurvivalKitOrder</a> or the <a href="https://qnoid.com/2010/09/27/reusability-dont-lose-your-train-of-thoughts.html#main">ForrstController</a>. Will you create extra classes for those relationships as well? Your code isn&rsquo;t that <a href="http://en.wikipedia.org/wiki/Don't_repeat_yourself">DRY</a> anymore.</p>
<p>You could use a base survival kit which includes everything but a TShirt and have your SurvivalKit extend that, adding a TShirt. <a href="https://qnoid.com/2011/01/16/inheritance.html#main">You are abusing inheritance now</a>.</p>
<p>You can simply use your existing SurvivalKit class and just use a null value anytime you don&rsquo;t want a TShirt. By doing so though you will end up having to check every time you access the TShirt if it&rsquo;s null or not. What&rsquo;s worse is <a href="https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html#main">if you have to make a decision based on that</a> when you really shouldn&rsquo;t.</p>
<p>How will you handle a future SurvivalKit that may have less or even more items (<em>Hint</em>) that go with it? You start to notice that this doesn&rsquo;t scale well.</p>
<p>The real question you have to ask yourself is, &ldquo;How much different are those SurvivalKit(s)?&rdquo;. Talking about different survival kit&rsquo;s is more directly related to <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">different implementations</a> rather on the properties that make it up.</p>
<p>If you rethink of what defines a SurvivalKit you will come to realise that it&rsquo;s merely the items that is has. So you could say that the TShirt, the Mug, the Wristband and the Sticker are all <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">SurvivalKitItem(s)</a>.</p>
<p>From the <a href="http://img101.imageshack.us/img101/8135/survivalkit.png">description of the kit</a> we can&rsquo;t really tell anything about a SurvivalKitItem yet we can simply define a <a href="http://en.wikipedia.org/wiki/Marker_interface_pattern">marker interface</a> that designates all the items that can be added to the kit.</p>
<p>All you have to do is have each implement the SurvivalKitItem interface.</p>
<p><em>You can see that the SurvivalKit#build no longer returns a new kit. So <a href="https://qnoid.com/2010/10/11/factory-type-dont-lose-your-train-of-thoughts.html#main">where do we specify the custom kit that we want</a>?</em></p>
]]></description>
        <pubDate>Fri, 08 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Parse a date with a variable format</title>
        <link>https://qnoid.com/2010/10/05/Parse-a-date-with-a-variable-format.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/10/05/Parse-a-date-with-a-variable-format.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Don&#39;t use *Util classes as they are deemed to have throw away code
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">DateUtil</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">ddMMyyyyDashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;dd-MM-yyyy&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">yyyyMMddDashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;yyyy-MM-dd&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">ddMMyyyySlashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;dd/MM/yyyy&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">yyyyMMddSlashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;yyyy/MM/dd&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">         
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="nf">textToDate</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">text</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Date</span><span class="w"> </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">try</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ddMMyyyyDashed</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="n">text</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w"> </span><span class="k">catch</span><span class="w"> </span><span class="p">(</span><span class="n">java</span><span class="p">.</span><span class="na">text</span><span class="p">.</span><span class="na">ParseException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">try</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">yyyyMMddDashed</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="n">text</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w"> </span><span class="k">catch</span><span class="w"> </span><span class="p">(</span><span class="n">java</span><span class="p">.</span><span class="na">text</span><span class="p">.</span><span class="na">ParseException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">try</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ddMMyyyySlashed</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="n">text</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w"> </span><span class="k">catch</span><span class="w"> </span><span class="p">(</span><span class="n">java</span><span class="p">.</span><span class="na">text</span><span class="p">.</span><span class="na">ParseException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">try</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">yyyyMMddSlashed</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="n">text</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w"> </span><span class="k">catch</span><span class="w"> </span><span class="p">(</span><span class="n">java</span><span class="p">.</span><span class="na">text</span><span class="p">.</span><span class="na">ParseException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Date is: &#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">date</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">date</span><span class="p">;</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     *
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A date format that can be used to parse a date using a number of 
</span></span></span><span class="line"><span class="cl"><span class="cm">     * {@link DateFormat}s
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CompositeDateFormat</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">ddMMyyyyDashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;dd-MM-yyyy&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">setLenient</span><span class="p">(</span><span class="kc">false</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">yyyyMMddDashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;yyyy-MM-dd&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">setLenient</span><span class="p">(</span><span class="kc">false</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">ddMMyyyySlashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;dd/MM/yyyy&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">setLenient</span><span class="p">(</span><span class="kc">false</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="w"> </span><span class="n">yyyyMMddSlashed</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SimpleDateFormat</span><span class="p">(</span><span class="s">&#34;yyyy/MM/dd&#34;</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">setLenient</span><span class="p">(</span><span class="kc">false</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new {@link CompositeDateFormat} which will parse any date in
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;ul&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt;dd-MM-yyyy&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt;yyyy-MM-dd&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt;dd/MM/yyyy&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         *  &lt;li&gt;yyyy/MM/dd&lt;/li&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &lt;/ul&gt;
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * format
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see #parse(String)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">CompositeDateFormat</span><span class="w"> </span><span class="nf">newDateFormat</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">newDateFormat</span><span class="p">(</span><span class="n">ddMMyyyyDashed</span><span class="p">,</span><span class="w"> </span><span class="n">yyyyMMddDashed</span><span class="p">,</span><span class="w"> </span><span class="n">ddMMyyyySlashed</span><span class="p">,</span><span class="w"> </span><span class="n">yyyyMMddSlashed</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Create a new CompositeDateFormat which will parse the dates in the same order as the DateFormat(s) are supplied
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param dateformats the date formats to include when parsing a date using
</span></span></span><span class="line"><span class="cl"><span class="cm">         * this format
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new {@link CompositeDateFormat} with the specified formats
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">CompositeDateFormat</span><span class="w"> </span><span class="nf">newDateFormat</span><span class="p">(</span><span class="n">DateFormat</span><span class="p">...</span><span class="w"> </span><span class="n">dateformats</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">CompositeDateFormat</span><span class="p">(</span><span class="n">dateformats</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">DateFormat</span><span class="o">[]</span><span class="w"> </span><span class="n">dateformats</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param dateformats the date formats to use when parsing a date
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">CompositeDateFormat</span><span class="p">(</span><span class="n">DateFormat</span><span class="p">...</span><span class="w"> </span><span class="n">dateformats</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">dateformats</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">dateformats</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Will try and parse the source using any of the date formatters.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * On the first one that succeeds will skip the remaining. 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see DateFormat#parse(String)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Date</span><span class="w"> </span><span class="nf">parse</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">source</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">ParseException</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">DateFormat</span><span class="w"> </span><span class="n">df</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">dateformats</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">try</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">return</span><span class="w"> </span><span class="n">df</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="n">source</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">catch</span><span class="w"> </span><span class="p">(</span><span class="n">ParseException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="c1">//better log this</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ParseException</span><span class="p">(</span><span class="s">&#34;Please make up your mind already &#34;</span><span class="p">,</span><span class="w"> </span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A test to come with it
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@RunWith</span><span class="p">(</span><span class="n">Theories</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CompositeDateFormatTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@DataPoints</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="o">[]</span><span class="w"> </span><span class="n">DATES</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="p">{</span><span class="s">&#34;05-10-2010&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;2010-10-05&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;05/10/2010&#34;</span><span class="p">,</span><span class="w"> </span><span class="s">&#34;2010/10/05&#34;</span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Theory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">parse</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">source</span><span class="p">)</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">CompositeDateFormat</span><span class="w"> </span><span class="n">newDateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">CompositeDateFormat</span><span class="p">.</span><span class="na">newDateFormat</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Date</span><span class="w"> </span><span class="n">date</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">newDateFormat</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="n">source</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertNotNull</span><span class="p">(</span><span class="n">date</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="p">(</span><span class="n">expected</span><span class="o">=</span><span class="n">ParseException</span><span class="p">.</span><span class="na">class</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">parse</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">CompositeDateFormat</span><span class="w"> </span><span class="n">newDateFormat</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">CompositeDateFormat</span><span class="p">.</span><span class="na">newDateFormat</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">newDateFormat</span><span class="p">.</span><span class="na">parse</span><span class="p">(</span><span class="s">&#34;Can&#39;t touch this!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>A friend of mine came across this somehow difficult situation where he had to parse a date only that he has no way of knowing the format.</p>
<p>In cases like these we usually apply &ldquo;[brute force][9]&rdquo; to overcome them as they look rather trivial and can&rsquo;t be bothered.</p>
<p>However, it&rsquo;s good if we hold our <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main" title="A tale about soft-are design in an OO world">train of thoughts</a> as this will lead to a code that is [easier to extend, reuse, maintain and even understand][10] in days to come.</p>
<p>So what&rsquo;s wrong with the DateUtils class?
Well, a couple of things.</p>
<p><strong>Not extensible</strong></p>
<ul>
<li>If you need to support another DateFormat you must re visit the  #textToDate method and add an extra try/catch. That might look like a trivial thing to do, but every time you <a href="http://en.wikipedia.org/wiki/Open/closed_principle" title="Follow the Open-Closed Principle">open a class you risk breaking the implementation</a>.</li>
<li>Having a static method doesn&rsquo;t allow you to <a href="https://qnoid.com/2010/08/02/abstract-class.html#main">extend through composition</a> or inheritance.</li>
</ul>
<p><strong>Not reusable</strong></p>
<ul>
<li>You [can&rsquo;t reuse][11] instances of the DateUtil class since the method is static.</li>
<li>It doesn&rsquo;t extend DateFormat so you have to add new code to accommodate for your DateUtil which is merely a different implementation for parsing dates.  ([Disclaimer])</li>
</ul>
<p><strong>Validates the contract of Format#parse(String)</strong></p>
<ul>
<li>The contract of the method #parse(String):Date defines a throw ParseException in case an error occurs during parsing. Your client code using <em>any</em> date format to parse the dates might look like it&rsquo;s behaving correctly since it&rsquo;s not catching an <a href="https://qnoid.com/2010/08/05/the-reason-behind-finally.html#main" title="How bad can that be?">expected Exception</a>.</li>
<li>You are forced to check for null every time you use that way of parsing dates.</li>
</ul>
<p>As you can see following principles isn&rsquo;t all that subjective as you might think. So the next time you decide to violate any at least do it for the right reasons. If there are any that is.</p>
<p><strong>[Software development shouldn&rsquo;t be a throwaway process.][12]</strong></p>
<p><strong>Disclaimer</strong> Your custom class <strong>should</strong> extend the DateFormat class. However, [DateFormat as an abstract class][5] forces you to also override both</p>
<ul>
<li><code>#format(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition)</code></li>
<li><code>#parse(String source, ParsePosition pos)</code></li>
</ul>
<p>which on its own is a chapter on API design.
Ideally an interface should have been present which holds the single method <em>#parse(String):Date</em> which you should implement.</p>
<p><strong>Kudoz</strong> [Heinz Kabutz][7] who wrote an article on the [cost of causing Exceptions][8]. Not performance wise, my personal opinion is that the DateFormat should have a method <em>#isParsable(String)</em> which can be used instead.</p>
<p><strong>Update</strong> While writing this post it came to my attention that all of the date formats should have [lenient][6] to false as you risk interpreting a date with a wrong format. Another reason why you should test even trivial code!</p>
<blockquote>
<p>By default, parsing is lenient: If the input is not in the form used by this object&rsquo;s format method but can still be parsed as a date, then the parse succeeds. Clients may insist on strict adherence to the format by calling setLenient(false).*</p>
</blockquote>
<p>Also the order of the DateFormat(s) can play an important role as you may find yourself parsing a date wrong for cases where the day is &lt;=12 and a SimpleDateFormat(&ldquo;MM-dd-yyyy&rdquo;) comes before a new SimpleDateFormat(&ldquo;dd-MM-yyyy&rdquo;). Though in some cases a different ordering isn&rsquo;t sufficient.</p>
<p>[5]: {{ ref &ldquo;2010-08-02-abstract-class.md#main&rdquo; &gt;}} &ldquo;What&rsquo;s the real role behind an abstract class and ho- it relates to an interface&rdquo;
[6]: <a href="http://bit.ly/blRBCF">http://bit.ly/blRBCF</a> &ldquo;What is lenient&rdquo;
[7]: <a href="http://www.javaspecialists.eu/archive/archive.jsp">http://www.javaspecialists.eu/archive/archive.jsp</a> &ldquo;The Java Specialists ne-sletter celebrated its 10 years this year&rdquo;
[8]: <a href="http://www.javaspecialists.eu/archive/Issue187.html">http://www.javaspecialists.eu/archive/Issue187.html</a>
[9]: https://qnoid.com/2011/01/28/The-myth-o-is-for-object-part-2.html#main
[10]: https://qnoid.com/2011/01/28/Revelations-o-is-for-object-part-3.html#main
[11]: https://qnoid.com/2011/01/28/Urban-legends-o-is-for-object-part-1.html#main &ldquo;A misconception on the subject of reusability&rdquo;
[12]: https://qnoid.com/2011/02/23/Why-cant-programmers-design-software.html#main &ldquo;Why Can&rsquo;t Programmers.. Design Software?&rdquo;</p>
]]></description>
        <pubDate>Tue, 05 Oct 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Builder type ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Survival Kit #1
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Rock some awesome Forrst schwag and show your support for the community.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKit</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Use to construct a new survival kit.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * The most popular size of a survival kit has been the large so far.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * So to speed up the process the default size will be {@link Size#LARGE}
</span></span></span><span class="line"><span class="cl"><span class="cm">         * You can chance it if you want, don&#39;t worry.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKitBuilder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">Size</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">TWO_XL</span><span class="p">,</span><span class="w"> </span><span class="n">XL</span><span class="p">,</span><span class="w"> </span><span class="n">LARGE</span><span class="p">,</span><span class="w"> </span><span class="n">MEDIUM</span><span class="p">,</span><span class="w"> </span><span class="n">SMALL</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Reasonable constant
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">COST</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">29</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Use the most popular size as the default one
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">private</span><span class="w"> </span><span class="n">Size</span><span class="w"> </span><span class="n">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Size</span><span class="p">.</span><span class="na">LARGE</span><span class="p">;</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKitBuilder</span><span class="w"> </span><span class="nf">size</span><span class="p">(</span><span class="n">Size</span><span class="w"> </span><span class="n">size</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">size</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">size</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * What you get
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * An awesome cotton twshirt to wear &amp; make your friends jealous
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  A coffee &amp; tea mug for enjoying a delicious beverage while 
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  browsing the site
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  A wristband for those intense games of curling
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  
</span></span></span><span class="line"><span class="cl"><span class="cm">             *  Two awesome vinyl stickers from our friends at Sticker Giant
</span></span></span><span class="line"><span class="cl"><span class="cm">             * 
</span></span></span><span class="line"><span class="cl"><span class="cm">             * @return a new {@link SurvivalKit}
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="w"> </span><span class="nf">build</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">TShirt</span><span class="w"> </span><span class="n">tShirt</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">TShirt</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">size</span><span class="p">,</span><span class="w"> </span><span class="n">Material</span><span class="p">.</span><span class="na">COTTON</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Mug</span><span class="w"> </span><span class="n">mug</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Mug</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">Wristband</span><span class="w"> </span><span class="n">wristband</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Wristband</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">List</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="n">stickers</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">Collections</span><span class="p">.</span><span class="na">nCopies</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Sticker</span><span class="p">(</span><span class="n">Material</span><span class="p">.</span><span class="na">VINYL</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * No disrespect for Joshua Bloch (thanks for the signed copy of
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * effective java!) on his take on Builders, but I believe that 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * listing dependencies explicitly on the constructor allows for 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * greater flexibility and is more straightforward.
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * You are effectively hiding the constructor anyway from your 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * client code and you are actually calling the constructor 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * on a single place.
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * Joshua you can have an argument with Misko Hevery next door 
</span></span></span><span class="line"><span class="cl"><span class="cm">                 * if you don&#39;t take my argument or even the Greek goddess Demeter:P
</span></span></span><span class="line"><span class="cl"><span class="cm">                 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="p">(</span><span class="n">tShirt</span><span class="p">,</span><span class="w"> </span><span class="n">mug</span><span class="p">,</span><span class="w"> </span><span class="n">wristband</span><span class="p">,</span><span class="w"> </span><span class="n">stickers</span><span class="p">,</span><span class="w"> </span><span class="n">COST</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">          
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">TShirt</span><span class="w"> </span><span class="n">tShirt</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Mug</span><span class="w"> </span><span class="n">mug</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Wristband</span><span class="w"> </span><span class="n">wristband</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="n">stickers</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Leveraging private to package level access so as to make it easier 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * to test different implementations and/or related functionality 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * on the survival kit.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Just make sure your test is on the same package! :D 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param tShirt
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param mug
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param wristband
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param stickers
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param cost
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">SurvivalKit</span><span class="p">(</span><span class="n">TShirt</span><span class="w"> </span><span class="n">tShirt</span><span class="p">,</span><span class="w"> </span><span class="n">Mug</span><span class="w"> </span><span class="n">mug</span><span class="p">,</span><span class="w"> </span><span class="n">Wristband</span><span class="w"> </span><span class="n">wristband</span><span class="p">,</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="n">stickers</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">cost</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">tShirt</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">tShirt</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">mug</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">mug</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">wristband</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">wristband</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">stickers</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">stickers</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">cost</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the tShirt
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">TShirt</span><span class="w"> </span><span class="nf">tShirt</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">tShirt</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the mug
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Mug</span><span class="w"> </span><span class="nf">mug</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">mug</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the wristband
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Wristband</span><span class="w"> </span><span class="nf">wristband</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">wristband</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the stickers
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">stickers</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">stickers</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the size
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Size</span><span class="w"> </span><span class="nf">size</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">tShirt</span><span class="p">.</span><span class="na">size</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">cost</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Making sure a survival kit doesn&#39;t miss anything.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKitTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">newSurvivalKit</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">SurvivalKitBuilder</span><span class="w"> </span><span class="n">survivalKitBuilder</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKitBuilder</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">SurvivalKit</span><span class="w"> </span><span class="n">survivalKit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">survivalKitBuilder</span><span class="p">.</span><span class="na">build</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertNotNull</span><span class="p">(</span><span class="n">survivalKit</span><span class="p">.</span><span class="na">tShirt</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">Size</span><span class="p">.</span><span class="na">LARGE</span><span class="p">,</span><span class="w"> </span><span class="n">survivalKit</span><span class="p">.</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertNotNull</span><span class="p">(</span><span class="n">survivalKit</span><span class="p">.</span><span class="na">mug</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertNotNull</span><span class="p">(</span><span class="n">survivalKit</span><span class="p">.</span><span class="na">stickers</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="n">survivalKit</span><span class="p">.</span><span class="na">stickers</span><span class="p">().</span><span class="na">size</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>When first identified the <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">SurvivalKit</a> we specified all the <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">properties that make it up</a>.</p>
<p>Now that&rsquo;s a lot of properties! (@kyle made sure a survival kit has everything we need) which means that every time we need to add a new survival kit to <a href="https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html#main">an order</a> we have to create everything that comes with it. Not only that but there is a risk of mistyping the cost, which pottentialy could make the kit more expensive, or cheaper than what it&rsquo;s actually worth. <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">Not fun</a>.</p>
<p>So you could go on creating survival kits; <a href="https://qnoid.com/2010/09/27/reusability-dont-lose-your-train-of-thoughts.html#main">every time you need to dispatch</a> one specifying the items that comprise it or you could use a builder.</p>
<p>The great thing about the <em>#build</em> method is that it can encapsulate the complexity of creating a SurvivalKit. The client code doesn&rsquo;t need to know how to go on creating a TShirt or a Mug. All is interested in is a survival kit and that&rsquo;s what it gets!</p>
<p>The <em>#build</em> method also provides a place to <a href="https://qnoid.com/2010/07/22/Everytime-you-write-an-init-method-a-developer-gets-an-Exception-simply-dont.html#main">return objects in the required state</a> while any &ldquo;setter&rdquo; method in the builder can be used to perform assertions on the property to set. So in essence a builder helps you create <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">immutable objects</a> since once the object is &ldquo;built&rdquo; you can&rsquo;t change it. (notice how the setters are missing from the SurvivalKit)</p>
<p>As an extra bonus you get to specify constant values for any of your properties. (e.g. the cost!)</p>
<p>Make sure that you <strong>document your builder on any default values it might use as well as the state that the object is returned in.</strong></p>
<p><em>Up next we&rsquo;ll see how a factory can help you produce different variations of a SurvivalKit and finally see <a href="https://qnoid.com/2010/10/08/marker-interfaces-dont-lose-your-train-of-thoughts.html#main">the real reason behind the need for a SurvivalKitItem</a>. Can you guess?</em></p>
<h2 id="disclaimer">Disclaimer</h2>
<p>The builder specified above is great if you have a single &ldquo;configuration&rdquo; of survival kits and that&rsquo;s usually the case. We&rsquo;ll see why the builder is complimentary to the factory and not a replacement altogether.</p>
<h2 id="kudoz">Kudoz</h2>
<p>Joshua Bloch in <a href="http://bit.ly/cvjAWv">Effective Java</a> and his take on the builder pattern.<br>
<a href="http://misko.hevery.com/2008/07/18/breaking-the-law-of-demeter-is-like-looking-for-a-needle-in-the-haystack/">Misko Hevery</a> for his great blog on testability.</p>
]]></description>
        <pubDate>Thu, 30 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Followup to Recursively find and filter files in Java</title>
        <link>https://qnoid.com/2010/09/28/Inspired-to-inspire-Followup-to-Recursively-find-and-filter-files-in-Java.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/28/Inspired-to-inspire-Followup-to-Recursively-find-and-filter-files-in-Java.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Polymorphic enums
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">TypeFilter</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">FileFilter</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">FILE</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">accept</span><span class="p">(</span><span class="n">File</span><span class="w"> </span><span class="n">file</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">file</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="n">file</span><span class="p">.</span><span class="na">isFile</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">},</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">DIR</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">accept</span><span class="p">(</span><span class="n">File</span><span class="w"> </span><span class="n">file</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">file</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="w"> </span><span class="o">&amp;&amp;</span><span class="w"> </span><span class="n">file</span><span class="p">.</span><span class="na">isDirectory</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">},</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">ALL</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">accept</span><span class="p">(</span><span class="n">File</span><span class="w"> </span><span class="n">file</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">file</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Use to obtain different implementations to {@link FileFilter}s
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FileFilters</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * A single instance will do since there our objects don&#39;t have any state
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">FileFilters</span><span class="w"> </span><span class="n">INSTANCE</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">FileFilters</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="n">FileFilters</span><span class="w"> </span><span class="nf">fileFilters</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">INSTANCE</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Make it explicitly private so client code doesn&#39;t have to create one
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">FileFilters</span><span class="p">(){}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">RegExFilter</span><span class="w"> </span><span class="nf">newRegExFilter</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">pattern</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">RegExFilter</span><span class="p">(</span><span class="n">pattern</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">RegExFilter</span><span class="w"> </span><span class="nf">newSuffixFilter</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">suffix</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">newRegExFilter</span><span class="p">(</span><span class="s">&#34;^.*&#34;</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">Pattern</span><span class="p">.</span><span class="na">quote</span><span class="p">(</span><span class="w"> </span><span class="n">suffix</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="s">&#34;$&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Create a new file filter that returns true if all filters are satisfied
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param filters the filter to include
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a composite file filter
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">FileFilter</span><span class="w"> </span><span class="nf">all</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">FileFilter</span><span class="p">...</span><span class="w"> </span><span class="n">filters</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">FileFilter</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">accept</span><span class="p">(</span><span class="n">File</span><span class="w"> </span><span class="n">pathname</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">FileFilter</span><span class="w"> </span><span class="n">fileFilter</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">filters</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">fileFilter</span><span class="p">.</span><span class="na">accept</span><span class="p">(</span><span class="n">pathname</span><span class="p">))</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="k">return</span><span class="w"> </span><span class="kc">false</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Extending file through composition
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">EnhancedFile</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">File</span><span class="w"> </span><span class="n">file</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param file the file to extend
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">EnhancedFile</span><span class="p">(</span><span class="n">File</span><span class="w"> </span><span class="n">file</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">file</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">file</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">File</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">getFilesRecursive</span><span class="p">(</span><span class="w"> </span><span class="n">File</span><span class="w"> </span><span class="n">file</span><span class="p">,</span><span class="w"> </span><span class="n">FileFilter</span><span class="w"> </span><span class="n">filter</span><span class="w"> </span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * If the file is normal end the recursion.  
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">file</span><span class="p">.</span><span class="na">isFile</span><span class="p">())</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">File</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">List</span><span class="o">&lt;</span><span class="n">File</span><span class="o">&gt;</span><span class="w"> </span><span class="n">files</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">File</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="w"> </span><span class="n">File</span><span class="w"> </span><span class="n">subdir</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">file</span><span class="p">.</span><span class="na">listFiles</span><span class="p">(</span><span class="w"> </span><span class="n">TypeFilter</span><span class="p">.</span><span class="na">DIR</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">files</span><span class="p">.</span><span class="na">addAll</span><span class="p">(</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">getFilesRecursive</span><span class="p">(</span><span class="w"> </span><span class="n">subdir</span><span class="p">,</span><span class="w"> </span><span class="n">filter</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">files</span><span class="p">.</span><span class="na">addAll</span><span class="p">(</span><span class="w"> </span><span class="n">Arrays</span><span class="p">.</span><span class="na">asList</span><span class="p">(</span><span class="w"> </span><span class="n">file</span><span class="p">.</span><span class="na">listFiles</span><span class="p">(</span><span class="w"> </span><span class="n">filter</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">files</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">List</span><span class="o">&lt;</span><span class="n">File</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">getFilesRecursive</span><span class="p">(</span><span class="w"> </span><span class="n">FileFilter</span><span class="w"> </span><span class="n">filter</span><span class="w"> </span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">getFilesRecursive</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">file</span><span class="p">,</span><span class="w"> </span><span class="n">filter</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Verifying the signature of FileFilters#all
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FileFiltersTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">FileFilters</span><span class="w"> </span><span class="n">FILE_FILTERS</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">FileFilters</span><span class="p">.</span><span class="na">fileFilters</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">all</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Quoting @cahnory from @imperez post
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">pattern</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="s">&#34;([^:]+:(\\/\\/)?)?([^@]+@)?([^?/]+)/&#34;</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">FileFilter</span><span class="w"> </span><span class="n">all</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">FILE_FILTERS</span><span class="p">.</span><span class="na">all</span><span class="p">(</span><span class="n">TypeFilter</span><span class="p">.</span><span class="na">ALL</span><span class="p">,</span><span class="w"> </span><span class="n">FILE_FILTERS</span><span class="p">.</span><span class="na">newRegExFilter</span><span class="p">(</span><span class="n">pattern</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
Did you know that you can define (even @Override) methods to enums pretty much in the same way as classes?</p>
<p>Instead of having the #accept(File) method checking on the &ldquo;type&rdquo; to decide on the operation, you can move the operation to the type itself! :D</p>
<p>Personally I believe the SuffixFilter is a bit of an overhead to implement with inheritance to just encapsule the</p>
<pre><code>&quot;^.*&quot; + Pattern.quote( suffix ) + &quot;$&quot;
</code></pre>
<p>Maybe a Factory is more appropriate. Which can also be used to create other file filters as well.</p>
<p>The #all makes it easy to have your RegExFilter decoupled from the TypeFilter.</p>
<p>Try to avoid static Util classes as are harder to extend or test. Instead you can use composition to &ldquo;extend&rdquo; a File to add more methods</p>
<p>Also notice how the stop condition for the <a href="https://qnoid.com/2010/10/18/recursion.html#main">recursion</a> is easier to identify.</p>
<p>Kudoz to @imperez for his <a href="http://forrst.com/posts/Regex_to_find_the_first_part_of_a_url-yBt">Regex to find the first part of a url</a> post and @cahnory followup comment.
Though it doesn&rsquo;t apply to files, I did remember his post while looking at yours :)</p>
]]></description>
        <pubDate>Tue, 28 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Reusability ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/09/27/reusability-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/27/reusability-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Feel free to reuse!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">US_CANADA</span><span class="p">(</span><span class="n">0</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">INTERNATIONAL</span><span class="p">(</span><span class="n">10</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Dispatches the order to the specified address.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param order the order which might contain several kits
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param adress the address for delivery
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a unique identifier for the order used for tracking
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="nf">dispatch</span><span class="p">(</span><span class="n">SurvivalKitOrder</span><span class="w"> </span><span class="n">order</span><span class="p">,</span><span class="w"> </span><span class="n">Address</span><span class="w"> </span><span class="n">adress</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">//There goes another one</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The almighty controller.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Dispatching orders since 1 month ago
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ForrstController</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * This method will decide on the shipping method, create 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * a new SurvivalKitOrder and an Address and initiate the dispatch!
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">purchase</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ShippingMethod</span><span class="w"> </span><span class="n">method</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="p">.</span><span class="na">INTERNATIONAL</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">SurvivalKit</span><span class="w"> </span><span class="n">survivalKit</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKit</span><span class="p">(</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                                    </span><span class="k">new</span><span class="w"> </span><span class="n">TShirt</span><span class="p">(</span><span class="n">Size</span><span class="p">.</span><span class="na">LARGE</span><span class="p">,</span><span class="w"> </span><span class="n">Material</span><span class="p">.</span><span class="na">COTTON</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                                    </span><span class="k">new</span><span class="w"> </span><span class="n">Mug</span><span class="p">(),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                                    </span><span class="k">new</span><span class="w"> </span><span class="n">Wristband</span><span class="p">(),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                                                    </span><span class="n">Collections</span><span class="p">.</span><span class="na">nCopies</span><span class="p">(</span><span class="n">2</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Sticker</span><span class="p">(</span><span class="n">Material</span><span class="p">.</span><span class="na">VINYL</span><span class="p">)),</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">                                                    </span><span class="n">29</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">survivalKits</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ArrayList</span><span class="o">&lt;</span><span class="n">SurvivalKit</span><span class="o">&gt;</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">survivalKits</span><span class="p">.</span><span class="na">add</span><span class="p">(</span><span class="w"> </span><span class="n">survivalKit</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">SurvivalKitOrder</span><span class="w"> </span><span class="n">order</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">SurvivalKitOrder</span><span class="p">(</span><span class="s">&#34;F0RR7T&#34;</span><span class="p">,</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Address</span><span class="w"> </span><span class="n">adress</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Address</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">//Woohoo we have started shipping!</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">method</span><span class="p">.</span><span class="na">dispatch</span><span class="p">(</span><span class="n">order</span><span class="p">,</span><span class="w"> </span><span class="n">adress</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>When thinking about the <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">ShippingMethod class</a> we talked about the importance of designing <a href="http://en.wikipedia.org/wiki/Immutable_object" title="Stricly speaking it's their objects that are immutable">immutable classes</a> thus allowing us to create constant objects and reuse them freely. Also while trying to identify the <a href="https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html#main">relationships to the SurvivalKitOrder class</a> in order to dispatch it we hold back from defining a rather complicated one.</p>
<p>Now the ShippingMethod is your point of reference. It&rsquo;s what you can <strong>reuse</strong> again and again to dispatch (<em>Hint</em>) an order to an address. <strong>The SurvivalKitOrder and the Address is what varies each time.</strong> So whenever a <em>new purchase is made</em>, you choose the ShippingMethod and <strong>create a new</strong> SurvivalKitOrder and an Address.</p>
<p>Designing for reusability through constants is &ldquo;the key to success&rdquo;. If you look back at the design of your classes you will come to realize that not only you have defined the minimum required relationships between them but in doing so you have effectively avoided any concurrency issues in the process.</p>
<p>The reason for that is that any shared objects (the shipping method) are constants and anything that varies (order, address) is new to each thread.</p>
<p>The question that remains is where do you create a new order and an address and how does it all come together? That&rsquo;s where the <a href="http://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller">controller</a> steps in. The controller itself could be mapped to a URL that handles purchases and gets all the address details from the form.</p>
<p>This effectively also closes the circle for <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">the #purchase method which has now found its place</a>.</p>
<p><em>Next in <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">the series</a> is <a href="https://qnoid.com/2010/09/30/builder-type-dont-lose-your-train-of-thoughts.html#main">&ldquo;Honour Your Builders&rdquo;</a> where we&rsquo;ll see how you can go on creating survival kits the fun way. Don&rsquo;t miss it.</em></p>
<h2 id="disclaimer">Disclaimer</h2>
<p>This is example code to make you think of class relationships and reusability. The ShippingMethod#dispatch will most likely require some other class relationship to do the dispatch, so in the real world you&rsquo;ll might have to take that into consideration as well.</p>
]]></description>
        <pubDate>Mon, 27 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Do you think that GAE alone is enough to justify learning Python over Ruby?</title>
        <link>https://qnoid.com/2010/09/16/Do-you-think-that-GAE-alone-is-enough-to-justify-learning-Python-over-Ruby.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/16/Do-you-think-that-GAE-alone-is-enough-to-justify-learning-Python-over-Ruby.html</guid>
        <description><![CDATA[<p>Considering the fact that you don&rsquo;t have to get involved in setting up a server or even buying a domain, do you think that fact alone is enough to choose one over the other?</p>
]]></description>
        <pubDate>Thu, 16 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Can an Abstract Class and an Interface play nice together?</title>
        <link>https://qnoid.com/2010/09/13/Can-an-Abstract-Class-and-an-Interface-play-nice-together.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/13/Can-an-Abstract-Class-and-an-Interface-play-nice-together.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Pity me
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Driver</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">Porsche</span><span class="w"> </span><span class="n">porsche</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">porsche</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Had to learn how to drive a Yugo after the crisis hit me
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Driver</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">Porsche</span><span class="w"> </span><span class="n">porsche</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">porsche</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">Yugo</span><span class="w"> </span><span class="n">yugo</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">yugo</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Gas for all!
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Driver</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">GasolineCar</span><span class="w"> </span><span class="n">gasolineCar</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">gasolineCar</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Not again....
</span></span></span><span class="line"><span class="cl"><span class="cm"> *
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Driver</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">ElectricalCar</span><span class="w"> </span><span class="n">electricalCar</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">electricalCar</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">GasolineCar</span><span class="w"> </span><span class="n">gasolineCar</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">gasolineCar</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * &#34;I&#39;m the King of the world&#34;
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Driver</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">(</span><span class="n">Car</span><span class="w"> </span><span class="n">car</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">car</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * All I wan&#39;t to do is drive...
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Car</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Nitro baby!
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">NitroCar</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Car</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Car</span><span class="w"> </span><span class="n">car</span><span class="p">;</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="nf">NitroCar</span><span class="p">(</span><span class="n">Car</span><span class="w"> </span><span class="n">car</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">this</span><span class="p">.</span><span class="na">car</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">car</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">private</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">applyNitro</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Applying Nitrous Oxide&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">this</span><span class="p">.</span><span class="na">applyNitro</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">this</span><span class="p">.</span><span class="na">car</span><span class="p">.</span><span class="na">drive</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Let&#39;s put this nitro to the test
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">DriverTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">drive</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Driver</span><span class="w"> </span><span class="n">brianOConner</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Driver</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Car</span><span class="w"> </span><span class="n">eclipse</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MitsubishiEclipseRS</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">Car</span><span class="w"> </span><span class="n">nitroCar</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">NitroCar</span><span class="p">(</span><span class="n">eclipse</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * &#34;O&#39;Conner appears to be ahead in the race, having equipped his Eclipse with Nitrous Oxide&#34; (as quoted by Wikipedia The Fast and the Furious (2001 film)
</span></span></span><span class="line"><span class="cl"><span class="cm"> article)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">brianOConner</span><span class="p">.</span><span class="na">drive</span><span class="p">(</span><span class="w"> </span><span class="n">nitroCar</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span></span></span></code></pre></div>
<p>What if your driver&rsquo;s licence said you can only drive a Porsche?</p>
<p>The money crisis is on and you have to sell your precious little horse for a new Yugo Zastava[Disclaimer].
You have to learn how to drive that as well.</p>
<p><a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">In OO terms</a> you are now presented with two options.</p>
<ul>
<li>Add another method that allows you to drive the Yugo.</li>
<li>Extract an abstract class that allows you to drive any car</li>
</ul>
<p>Now ask yourself this. How &ldquo;abstract&rdquo; will that abstract class be? Will you go as far as to define an AbstractCar class? What methods will this class define and how usefull will <strong><a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">inheritance</a></strong> prove to be after all? Will you define an abstract GasolineCar that will at least give you some basic <strong>implementation</strong> on <a href="https://qnoid.com/2010/08/02/abstract-class.html#main">how such a car operates</a> when you drive it?</p>
<p>So you go on and just use an abstract GasolineCar class since all cars run on gas anyway.</p>
<p>The electrical revolution is upon us and all of a sudden both your Porsche and Yugo are overshadowed by Toyota.
Yet, you are left with driving just GasolineCar(s).</p>
<p>Now again you have two options.</p>
<ul>
<li>Add another method that allows you to drive the ElectricCar</li>
<li>Extract an abstract class that allows you to drive any car</li>
</ul>
<p>See a pattern here? <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">It ain&rsquo;t fun</a> driving any more.</p>
<p>You give up and introduce an AbstractCar class after all to decouple the Driver <strong>from any implementation</strong>, but ask yourself this (rather rhetorical) question. If that abstract class merely defines an abstract <em>drive</em> method (or even a set of abstract methods) and nothing more, isn&rsquo;t that what an interface is all about?</p>
<p>In this example obviously there is a need to drive different (implementations of) cars. You shouldn&rsquo;t neccesary have to create an interface for every implementation that you have but <a href="https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html#main">use your best judgement and reasoning</a> on where it&rsquo;s suitable to do so. When designing an API will make more sense as you see a reason to make it extensible. In any case structure your code in such a way that when presented with the task you can <a href="https://qnoid.com/2010/08/30/types.html#main">easily introduce an interface later</a>.</p>
<p>Most likely you will be introducing an abstract class to encapsulate a common algorithm for all your inheriting classes but tightening yourself to an abstract class is tightening yourself to an implementation which isn&rsquo;t that obvious at first sight.</p>
<p>Think of an interface as a way to describe behaviour for your classes without any sort of definition of how the methods relate together. e.g. what can you do with all the cars? <strong>Drive</strong> them!</p>
<p>As a bonus to coding to an interface you can easily extend your cars (even at runtime!) by using <a href="http://en.wikipedia.org/wiki/Composition_over_inheritance">composition over inheritance</a>. All of a sudden you are fast and furious.</p>
<p><em>The above isn&rsquo;t by any means a play of Greek tragedy in some theater in <a href="http://en.wikipedia.org/wiki/Epidaurus">Epidaurus</a>. Though an example it is very much real</em>.</p>
<h2 id="disclaimer">Disclaimer</h2>
<p>No disrespect for the <a href="http://en.wikipedia.org/wiki/Zastava">Yugo Zastava</a></p>
]]></description>
        <pubDate>Mon, 13 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Why is 8 numbers considered a &#34;strong&#34; password?</title>
        <link>https://qnoid.com/2010/09/07/Why-is-8-numbers-considered-a-strong-password.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/07/Why-is-8-numbers-considered-a-strong-password.html</guid>
        <description><![CDATA[<p>Just curious as to why 8 numbers are accepted as a password in linux (CentOS if it matters) and not 8 characters on a nonwdictionary word.</p>
<p>It&rsquo;s 10 vs 26 per digit after all. (52 counting CaSe SeNsItIvE)</p>
]]></description>
        <pubDate>Tue, 07 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Reasoning ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/06/reasoning-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * First iteration
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKitOrder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Tracking code
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">code</span><span class="p">;</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * All we need
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">SurvivalKitOrder</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">code</span><span class="p">,</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">code</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">survivalKits</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Does it make sense? 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">purchase</span><span class="p">(</span><span class="n">ShippingMethod</span><span class="w"> </span><span class="n">shippingMethod</span><span class="p">,</span><span class="w"> </span><span class="n">Address</span><span class="w"> </span><span class="n">address</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Ill conceived class
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKitOrder</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">code</span><span class="p">;</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="w"> </span><span class="n">shippingMethod</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Address</span><span class="w"> </span><span class="n">address</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Are the relationships over yet?
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">SurvivalKitOrder</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">code</span><span class="p">,</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">SurvivalKit</span><span class="o">&gt;</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">,</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="w"> </span><span class="n">shippingMethod</span><span class="p">,</span><span class="w"> </span><span class="n">Address</span><span class="w"> </span><span class="n">address</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">code</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">survivalKits</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">survivalKits</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">shippingMethod</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">shippingMethod</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">address</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">address</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * On second thoughts maybe not...
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">purchase</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
While <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">identifying the survival kit class</a> we left out a presumably important method like <strong>purchase</strong>.</p>
<p>The initial hunch was to define it in the SurvivalKit class though a survival kit seems to better relate with an order (<em>hint</em>).</p>
<p>Looking at the SurvivalKitOrder there is a <strong>code</strong> property and a collection of SurvivalKit(s). (people might want to order more than 1 kit after all) Should we define the <strong>purchase</strong> method in the SurvivalKitOrder? Let&rsquo;s see.</p>
<p>First of all, in order for the purchase method to work we need to have both the ShippingMethod and the Address to dispatch. Should the <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">SurvivalKitOrder class <strong>use</strong> the ShippingMethod</a> and Address through its purchase method?</p>
<p>Ask yourself the following questions.</p>
<ul>
<li>Would you send <strong>the same order</strong> to the same address using a different shipping method?</li>
<li>Would you send <strong>the same order</strong> to a different address on the same shipping method?</li>
<li>Would you send <strong>the same order</strong> to a different address all together?</li>
</ul>
<p><strong>In any case</strong>, an order it&rsquo;s not something you would <strong>reuse</strong>, since each must have a unique code. Thus you will need to <strong>create a new one</strong> every time.</p>
<p>So it only makes sense that you define both the ShippingMethod and the Address as properties to the SurvivalKitOrder. (after all an order must <strong>have</strong> a shipping method and an address associated)</p>
<p><a href="http://en.wikipedia.org/wiki/Single_responsibility_principle">Single responsibility</a> is one thing and indeed SurvivalKitOrder sole responsibility is dealing with a purchase but don&rsquo;t forget about the importance of well defined class relationships. The SurvivalKitOrder suddenly has a <strong>strong</strong> (e.g. can&rsquo;t have one without a ShippingMethod and an Address) relationship with 2 other classes. Now there is nothing inheritly wrong with that, but there might be a better way. After all you don&rsquo;t need another <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">complicated relationship</a> in your hands.</p>
<p><em>Leave your thoughts below on <a href="https://qnoid.com/2010/09/27/reusability-dont-lose-your-train-of-thoughts.html#main">where you would define the purchase method</a>. Don&rsquo;t forget your reasoning behind it.</em></p>
<h2 id="disclaimer">Disclaimer</h2>
<p>As in every object oriented design there is a reasoning behind it all. Depending on the problem you are trying to solve most likely will differ. <strong>Not everything</strong> related to software engineering should be treated as gospel and as a developer you should apply critical thinking before making any decisions. Use that.</p>
]]></description>
        <pubDate>Mon, 06 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Do small code presentations</title>
        <link>https://qnoid.com/2010/09/01/Do-small-code-presentations.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/09/01/Do-small-code-presentations.html</guid>
        <description><![CDATA[<p>Every time a team or a single developer releases a piece of code for internal consumption, an overall presentation is a good thing to have.</p>
<p>That way you get the chance to</p>
<ul>
<li>avoid going through every desk and explain intent or usage</li>
<li>state reasoning behind implementation</li>
<li>give an example on how it should be used</li>
<li>show how it can be extended</li>
</ul>
<p>The presentation should be complimentary to comments (e.g. Javadocs) and unit tests.</p>
]]></description>
        <pubDate>Wed, 01 Sep 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Use types ...Don&#39;t Abuse The If</title>
        <link>https://qnoid.com/2010/08/30/types.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/30/types.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A lame dragon that can&#39;t make up his mind
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">IndecisiveDragon</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">FIRE_BREATH</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">POISON_BREATH</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">1</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Should be final but the default constructor forces us to forfeit
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">breath</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Avoid naive constructor!
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Forces breath and damage not to be final, and doesn&#39;t specify reasonable defaults.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Also, fails to show intend. What&#39;s a dragon without its breath?
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">IndecisiveDragon</span><span class="p">(){}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param breath which type of breath the dragon shall deal 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param damage how much damage the breath should deal
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see #FIRE_BREATH
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see #POISON_BREATH
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">IndecisiveDragon</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">breath</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">breath</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">breath</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Rain chaos with just a breath  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the damage dealt by the dragon
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Picture this as an if doing String comparisons and it only gets worse
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">switch</span><span class="w"> </span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">breath</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">case</span><span class="w"> </span><span class="n">FIRE_BREATH</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Breathing mighty fire dealing %d damage&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">;</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">case</span><span class="w"> </span><span class="n">POISON_BREATH</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Unleasing poison dealing %d damage&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">;</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">default</span><span class="p">:</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Pants...Dealing no damage&#34;</span><span class="p">);</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A mighty dragon that can have custom {@link Breaths}
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">MightyDragon</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * A dragon *has* breath
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Breath</span><span class="w"> </span><span class="n">breath</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param breath give me breath
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see Breaths
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">MightyDragon</span><span class="p">(</span><span class="n">Breath</span><span class="w"> </span><span class="n">breath</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">breath</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">breath</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Rain chaos with just a breath  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @see Breath#breath()
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">breath</span><span class="p">.</span><span class="na">breathe</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * The mighty breath
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Breath</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the damage dealt
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Lot&#39;s of breaths for your perusal
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Breaths</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Making constants out of breaths is goooooooood.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Breath</span><span class="w"> </span><span class="n">FIRE_BREATH</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">FireBreath</span><span class="p">(</span><span class="n">30</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Breath</span><span class="w"> </span><span class="n">HEAVY_FIRE_BREATH</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">HeavyFireBreath</span><span class="p">(</span><span class="n">20</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Breath</span><span class="w"> </span><span class="n">POISON_BREATH</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">PoisonBreath</span><span class="p">(</span><span class="n">50</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Breath</span><span class="w"> </span><span class="n">NO_BREATH</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">NoBreath</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FireBreath</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Breath</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">FireBreath</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Casting mighty fire dealing %d damage&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">;</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PoisonBreath</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Breath</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">PoisonBreath</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Unleasing poison dealing %d damage&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">;</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">NoBreath</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Breath</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="s">&#34;Pants...Dealing no damage&#34;</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">0</span><span class="p">;</span><span class="w">      
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">HeavyFireBreath</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Breath</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">multiplier</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param damage
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">HeavyFireBreath</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Increments the multiplier and multiplies it to the damage
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param damage the damage to multiply
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a multiplied damage
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">inhale</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="o">++</span><span class="n">multiplier</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">breathe</span><span class="p">()</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">damage</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">inhale</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">damage</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="w"> </span><span class="n">String</span><span class="p">.</span><span class="na">format</span><span class="p">(</span><span class="s">&#34;Inhaling up to %d times dealing %d damage&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">multiplier</span><span class="p">,</span><span class="w"> </span><span class="n">damage</span><span class="p">)</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">damage</span><span class="p">;</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Here be dragons
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">MightyDragonTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">breathe</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MightyDragon</span><span class="w"> </span><span class="n">harmlessDragon</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MightyDragon</span><span class="p">(</span><span class="n">Breaths</span><span class="p">.</span><span class="na">NO_BREATH</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MightyDragon</span><span class="w"> </span><span class="n">fireDragon</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MightyDragon</span><span class="p">(</span><span class="n">Breaths</span><span class="p">.</span><span class="na">FIRE_BREATH</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MightyDragon</span><span class="w"> </span><span class="n">poisonDragon</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MightyDragon</span><span class="p">(</span><span class="n">Breaths</span><span class="p">.</span><span class="na">POISON_BREATH</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MightyDragon</span><span class="w"> </span><span class="n">heavyFireDragon</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MightyDragon</span><span class="p">(</span><span class="n">Breaths</span><span class="p">.</span><span class="na">HEAVY_FIRE_BREATH</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">harmlessDragon</span><span class="p">.</span><span class="na">breathe</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">30</span><span class="p">,</span><span class="w"> </span><span class="n">fireDragon</span><span class="p">.</span><span class="na">breathe</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">50</span><span class="p">,</span><span class="w"> </span><span class="n">poisonDragon</span><span class="p">.</span><span class="na">breathe</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">20</span><span class="p">,</span><span class="w"> </span><span class="n">heavyFireDragon</span><span class="p">.</span><span class="na">breathe</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">40</span><span class="p">,</span><span class="w"> </span><span class="n">heavyFireDragon</span><span class="p">.</span><span class="na">breathe</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">60</span><span class="p">,</span><span class="w"> </span><span class="n">heavyFireDragon</span><span class="p">.</span><span class="na">breathe</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
Most of us would go mental having a dragon as a pet but what&rsquo;s even more fun is creating your own!
Now, designing your own dragon will most likely make you over excited causing you to simply <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">dump code</a>.</p>
<p>Take a look at the IndecisiveDragon class. This class has a <em>breath</em> property which is merely an int acting as a flag to designate the type of breath your dragon has. Having an int for that purpose not only poses a risk for arbitary breaths (thus making it harder to debug) but makes extending the dragon with a new breath even harder. Not to mention <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">how scary your dragon</a> can grow. And you don&rsquo;t want that dragon turned against you.</p>
<p>In order to cope with the different types of breaths the #breathe method has a switch statement which depending on the value <strong>does something different</strong>. The important thing to notice is that a <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">dragon <strong>has</strong> a breath</a> therefore the #breathe method <strong>merely executes one branch per dragon</strong> (1 dragon - 1 breath, more on <a href="http://en.wikipedia.org/wiki/Class_diagram#Multiplicity">multiplicity</a> later)</p>
<p>Finally, there is a naive default constructor which is used to just create a dragon and be done with it. Most likely this happens at a later stage when adding a method to the IndecisiveDragon class that has nothing to do with breath(s) or even the dragon itself in most cases.</p>
<p><strong>Say hello to the MightyDragon</strong>. This dragon clearly states it&rsquo;s relationship with a Breath type which not only ensures type safety among breaths but allows you to <a href="http://en.wikipedia.org/wiki/Open/closed_principle" title="Open for Extension, Closed for Modification principle">extend your class without modifying it</a> making it easier to choose between different breaths. Notice how you delegate the code to the breath thus in essence applying <a href="https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html#main">polymorphism</a> since every breath is implemented differently.</p>
<p>When creating a MightyDragon you are forced to explicitly choose 1 breath which the dragon shall have. (In OO terms this is actually the <a href="http://en.wikipedia.org/wiki/Strategy_pattern">Strategy design pattern</a>)</p>
<p>What&rsquo;s also important to notice is how the HeavyFireBreath class defines an extra method related to the #breathe which otherwise would have ended up either inside your dragon class or part of the switch statement.</p>
<p>As a added bonus you get constants out of breaths <a href="https://github.com/qnoid/qnoid/commit/84048707c29084ec44a4fa41dcb2b77b57d5a5fb">which is gooooood</a>.</p>
<p><em>Leave your comment below on how it helped you make your life a bit better without another if</em></p>
<h2 id="disclaimer">Disclaimer</h2>
<p>Again this is a trivial example. FireBreath, PoisonBreath and NoBreath aren&rsquo;t really that different since they all return the damage dealt, so a single class would suffice. In any case the breath interface allows you to extend your dragon (adding custom breaths) without modifying its internal(s) [organs].</p>
<h2 id="kudoz">Kudoz</h2>
<p><a href="http://www.markshuttleworth.com/biography">Mark Shuttleworth</a></p>
<p><em><a href="https://github.com/qnoid/qnoid/commit/84048707c29084ec44a4fa41dcb2b77b57d5a5fb">Source</a></em></p>
]]></description>
        <pubDate>Mon, 30 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Immutability ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * A nice little enum defining our shipping methods
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">enum</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">US_CANADA</span><span class="p">(</span><span class="n">0</span><span class="p">),</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">INTERNATIONAL</span><span class="p">(</span><span class="n">10</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">fee</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param fee how much does it cost 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">ShippingMethod</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fee</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">fee</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">fee</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the fee of the shipping method
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">fee</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">fee</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * You can use a class too!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ShippingMethodImpl</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ShippingMethodImpl</span><span class="w"> </span><span class="n">US_CANADA</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ShippingMethodImpl</span><span class="p">(</span><span class="n">0</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kd">static</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">ShippingMethodImpl</span><span class="w"> </span><span class="n">INTERNATIONAL</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ShippingMethodImpl</span><span class="p">(</span><span class="n">10</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">fee</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * No need to have the constructor public.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param fee how much does it cost 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">ShippingMethodImpl</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">fee</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">fee</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">fee</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the fee of the shipping method
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">fee</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">fee</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Hopefully we don&#39;t send out international orders for free!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ShippingMethodTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">enumz</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ShippingMethod</span><span class="w"> </span><span class="n">usCanada</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="p">.</span><span class="na">US_CANADA</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ShippingMethod</span><span class="w"> </span><span class="n">international</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ShippingMethod</span><span class="p">.</span><span class="na">INTERNATIONAL</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">usCanada</span><span class="p">.</span><span class="na">fee</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">10</span><span class="p">,</span><span class="w"> </span><span class="n">international</span><span class="p">.</span><span class="na">fee</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">classes</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ShippingMethodImpl</span><span class="w"> </span><span class="n">usCanada</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ShippingMethodImpl</span><span class="p">.</span><span class="na">US_CANADA</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">ShippingMethodImpl</span><span class="w"> </span><span class="n">international</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">ShippingMethodImpl</span><span class="p">.</span><span class="na">INTERNATIONAL</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">usCanada</span><span class="p">.</span><span class="na">fee</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">10</span><span class="p">,</span><span class="w"> </span><span class="n">international</span><span class="p">.</span><span class="na">fee</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">Class relationships are really important</a> and noone wants a &ldquo;complicated&rdquo; one.
Now although <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">grammar does help</a> sometimes it is still hard to decide which class should relate to which thus you end up <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">not thinking too much about it</a> and dump them on a <em>need to have</em> basis.</p>
<p>One way to think of classes is in terms of the <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">object state</a> they enforce. So in essence you have classes of two kinds. Muttable (the value of its fields can change) and immutable (you can tell from their <strong>final</strong> fields; <em>see Disclaimer</em>). It&rsquo;s good practice not to mix the two since mixing a mutable with an immutable will give you a mutable one at the end :(.</p>
<p>The reason you should strive to design immutable classes is that are easier to maintain, (no state to worry about!) encourage reusability (objects are effectively constants!) and last but not least are thread safe. (woohoo, no concurrency bugs!)</p>
<p>Let&rsquo;s take a look at the <a href="http://img101.imageshack.us/img101/8135/survivalkit.png">survival kit</a> to identify classes that qualify for immutable. The text talks about 2 distinct shipping methods. US_CANADA and INTERNATIONAL. See a pattern here? With ShippingMethod as your class, you can have 2 objects, one for US_CANADA and second one for INTERNATIONAL. Yes constants (use CAPITAL to get your point across). In Java you can use an Enum for defining constants.</p>
<p><strong>Summary</strong>:</p>
<ul>
<li>Start with <strong>private final</strong> fields.</li>
<li>Don&rsquo;t have (possible) immutable classes with mutable properties.</li>
<li>Make constants out of your immutable classes and reuse them.</li>
</ul>
<p>There is still a long way to go before we start sending survival kits out, so leave your feedback below on how you would specify any further class relationships, now that you have acquired that extra knowledge.</p>
<p><em>Also, Misko Hevery gives you another clue as to how to think about your class relatiosnhips when it comes to <a href="http://misko.hevery.com/2008/09/30/to-new-or-not-to-new/">dependency injection</a></em></p>
<h2 id="disclaimer">Disclaimer</h2>
<p>Not strictly true. <em>final</em> is about not changing the <strong>reference</strong> of an object while the object itself might still change. Take an array for example, though you might not be able to assign a different one, you can still change its contents.</p>
<h2 id="kudoz">Kudoz</h2>
<p><a href="http://misko.hevery.com" title="If you value yourself as an OO developer you should read his posts on testability!">Misko Hevery</a></p>
]]></description>
        <pubDate>Thu, 26 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Class Relationships ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<p><a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">During the introduction</a> we established a simple way to identify objects and their respective classes via looking at <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">nouns and verbs in a text</a>.</p>
<p>Second most important thing when it comes to crafting good OO code is class relationships. Can&rsquo;t really stress enough how important this is. Classes can grow pretty <a href="https://qnoid.com/2010/08/15/polymorphism.html#main">scary</a>. Don&rsquo;t underestimate this technique if you are trying to design software that you aren&rsquo;t familiar with its problem domain. Though very basic its simplicity in identifying class relationships is powerful enough to help you write structured OO code.</p>
<p>Failing to identify proper class relationships can lead to <a href="https://qnoid.com/2011/03/07/On-reusability-part-1-misconceptions.html#main">unnecessary complexity</a>, multiple responsibilities (<a href="https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html#main">driving you crazy</a>), even manifesting <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">concurrency problems</a>.</p>
<p>Looking at the [Survival Kit class][1] you may have noticed that apart from its <strong>cost</strong> all its other <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">properties</a> are a <strong>TShirt</strong>, <strong>Mug</strong>, <strong>Wristband</strong> and 2 <strong>Sticker</strong>(s). As you can tell these are classes. (the most straight forward way to identify a class in code is because its first letter is capitalized, so know your <a href="http://www.oracle.com/technetwork/java/codeconv-138413.html">code conventions</a>)</p>
<p>In other words, each SurvivalKit <strong>has</strong> a TShirt, Mug, Wristband and 2 Sticker(s). So whenever you see a <strong>has</strong> in a text know that you have a <strong>class that is a property in another</strong> (most commonly known as <a href="http://en.wikipedia.org/wiki/Object_composition">composition</a>).</p>
<p>The second relationship comes when a class <strong>is</strong> another. Take a look at everything a SurvivalKit has. You could say that each of them is a <strong>SurvivalKitItem</strong>(s). When a class is another class it simply <strong>inherits all its properties and methods</strong>. Now, there should be a <a href="https://qnoid.com/2010/08/02/abstract-class.html#main">good reason</a> to use the <strong>is</strong> relationship (aka Inheritance) when it comes to classes so use it wisely.</p>
<p>Finally there is <strong>uses</strong>. <em>Uses</em> most of the time is related to method arguments. Therefore <strong>one class is an argument to another&rsquo;s class method</strong>. Would you say that the <em>#dispatch</em> method (which as of now is left stranded) should expect another class as an argument?</p>
<p>With the above in mind, how would you design the <strong>SurvivalKitOrder</strong> class? With which classes should it have a relationship and what type? (<strong>is</strong>, <strong>has</strong>, <strong>uses</strong>)</p>
<p>Would you incorporate inheritance using a <strong>SurvivalKitItem</strong> type. If yes, how and why? Leave your comments below.</p>
<h2 id="disclaimer">Disclaimer</h2>
<p>Things are simplified on purpose. You need to walk before you can run.</p>
]]></description>
        <pubDate>Mon, 23 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Whiteboard</title>
        <link>https://qnoid.com/2010/08/20/Whiteboard.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/20/Whiteboard.html</guid>
        <description><![CDATA[<p>Use the whiteboard at your work to post daily tips. (Look for inspiration in your daily code)</p>
<ul>
<li>Tip should be a single line</li>
<li>Give facts</li>
<li>List benefits</li>
<li>Write an example</li>
</ul>
<p>That way you can improve overall code quality by raising awareness but also helps pinpointing bad code without getting personal ensuring code consistency across the team.</p>
]]></description>
        <pubDate>Fri, 20 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Preamble ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Describing all glasses of water in the known world
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">GlassOfWater</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Material</span><span class="w"> </span><span class="n">material</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Weight</span><span class="w"> </span><span class="n">weight</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">private</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">capacity</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * When creating a new glass of water you have to say what material, how
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * much it weights and how much water it can hold.
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * 
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * Pretty much like &#34;Simon says&#34;
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * 
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @param material the material of the glass
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @param weight its weight
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @param capacity how much water can it hold
</span></span></span><span class="line"><span class="cl"><span class="cm">	 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="nf">GlassOfWater</span><span class="p">(</span><span class="n">Material</span><span class="w"> </span><span class="n">material</span><span class="p">,</span><span class="w"> </span><span class="n">Weight</span><span class="w"> </span><span class="n">weight</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">capacity</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">this</span><span class="p">.</span><span class="na">material</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">material</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">this</span><span class="p">.</span><span class="na">weight</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">weight</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="k">this</span><span class="p">.</span><span class="na">capacity</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">capacity</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @return true if you can smash it, is it made of glass?
</span></span></span><span class="line"><span class="cl"><span class="cm">	 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">smash</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">material</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">Material</span><span class="p">.</span><span class="na">GLASS</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @return true if you can lift it, is it light?
</span></span></span><span class="line"><span class="cl"><span class="cm">	 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="nf">lift</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">weight</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">Weight</span><span class="p">.</span><span class="na">LIGHT</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * Drink responsibly
</span></span></span><span class="line"><span class="cl"><span class="cm">	 *  
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @param amount how much do you want to drink
</span></span></span><span class="line"><span class="cl"><span class="cm">	 * @return what&#39;s left.
</span></span></span><span class="line"><span class="cl"><span class="cm">	 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">drink</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">amount</span><span class="p">){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">capacity</span><span class="w"> </span><span class="o">-=</span><span class="w"> </span><span class="n">amount</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Let&#39;s prove our theory that you can indeed lift/smash and drink from a glass 
</span></span></span><span class="line"><span class="cl"><span class="cm"> * of water
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">GlassOfWaterTest</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">test</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">		 * Here is your glass of water object.
</span></span></span><span class="line"><span class="cl"><span class="cm">		 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">GlassOfWater</span><span class="w"> </span><span class="n">aGlassOfWater</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">GlassOfWater</span><span class="p">(</span><span class="n">Material</span><span class="p">.</span><span class="na">PLASTIC</span><span class="p">,</span><span class="w"> </span><span class="n">Weight</span><span class="p">.</span><span class="na">HEAVY</span><span class="p">,</span><span class="w"> </span><span class="n">330</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">		 * Let&#39;s drink some, water level drops
</span></span></span><span class="line"><span class="cl"><span class="cm">		 */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="kt">int</span><span class="w"> </span><span class="n">remainingWater</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">aGlassOfWater</span><span class="p">.</span><span class="na">drink</span><span class="p">(</span><span class="n">330</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> </span><span class="n">aGlassOfWater</span><span class="p">.</span><span class="na">lift</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">Assert</span><span class="p">.</span><span class="na">assertFalse</span><span class="p">(</span><span class="w"> </span><span class="n">aGlassOfWater</span><span class="p">.</span><span class="na">smash</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">		</span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="w"> </span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">remainingWater</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">	</span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span></span></span></code></pre></div>
This is the first part of the series (<a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">Introduction to object oriented programing</a>) about taking a paragraph of text and identifying objects that are the corner stone of an object oriented program.</p>
<p>Before I go into the actual text let me first establish some basic rules about what is <strong>an object</strong>. Go get a glass of water. It&rsquo;s the first step to understanding OO programming. Go on, I&rsquo;ll be waiting.</p>
<p>Would you say that the glass of water is an object?</p>
<p>If so, how would you describe it? It&rsquo;s made of a material (glass/plastic), has some weight (heavy/light) and holds some amount of water as in; its capacity. It <strong>has properties</strong>.</p>
<p>What can you do with it? Smash it, lift it, and last but not least drink from it. It <strong>has methods</strong>.</p>
<p>Now, take a good look at yours. Is it broken? Is it floating in mid air? Is it half full? Drink some. Is it half empty now? In one word. It <strong>has a state</strong>.</p>
<p>Oh, and it <strong>has a name</strong>. Let&rsquo;s call it <code>aGlassOfWater</code>.</p>
<p>Now there are quite a lot of glasses of water out there. Therefore in order to <strong>define</strong> them we use <strong>a class</strong>.</p>
<p>A class merely describes what a glass of water really is. Thus, its properties and methods. (indirectly describes its possible states as well but leave that for now)</p>
<p>Oh, and it has a name. Let&rsquo;s call it <code>GlassOfWater</code>.</p>
<p>What about time? Or color? Are these objects? What classes would they describe them? Leave <strong>your thoughts</strong> below in the comments.</p>
<p>After that, take a look at the <a href="http://img101.imageshack.us/img101/8135/survivalkit.png" title="survival kit">survival kit</a>. That will be the basis of our OO analysis.</p>
]]></description>
        <pubDate>Sun, 15 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Polymorphism ...Don&#39;t Abuse The If</title>
        <link>https://qnoid.com/2010/08/15/polymorphism.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/15/polymorphism.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Good luck with that. Especially when it grows from a scary one to a mean one.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">ScaryCalculator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Hard to maintain. 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Need to read through the if(s) and identify the code and variables that
</span></span></span><span class="line"><span class="cl"><span class="cm">         * you are interested. Not pleasant.  
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Hard to extend.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Every time you need to add an operation you have to look at that scary
</span></span></span><span class="line"><span class="cl"><span class="cm">         * method and find a way to stick your code in it without messing with the 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * rest. Not fun.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Not reusable.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * You can&#39;t reuse any of the operations on a different class. Not efficient.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">calculate</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">operator</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;+&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">operator</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;-&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">operator</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;*&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">operator</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">else</span><span class="w"> </span><span class="k">if</span><span class="p">(</span><span class="s">&#34;/&#34;</span><span class="p">.</span><span class="na">equals</span><span class="p">(</span><span class="n">operator</span><span class="p">)){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnsupportedOperationException</span><span class="p">(</span><span class="n">operator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Hello polymorphism!
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">FunCalculator</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Interface to the rescue. Each operation is implemented differently.
</span></span></span><span class="line"><span class="cl"><span class="cm">         * So depepnding on the operation you pass in, you get a different result!
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Oh the joy of polymorphism. (Maintenable)
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">calculate</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">Operation</span><span class="w"> </span><span class="n">operation</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">operation</span><span class="p">.</span><span class="na">make</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Want to support a new Operation? Implement this interface! (Extensible)
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Operation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Free to do any operation you like
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">make</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Classes implementing that interface
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Addition</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Operation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">make</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">+</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Subtraction</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Operation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">make</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Multiplication</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Operation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">make</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Division</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Operation</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">make</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">/</span><span class="w"> </span><span class="n">y</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Encapsulates the decision on which operation you get based on the operator.
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Operations for everyone! (Reusable) 
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">OperationFactory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Use a Map as an index for your operations!
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Want to extend to include a new one? Simply put it in the Map!
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Map</span><span class="o">&lt;</span><span class="n">String</span><span class="p">,</span><span class="w"> </span><span class="n">Operation</span><span class="o">&gt;</span><span class="w"> </span><span class="n">operations</span><span class="w"> </span><span class="o">=</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">new</span><span class="w"> </span><span class="n">HashMap</span><span class="o">&lt;</span><span class="n">String</span><span class="p">,</span><span class="w"> </span><span class="n">Operation</span><span class="o">&gt;</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="s">&#34;+&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Addition</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="s">&#34;-&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Subtraction</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="s">&#34;*&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Multiplication</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">this</span><span class="p">.</span><span class="na">put</span><span class="p">(</span><span class="s">&#34;/&#34;</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Division</span><span class="p">());</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @param operator what&#39;s your choice?
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Operation</span><span class="w"> </span><span class="nf">newOperation</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">operator</span><span class="p">)</span><span class="w"> 
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Operation</span><span class="w"> </span><span class="n">operation</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">operations</span><span class="p">.</span><span class="na">get</span><span class="p">(</span><span class="n">operator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * An innocent if
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="p">(</span><span class="n">operation</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">UnsupportedOperationException</span><span class="p">(</span><span class="n">operator</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">operation</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Let&#39;s put it to the test
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">CalculatorTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">make</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">x</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="kt">int</span><span class="w"> </span><span class="n">y</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">2</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">OperationFactory</span><span class="w"> </span><span class="n">operationFactory</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">OperationFactory</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Operation</span><span class="w"> </span><span class="n">addition</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operationFactory</span><span class="p">.</span><span class="na">newOperation</span><span class="p">(</span><span class="s">&#34;+&#34;</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Operation</span><span class="w"> </span><span class="n">subtraction</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operationFactory</span><span class="p">.</span><span class="na">newOperation</span><span class="p">(</span><span class="s">&#34;-&#34;</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Operation</span><span class="w"> </span><span class="n">multiplication</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operationFactory</span><span class="p">.</span><span class="na">newOperation</span><span class="p">(</span><span class="s">&#34;*&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Operation</span><span class="w"> </span><span class="n">division</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">operationFactory</span><span class="p">.</span><span class="na">newOperation</span><span class="p">(</span><span class="s">&#34;/&#34;</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">FunCalculator</span><span class="w"> </span><span class="n">calculator</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">FunCalculator</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">calculator</span><span class="p">.</span><span class="na">calculate</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">addition</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">0</span><span class="p">,</span><span class="w"> </span><span class="n">calculator</span><span class="p">.</span><span class="na">calculate</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">subtraction</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">4</span><span class="p">,</span><span class="w"> </span><span class="n">calculator</span><span class="p">.</span><span class="na">calculate</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">multiplication</span><span class="p">));</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertEquals</span><span class="p">(</span><span class="n">1</span><span class="p">,</span><span class="w"> </span><span class="n">calculator</span><span class="p">.</span><span class="na">calculate</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="w"> </span><span class="n">y</span><span class="p">,</span><span class="w"> </span><span class="n">division</span><span class="p">));</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<strong>If</strong>. One of the fundamental keywords in a programming language and most abused (close second is inheritance [Disclaimer]). Has been there since the dawn of programming so people are fond of it. A joy for juniors as it gives them power to put some logic in their code.</p>
<p>Now, there is nothing wrong with if per se. There are some valid cases where an if is what you need <em>but</em> I have come to realise [Disclaimer] that one if per method should be adequate. (A couple are ok, as long as are part of the same branch)</p>
<p>Usually one of the most common <em>wrong usage</em> of an if is failing to identify polymorphism.</p>
<p>Take a look at the <code>ScaryCalculator#calculate(int, int String)</code> method.</p>
<p>There are actually 2 things going on in the code.</p>
<ul>
<li>the decision on which operation to make</li>
<li>the different operation based on the String operator.</li>
</ul>
<p>When you see a code structured like that you have most likely encountered <a href="https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html#main">polymorphism</a>. (You are blessed) What this means is that you have <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main"><strong>objects</strong></a> that the have a <strong>common method</strong> but <strong>implemented differently</strong>.</p>
<ol>
<li>identify what those objects are. <em>Operation</em>(s); that&rsquo;s your interface.</li>
<li>identify the common code. <em>Make</em> the operation; that&rsquo;s your interface method.</li>
<li>identify the different operations that you have. <em>Addition</em>, <em>Subtraction</em>, <em>Multiplication</em>, <em>Division</em>; these are your <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">classes implementing that interface</a> each encapsulating the relative operation code.</li>
</ol>
<p>Also, use a map for an index if what you actually need is <strong>a choice</strong>!</p>
<p>There are a couple of other <em>wrong usages</em> of if that will try to explore in the <em>Don&rsquo;t abuse the If</em> series, but please feel free to explore them yourself or comment below.</p>
<p><em>The <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">Don&rsquo;t lose your train of thoughts series</a> are far from over</em></p>
<h2 id="disclaimer">Disclaimer</h2>
<p>Not based on scientific research but from experience.</p>
<p>This is example code. Not quality code (limited to 2 numbers, String literals instead of enums) but the advice still stands. Take this instead.</p>
]]></description>
        <pubDate>Sun, 15 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Introduction ...Don&#39;t Lose Your Train Of Thoughts</title>
        <link>https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Survival Kit #1
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Rock some awesome Forrst schwag and show your support for the community.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SurvivalKit</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">     
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">TShirt</span><span class="w"> </span><span class="n">tShirt</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Mug</span><span class="w"> </span><span class="n">mug</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Wristband</span><span class="w"> </span><span class="n">wristband</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="n">stickers</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="nf">SurvivalKit</span><span class="p">(</span><span class="n">TShirt</span><span class="w"> </span><span class="n">tShirt</span><span class="p">,</span><span class="w"> </span><span class="n">Mug</span><span class="w"> </span><span class="n">mug</span><span class="p">,</span><span class="w"> </span><span class="n">Wristband</span><span class="w"> </span><span class="n">wristband</span><span class="p">,</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="n">stickers</span><span class="p">,</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">cost</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">tShirt</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">tShirt</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">mug</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">mug</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">wristband</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">wristband</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">stickers</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">stickers</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">cost</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the tShirt
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">TShirt</span><span class="w"> </span><span class="nf">tShirt</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">tShirt</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the mug
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Mug</span><span class="w"> </span><span class="nf">mug</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">mug</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the wristband
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Wristband</span><span class="w"> </span><span class="nf">wristband</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">wristband</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the stickers
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Collection</span><span class="o">&lt;</span><span class="n">Sticker</span><span class="o">&gt;</span><span class="w"> </span><span class="nf">stickers</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">stickers</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the size
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Size</span><span class="w"> </span><span class="nf">size</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">tShirt</span><span class="p">.</span><span class="na">size</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return the cost
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="nf">cost</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">cost</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p><em>If you are totally unfamiliar with the notion of objects you should read the <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">preamble</a> first</em></p>
<p>To start building an OO program you need objects. The most basic way to identify objects in a text is <strong>looking at the nouns</strong>.</p>
<p>Take a look at the <a href="http://img101.imageshack.us/img101/8135/survivalkit.png" title="survival kit">survival kit</a>. Some of the nouns identified are <strong>tshirt</strong> (cotton), <strong>mug</strong> (coffee, tea, beverage, site), <strong>wristband</strong>, <strong>sticker</strong> (vinyl) and the <strong>survival kit</strong> itself. Also, <strong>shipping</strong> (fee - implied, cost - disguised as an image)</p>
<p>Now since objects are used to do things with or on them the second step is to identify their methods. <strong>Look at the verbs</strong> for that.
<strong>wear</strong>, <strong>enjoy</strong>, <strong>browse</strong>, <strong>purchase</strong>. Some might be disguised like <strong>make friends jealous</strong> or even implied <strong>dispatch</strong> once a purchase is made.</p>
<p>Now all you have to do is make the association between which objects have which methods and create your classes. Some will be straight forward, others not so much.</p>
<p>You might be tempted to define a purchase method in the survival kit but let me ask you this. What is a purchase method supposed to do? Most likely will calculate the cost of the order and dispatch the item to a given address based on a shipping method.</p>
<p>An important thing to have in mind when crafting your OO code is to design classes with <a href="http://en.wikipedia.org/wiki/Single_responsibility_principle"><strong>single responsibility</strong></a>.</p>
<p>You might think, hell that will only create so many classes! Well, if a class has a reason to exist you should do well to create one. There isn&rsquo;t such thing as too many classes <strong>when there is a reason</strong>. Even if you don&rsquo;t create a class, <a href="https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html#main">it will still manifest</a> itself in your code. The ability to correctly identify the right number of classes only comes with experience.</p>
<p>If you are instead troubled that you will end up creating a vast API that will be cumbersome to use and difficult to understand there are other ways to <a href="http://en.wikipedia.org/wiki/Java_syntax#Access_modifiers">hide those classes</a> or <a href="http://en.wikipedia.org/wiki/Design_pattern_(computer_science)">design patterns</a> to make using your API easier.</p>
<p>Although a basic methodology, you will be surprised how effective it is even for those technical specs or system requirements that you read. Especially when you are clueless about the problem domain.</p>
<p>Till the next post, leave your comments below on which class you would define a purchase method and what are some of the objects/classes you have identified in the survival kit.</p>
<p><em>Part of the <a href="https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html#main">Don&rsquo;t lose your train of thoughts</a> series.</em></p>
]]></description>
        <pubDate>Sun, 15 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>You need to know grammar, not math to do Object Oriented programming</title>
        <link>https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/11/you-need-to-know-grammar-not-math-to-do-object-oriented-programming.html</guid>
        <description><![CDATA[<p>Now this is part of a greater series of posts that will follow, about how you go on writing code in <a href="https://qnoid.com/2010/08/15/preamble-dont-lose-your-train-of-thoughts.html#main">an OO world</a>. All the way from analysis to testing covering all sorts of topics and coding practices following a tutorial style.</p>
<p>It strikes me as odd (though I see the reason) that a lot of developers find it hard to correctly <a href="https://qnoid.com/2010/08/15/introduction-dont-lose-your-train-of-thoughts.html#main">identify classes, objects</a>, <a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">class relationships</a>, <a href="https://qnoid.com/2010/08/26/immutability-dont-lose-your-train-of-thoughts.html#main">responsibilities</a> etc.</p>
<p>Seems to me like they quickly try to put their thoughts into code in fear of losing them and as a result have working code -yes- but quite as messy as their thoughts.</p>
<p>Now all the posts (including this one) that will follow on the series will not try to be clever. But hopefully act more like a reminder on what OO programming is all about.</p>
<p>It may sound controversial and some might gasp when I say this but; <strong>what precedes OO programming is grammar not math</strong>. That&rsquo;s OO 101. (though it doesn&rsquo;t seem to be part of any University&rsquo;s module guide)</p>
<p>So what to expect. The series will take a paragraph of text from any source on the internet (could be a wikipedia article, a news story or even a <a href="http://img101.imageshack.us/img101/8135/survivalkit.png">qnoid post</a>) and transform it to object oriented code.</p>
<p>The series will be called <em><strong>&ldquo;Don&rsquo;t lose your <a href="http://en.wikipedia.org/wiki/Train_of_thought">train of thoughts</a>&rdquo;</strong></em>, so don&rsquo;t miss a post!</p>
<h2 id="disclaimer">Disclaimer</h2>
<p>As always, the code that will be part of the series is &ldquo;example code&rdquo;. Do take it seriously, but only as much. Take the advice, not the code.</p>
<h2 id="kudoz">Kudoz</h2>
<p><a href="http://en.wikipedia.org/wiki/Derren_Brown">Derren Brown</a> (inspired for the title &ldquo;Train of Thoughts&rdquo; from one of his <a href="http://en.wikipedia.org/wiki/Derren_Brown#Trick_of_the_Mind">&ldquo;Trick of the Mind&rdquo;</a> episodes)</p>
]]></description>
        <pubDate>Wed, 11 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Be Pissed, Be Polite. Always Say &#34;Good Bye!&#34; (the Reason Behind &#39;finally&#39; In A Try:catch)</title>
        <link>https://qnoid.com/2010/08/05/the-reason-behind-finally.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/05/the-reason-behind-finally.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * You are asking for trouble here
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">buyMuffin</span><span class="p">(</span><span class="n">LocalStore</span><span class="w"> </span><span class="n">localStore</span><span class="p">,</span><span class="w"> </span><span class="n">Flavour</span><span class="w"> </span><span class="n">flavour</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">try</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">localStore</span><span class="p">.</span><span class="na">buyMuffin</span><span class="p">(</span><span class="n">flavour</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">catch</span><span class="p">(</span><span class="n">MuffinNotFoundException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Pissed!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Good bye!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Not my problem I don&#39;t have any money!
</span></span></span><span class="line"><span class="cl"><span class="cm"> * (InsufficientFundsException not handled)
</span></span></span><span class="line"><span class="cl"><span class="cm"> * You aren&#39;t being polite.
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">buyMuffin</span><span class="p">(</span><span class="n">LocalStore</span><span class="w"> </span><span class="n">localStore</span><span class="p">,</span><span class="w"> </span><span class="n">Flavour</span><span class="w"> </span><span class="n">flavour</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">try</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">localStore</span><span class="p">.</span><span class="na">buyMuffin</span><span class="p">(</span><span class="n">flavour</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">catch</span><span class="p">(</span><span class="n">MuffinNotFoundException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Pissed!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Good bye!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * I don&#39;t give a damn! Still have to be polite though.
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">buyMuffin</span><span class="p">(</span><span class="n">LocalStore</span><span class="w"> </span><span class="n">localStore</span><span class="p">,</span><span class="w"> </span><span class="n">Flavour</span><span class="w"> </span><span class="n">flavour</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">try</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">localStore</span><span class="p">.</span><span class="na">buyMuffin</span><span class="p">(</span><span class="n">flavour</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">catch</span><span class="p">(</span><span class="n">MuffinNotFoundException</span><span class="w"> </span><span class="n">e</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Pissed!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">finally</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Good bye!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Just want my muffin
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">buyMuffin</span><span class="p">(</span><span class="n">LocalStore</span><span class="w"> </span><span class="n">localStore</span><span class="p">,</span><span class="w"> </span><span class="n">Flavour</span><span class="w"> </span><span class="n">flavour</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">try</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">localStore</span><span class="p">.</span><span class="na">buyMuffin</span><span class="p">(</span><span class="n">flavour</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="k">finally</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">System</span><span class="p">.</span><span class="na">out</span><span class="p">.</span><span class="na">println</span><span class="p">(</span><span class="s">&#34;Good bye!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span></span></span></code></pre></div>
<p>There has been a lot of debate about exceptions and their usage in the Java world. This post is not about it.</p>
<p>A foreword on what exceptions really are in case you are still confused.</p>
<p>Consider yourself going to your local store to buy a muffin (an addict here).</p>
<p>Now I prefer a chocolate one but the local store might not have one. So I walk in, go to the muffins section and&hellip; there is none! Something unexpected happened (<em>hint</em> an Exception). Yeah I&rsquo;m pissed but I still have to be polite and say goodbye on my way out.</p>
<p>Now the only way to ensure that; is the &lsquo;finally&rsquo; clause in a try/catch block. Here is why.</p>
<p>Without a &lsquo;finally&rsquo; this might very well work. You do handle the exception right there and you still get to say &ldquo;Good bye!&rdquo; at the end. There are 2 things to consider though.</p>
<ul>
<li>the <code>LocalStore#buyMuffin(Flavour)</code> method might very well change (especially if it&rsquo;s third party code) introducing a new exception to the mix (<code>InsufficientFundsException</code> since people were just buying muffins without having enough money to pay). You aren&rsquo;t being polite anymore.</li>
<li>you may not be responsible for handling the situation of not having enough money to buy a muffin. Your dad/employer/clients are. (in the &ldquo;real world&rdquo; an example would be to have a common class to log the exceptions)</li>
</ul>
<p>Now in both cases not having a <code>finally</code> clause will simply break your code sooner or later. (Picture this with database connections and you have a serious leak there)</p>
<p><strong>Disclaimer</strong> Take the advice. Not the code. It&rsquo;s just an example.</p>
]]></description>
        <pubDate>Thu, 05 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>I&#39;m a developer, you are a designer, we get along. We are both Person(s) after all</title>
        <link>https://qnoid.com/2010/08/02/abstract-class.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/08/02/abstract-class.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Person</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * We can both make posts. Woohoo.
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">makePost</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Abstract class encapsulating the highly sophisticated algorithm of writing a
</span></span></span><span class="line"><span class="cl"><span class="cm"> * post. Developer, Designer, doesn&#39;t matter. 
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="kd">class</span> <span class="nc">AbstractPerson</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Person</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">title</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">pasteCode</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">description</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kd">abstract</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">tags</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">makePost</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">title</span><span class="p">(</span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">pasteCode</span><span class="p">(</span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">description</span><span class="p">(</span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">tags</span><span class="p">(</span><span class="n">post</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Developer
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Developer</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">AbstractPerson</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Person</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">title</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">post</span><span class="p">.</span><span class="na">title</span><span class="p">(</span><span class="s">&#34;I&#39;m a developer, you are a designer, we get along. We are both Person(s) after all.&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">pasteCode</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="c1">//Java code about abstract classes and interfaces. Didn&#39;t want to create an endless recursion.</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">description</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         *What&#39;s the difference between an Abstract class and an Interface? 
</span></span></span><span class="line"><span class="cl"><span class="cm">         *Radical. A common misunderstanding and a source of confusion. 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">tags</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">post</span><span class="p">.</span><span class="na">tags</span><span class="p">(</span><span class="s">&#34;java&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Designer
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Designer</span><span class="w"> </span><span class="kd">extends</span><span class="w"> </span><span class="n">AbstractPerson</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Person</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">title</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">post</span><span class="p">.</span><span class="na">title</span><span class="p">(</span><span class="s">&#34;Padded column Compass mixin&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">pasteCode</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * cool CSS snippet
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">description</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/*
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Unfortunately, Compass @column mixin is a bit inefficient, since it 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * just sets width so it requires a nested div to set padding without 
</span></span></span><span class="line"><span class="cl"><span class="cm">         * breaking the grid.
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">protected</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">tags</span><span class="p">(</span><span class="n">Post</span><span class="w"> </span><span class="n">post</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="n">post</span><span class="p">.</span><span class="na">tags</span><span class="p">(</span><span class="s">&#34;CSS&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w"></span><span class="p">}</span></span></span></code></pre></div>
<p>What&rsquo;s the difference between an Abstract class and an Interface? Radical.
A common misunderstanding and a source of confusion.</p>
<p>I&rsquo;m a developer, you are a designer. That&rsquo;s fine. We should both be able to make posts in Forrst. We are <em>Person</em>(s) after all.</p>
<p><em>An interface</em> is all about behaviour. What can both a Developer and a Designer do in Forrst? That&rsquo;s right, make posts. That&rsquo;s our common behaviour here in Forrst, what makes us interchangeable.</p>
<p>Now I will be most likely writing about Java and you will be showcasing your million dollar design, <strong>but</strong> we both have to go through the same process of writing our post.</p>
<ul>
<li>Specify a <em>title</em></li>
<li>Paste some <em>code</em></li>
<li>Enter a <em>description</em></li>
<li>Put some <em>tags</em></li>
</ul>
<p>Now that&rsquo;s a pretty nifty algorithm that we both have to go through to write a post and that&rsquo;s what a base class is good at. Encapsulating common code.</p>
<p>However, since we won&rsquo;t be writing the same stuff anyway though (title, code, description, tags), it&rsquo;s destined to be abstract.</p>
<p><em>A follow up post titled <a href="https://qnoid.com/2010/09/13/Can-an-Abstract-Class-and-an-Interface-play-nice-together.html#main">Why I don&rsquo;t drive a Porsche</a> tries to put the final nail in the coffin on when/how to use an interface compared to an abstract class</em></p>
<p><strong>Disclaimer:</strong> Another trivial example, don&rsquo;t put that in production code please.
<em>Special thanks:</em> @sugarenia for the designer&rsquo;s <a href="http://forrst.com/posts/Padded_column_Compass_mixin-e1D" title="code">code</a></p>
]]></description>
        <pubDate>Mon, 02 Aug 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Focus on your test, leave buggage behind</title>
        <link>https://qnoid.com/2010/07/29/Focus-on-your-test-leave-buggage-behind.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/07/29/Focus-on-your-test-leave-buggage-behind.html</guid>
        <description><![CDATA[<p><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">MySelfTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">goOutWithYourMates</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MySelf</span><span class="w"> </span><span class="n">mySelf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MySelf</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Not DRY
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">mySelf</span><span class="p">.</span><span class="na">getOver</span><span class="p">(</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ExGirlfriend</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">mySelf</span><span class="p">.</span><span class="na">goOutWithYourMates</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">playStarcraft</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MySelf</span><span class="w"> </span><span class="n">mySelf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MySelf</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">             * Not DRY
</span></span></span><span class="line"><span class="cl"><span class="cm">             */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">mySelf</span><span class="p">.</span><span class="na">getOver</span><span class="p">(</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ExGirlfriend</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">mySelf</span><span class="p">.</span><span class="na">playStarcraft</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * DRY yourself
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Create implementations of this interface with your conditions
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">interface</span> <span class="nc">Condition</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Put the condition logic here 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">apply</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Introduce Preconditions
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">class</span> <span class="nc">Preconditions</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">static</span><span class="w"> </span><span class="n">Condition</span><span class="w"> </span><span class="nf">all</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">Condition</span><span class="p">...</span><span class="w"> </span><span class="n">conditions</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Condition</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">apply</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="k">for</span><span class="w"> </span><span class="p">(</span><span class="n">Condition</span><span class="w"> </span><span class="n">condition</span><span class="w"> </span><span class="p">:</span><span class="w"> </span><span class="n">conditions</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                        </span><span class="n">condition</span><span class="p">.</span><span class="na">apply</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="p">}</span><span class="w">                
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">static</span><span class="w"> </span><span class="n">Condition</span><span class="w"> </span><span class="nf">buggageShouldBeLeftBehind</span><span class="p">(</span><span class="kd">final</span><span class="w"> </span><span class="n">MySelf</span><span class="w"> </span><span class="n">mySelf</span><span class="p">,</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Girlfriend</span><span class="w"> </span><span class="n">girlfriend</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Condition</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">apply</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                    </span><span class="n">mySelf</span><span class="p">.</span><span class="na">getOver</span><span class="p">(</span><span class="w"> </span><span class="n">girlfriend</span><span class="w"> </span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">};</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Leave buggage behind
</span></span></span><span class="line"><span class="cl"><span class="cm">     *
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">MySelfTest</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">goOutWithYourMates</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MySelf</span><span class="w"> </span><span class="n">mySelf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MySelf</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">buggageShouldBeLeftBehind</span><span class="p">(</span><span class="n">mySelf</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ExGirlfriend</span><span class="p">()).</span><span class="na">apply</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">mySelf</span><span class="p">.</span><span class="na">goOutWithYourMates</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Test</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">playStarcraft</span><span class="p">()</span><span class="w"> </span><span class="kd">throws</span><span class="w"> </span><span class="n">Exception</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">MySelf</span><span class="w"> </span><span class="n">mySelf</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">MySelf</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Preconditions</span><span class="p">.</span><span class="na">buggageShouldBeLeftBehind</span><span class="p">(</span><span class="n">mySelf</span><span class="p">,</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">ExGirlfriend</span><span class="p">()).</span><span class="na">apply</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Assert</span><span class="p">.</span><span class="na">assertTrue</span><span class="p">(</span><span class="w"> </span><span class="n">mySelf</span><span class="p">.</span><span class="na">playStarcraft</span><span class="p">()</span><span class="w"> </span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
Use a class to define your Preconditions.</p>
<p>You don&rsquo;t pollute your test class with methods not related explicitly to your tests and avoid boilerplate code.</p>
<p>Preconditions class</p>
<ul>
<li>encapsulates the Condition(s)</li>
</ul>
<p>while making your code</p>
<ul>
<li>readable</li>
<li>reusable</li>
</ul>
<p>Can apply to any conditions you would like to encapsulate really.</p>
<p><strong>Disclaimer</strong>: It&rsquo;s a trivial example to make you think of an alternative way to apply pre/post conditions to your tests.</p>
]]></description>
        <pubDate>Thu, 29 Jul 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Everytime you write an init method a developer gets an Exception ...Simply Don&#39;t</title>
        <link>https://qnoid.com/2010/07/22/Everytime-you-write-an-init-method-a-developer-gets-an-Exception-simply-dont.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/07/22/Everytime-you-write-an-init-method-a-developer-gets-an-Exception-simply-dont.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Plane</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kt">boolean</span><span class="w"> </span><span class="n">engineStarted</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * Don&#39;t do that
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">init</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">startEngine</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * 
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">startEngine</span><span class="p">(){</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">engineStarted</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="kc">true</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">PlaneFactory</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">         * @return a new {@link Plane} ready to take off
</span></span></span><span class="line"><span class="cl"><span class="cm">         */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Plane</span><span class="w"> </span><span class="nf">newPlane</span><span class="p">()</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Plane</span><span class="w"> </span><span class="n">plane</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">Plane</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">plane</span><span class="p">.</span><span class="na">startEngine</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="n">plane</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Don&rsquo;t write #init methods. They only add an extra place for the client code to look for and lead to frustration when trying to figure out what went wrong.</p>
<p>Instead use a factory method to return an object to the required state and document that.</p>
]]></description>
        <pubDate>Thu, 22 Jul 2010 00:00:00 +0200</pubDate>
      </item>
      <item>
        <title>Apply polymorphism or you will drive yourself crazy</title>
        <link>https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html?utm_source=blog+rss+feed&amp;utm_medium=rss&amp;utm_campaign=rss+feed</link>
        <guid isPermaLink="true">https://qnoid.com/2010/07/22/Apply-polymorphism-or-you-will-drive-yourself-crazy.html</guid>
        <description><![CDATA[<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="w">	</span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Psychiatrist</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">Psychiatrist</span><span class="p">(</span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Prescription</span><span class="w"> </span><span class="nf">takeCare</span><span class="p">(</span><span class="n">MultiplePersonality</span><span class="w"> </span><span class="n">personality</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">// MultiplePersonality may have been created with a </span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">// String, Integer or just a Boolean</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">// try to get a String from MultiplePersonality object</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">personality</span><span class="p">.</span><span class="na">areYouAString</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">string</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="p">.</span><span class="na">isAString</span><span class="p">(</span><span class="n">string</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="p">.</span><span class="na">getPrescription</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">// or try to get an Integer from MultiplePersonality object</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Integer</span><span class="w"> </span><span class="n">integer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">personality</span><span class="p">.</span><span class="na">areYouAnInteger</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">integer</span><span class="w"> </span><span class="o">!=</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="p">.</span><span class="na">isAnInteger</span><span class="p">(</span><span class="n">integer</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="p">.</span><span class="na">getPrescription</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">// or try to get just a Boolean from MultiplePersonality object</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">Boolean</span><span class="w"> </span><span class="n">nuts</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">personality</span><span class="p">.</span><span class="na">areYouNuts</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="p">(</span><span class="n">nuts</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="kc">null</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">                </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">RuntimeException</span><span class="p">();</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="kc">null</span><span class="p">;</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * Instead use this
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Psychiatrist</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">Psychiatrist</span><span class="p">(</span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Prescription</span><span class="w"> </span><span class="nf">takeCare</span><span class="p">(</span><span class="n">Personality</span><span class="w"> </span><span class="n">personality</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="k">return</span><span class="w"> </span><span class="k">this</span><span class="p">.</span><span class="na">pharmacy</span><span class="p">.</span><span class="na">getPrescription</span><span class="p">(</span><span class="n">personality</span><span class="p">);</span><span class="w">        
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">Pharmacy</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">isAString</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">isAnInteger</span><span class="p">(</span><span class="n">Integer</span><span class="w"> </span><span class="n">integer</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="n">Prescription</span><span class="w"> </span><span class="nf">getPrescription</span><span class="p">(</span><span class="n">Personality</span><span class="w"> </span><span class="n">personality</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">personality</span><span class="p">.</span><span class="na">whatAreYou</span><span class="p">(</span><span class="k">this</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="c1">//decide upon prescription</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm">     * With a Personality for each
</span></span></span><span class="line"><span class="cl"><span class="cm">     */</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">IntegerPersonality</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Personality</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">Integer</span><span class="w"> </span><span class="n">integer</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">IntegerPersonality</span><span class="p">(</span><span class="n">Integer</span><span class="w"> </span><span class="n">integer</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">integer</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">integer</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">whatAreYou</span><span class="p">(</span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">pharmacy</span><span class="p">.</span><span class="na">isAnInteger</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">integer</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">StringPersonality</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Personality</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="kd">final</span><span class="w"> </span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">private</span><span class="w"> </span><span class="nf">StringPersonality</span><span class="p">(</span><span class="n">String</span><span class="w"> </span><span class="n">string</span><span class="p">)</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">this</span><span class="p">.</span><span class="na">string</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">string</span><span class="p">;</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">whatAreYou</span><span class="p">(</span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="n">pharmacy</span><span class="p">.</span><span class="na">isAString</span><span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="na">string</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="kd">public</span><span class="w"> </span><span class="kd">class</span> <span class="nc">SanePersonality</span><span class="w"> </span><span class="kd">implements</span><span class="w"> </span><span class="n">Personality</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="nd">@Override</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="kd">public</span><span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="nf">whatAreYou</span><span class="p">(</span><span class="n">Pharmacy</span><span class="w"> </span><span class="n">pharmacy</span><span class="p">)</span><span class="w"> </span><span class="p">{</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">            </span><span class="k">throw</span><span class="w"> </span><span class="k">new</span><span class="w"> </span><span class="n">RuntimeException</span><span class="p">(</span><span class="s">&#34;I&#39;m sane!&#34;</span><span class="p">);</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">        </span><span class="p">}</span><span class="w">
</span></span></span><span class="line"><span class="cl"><span class="w">    </span><span class="p">}</span></span></span></code></pre></div>
<p>Don&rsquo;t try to do to much. (<a href="https://qnoid.com/2010/08/23/class-relationships-dont-lose-your-train-of-thoughts.html#main">Class Relationships</a>). Identify polymorphism in 3 steps. (<a href="https://qnoid.com/2010/08/15/polymorphism.html#main">How to identify polymorphism</a>)?</p>
<ul>
<li>find the common operation (e.g. #whatAreYou)</li>
<li>find how is every operation different and put it in a method in each own class (e.g. #isAString, #isAnInteger, &ldquo;is nuts&rdquo;)</li>
<li>introduce an interface for the above classes with that common method</li>
</ul>
<p>That&rsquo;s all really. Try it with a Calculator example now.</p>
<p>Using polymorphism will</p>
<ul>
<li>eliminate the need for multiple if(s)</li>
<li>eliminate the check for null</li>
<li>eliminate the exceptional case (in this case to return null)</li>
</ul>
<p>Plus on each Personality class you get</p>
<ul>
<li>final fields</li>
<li>single responsibility</li>
<li>encapsulation</li>
</ul>
<p><strong>Disclaimer</strong>: This is actual (disguised) code as seen on a very popular API. There are even more problems to discuss about it but let&rsquo;s just focus on one thing at a time.</p>
]]></description>
        <pubDate>Thu, 22 Jul 2010 00:00:00 +0200</pubDate>
      </item>
  </channel>
</rss>
