<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>intro on Dan Lowe</title>
    <link>https://danlowe.me/tags/intro/</link>
    <description>Recent content in intro on Dan Lowe</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-us</language>
    <managingEditor>dan@danlowe.me (Dan Lowe)</managingEditor>
    <webMaster>dan@danlowe.me (Dan Lowe)</webMaster>
    <lastBuildDate>Thu, 07 Jun 2018 15:26:59 -0400</lastBuildDate>
    
	<atom:link href="https://danlowe.me/tags/intro/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Why Kotlin? An Introduction. (Part 6)</title>
      <link>https://danlowe.me/post/2018-06-06-kotlin-6/</link>
      <pubDate>Thu, 07 Jun 2018 15:26:59 -0400</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-06-06-kotlin-6/</guid>
      <description>This post is going to be a short but sweet one as I introduce the power of Kotlin extensions!
Kotlin extensions allow you to simply extend the functionality of a given object. Say for some reason you&#39;re developing an Android app and find yourself passing around an instance of context a lot to get a simple desired result. As everyone (should) know, passing around an instance of context is dangerous. It can lead to memory leaks and makes your application more coupled, complicating testing.</description>
    </item>
    
    <item>
      <title>Why Kotlin? An Introduction. (Part 5)</title>
      <link>https://danlowe.me/post/2018-05-05-kotlin-5/</link>
      <pubDate>Sat, 05 May 2018 12:12:34 -0400</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-05-05-kotlin-5/</guid>
      <description>It has been a little too long since my last post, but it&#39;s been a busy couple of months as I&#39;ve been pushing hard to get some of my side projects moving along. Be on the lookout in the future as I plan to start going into more Android focused posts.
If you&#39;re familiar with C your mind probably just jumped (pun intended) to a bad place. Don&#39;t worry though, Kotlin&#39;s implementation isn&#39;t anything as divisive as Dijkstra&#39;s or Rubin&#39;s arguments.</description>
    </item>
    
    <item>
      <title>Why Kotlin? An Introduction. (Part 4)</title>
      <link>https://danlowe.me/post/2018-03-16-kotlin-4/</link>
      <pubDate>Fri, 16 Mar 2018 19:19:10 -0400</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-03-16-kotlin-4/</guid>
      <description>We&#39;re going back to some of the good stuff right now. Control flow! Last week was a little more ranty, with a little less real content than I like, so I&#39;m going to try to put a little more content in this week.
ZZZzzzzz&amp;hellip;. We&#39;ll get the boring stuff out of the way first&amp;hellip; What&#39;s the same in Kotlin as in Java? Most of it&amp;hellip;
While and Do While still doing the same thing Kotlin:</description>
    </item>
    
    <item>
      <title>Why Kotlin? An Introduction. (Part 3)</title>
      <link>https://danlowe.me/post/2018-03-09-kotlin-3/</link>
      <pubDate>Fri, 09 Mar 2018 01:30:25 -0500</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-03-09-kotlin-3/</guid>
      <description>Lets follow up the discussion about nullability and talk about error handling in Kotlin. Syntactically, the differences from Java are pretty nominal, except for one pretty major key difference that I&#39;ll get to in just a second.
First some code to demonstrate how similar Kotlin Exceptions are to Java&#39;s Exception handling:
fun doSomething(data : String) { if(data.contains(&amp;#34;test&amp;#34;)) { throw IllegalStateException(&amp;#34;Test!&amp;#34;) } } fun main() { try { doSomething(&amp;#34;testData&amp;#34;) } catch (e : Exception) { // This will always get called because an exception is thrown if a String containing &amp;#34;test&amp;#34; is passed to doSomething(.</description>
    </item>
    
    <item>
      <title>Why Kotlin? An Introduction. (Part 2)</title>
      <link>https://danlowe.me/post/2018-03-02-kotlin-2/</link>
      <pubDate>Sun, 04 Mar 2018 21:32:51 -0500</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-03-02-kotlin-2/</guid>
      <description>In the first part of this series I stated I&#39;d very likely start all my new Android projects in Kotlin. Don&#39;t get me wrong, I don&#39;t hate Java, but why would I make such a bold claim? The answer is null. Or more specifically, the explicit detraction of the use of null that Kotlin promotes. Kotlin has some nice features, but its handling of null variables is what hooked me.</description>
    </item>
    
    <item>
      <title>Why Kotlin? An Introduction. (Part 1)</title>
      <link>https://danlowe.me/post/2018-03-02-kotlin-1/</link>
      <pubDate>Fri, 02 Mar 2018 19:28:56 -0500</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-03-02-kotlin-1/</guid>
      <description>The Awakening When Kotlin was announced as a first class Android language at Google I/O in 2017, I like many Android developers, was skeptical. As an ardent user of Jetbrains products for a number of years now I haven&#39;t been oblivious to Kotlin, but I&#39;ve only recently begun to take Kotlin seriously. In fact, after developing CoinWatch in Kotlin, I don&#39;t know that I&#39;m going to start another Android project in Java (willingly) ever again.</description>
    </item>
    
    <item>
      <title>Where to from here?</title>
      <link>https://danlowe.me/post/2018-02-21-where-to-from-here/</link>
      <pubDate>Wed, 21 Feb 2018 15:33:38 -0500</pubDate>
      <author>dan@danlowe.me (Dan Lowe)</author>
      <guid>https://danlowe.me/post/2018-02-21-where-to-from-here/</guid>
      <description>The short answer&amp;hellip; everywhere.
It&#39;d feel weird to just start writing a blog without explaining why. I could just go right into a technical topic, but I think it is important to draw some context into why I want to write. Basically, I want to share my knowledge and maybe some thoughts at times.
I have a wide range of interests. I&#39;m not just an Android developer, I&#39;m not just a backend developer.</description>
    </item>
    
  </channel>
</rss>