<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Karlo Miguel on Medium]]></title>
        <description><![CDATA[Stories by Karlo Miguel on Medium]]></description>
        <link>https://medium.com/@karlomiguelpyu?source=rss-c9d340064674------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*sz8fzevGF2hpQG_AEnSaXg.png</url>
            <title>Stories by Karlo Miguel on Medium</title>
            <link>https://medium.com/@karlomiguelpyu?source=rss-c9d340064674------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:32:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@karlomiguelpyu/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[A Brief Intro to Dagger Hilt]]></title>
            <link>https://medium.com/swlh/a-brief-intro-to-dagger-hilt-979dce3c8788?source=rss-c9d340064674------2</link>
            <guid isPermaLink="false">https://medium.com/p/979dce3c8788</guid>
            <category><![CDATA[dagger-hilt]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[dagger]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Karlo Miguel]]></dc:creator>
            <pubDate>Tue, 21 Jul 2020 09:39:00 GMT</pubDate>
            <atom:updated>2020-07-21T16:30:11.525Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*neyWh2Zi1BsT4sBuWy_BCA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@jupp?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Jonathan Kemper</a> on <a href="https://unsplash.com/s/photos/android?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure><p><strong>Dependency injection (DI), </strong>in a nutshell, is a technique whereby one object provides or supplies the dependencies of another instead of creating it by themselves. This will let you have good architecture for your application and better code reusability.</p><p>In Android, <strong>Dagger</strong> is the dependency injection library that is recommended by Google for dependency injection. But let’s face it, there are a lot of overheads when setting up Dagger that beginners might shy away from.</p><p>This is where <strong>Dagger Hilt</strong> for Android comes in.</p><h3>What is Dagger Hilt?</h3><p>Hilt, built on top of Dagger, is now the <strong>new</strong> recommended DI library from Google which would help to simplify setting up Dagger in your applications.</p><p>The previous Components that we created in our app, exists now in the predefined components that are being provided to us, out of the box, by Hilt. So we won’t need to define these directly. The built-in components are also automatically integrated into the lifecycle of your app, which is really neat.</p><p>To check out these components, take a look <a href="https://dagger.dev/hilt/components">here</a>.</p><h3><strong>The Setup</strong></h3><p>We first need to add the following to our project level build.gradle</p><pre>classpath &#39;com.google.dagger:hilt-android-gradle-plugin:2.28-alpha&#39;</pre><p>Then in our module level build.gradle</p><pre>apply plugin: &#39;dagger.hilt.android.plugin&#39;</pre><p>Finally, we can now add the required dependencies for us to use Hilt</p><pre>implementation &#39;com.google.dagger:hilt-android:2.28-alpha&#39;<br>kapt &#39;com.google.dagger:hilt-android-compiler:2.28-alpha&#39;<br>implementation &#39;androidx.hilt:hilt-lifecycle-viewmodel:1.0.0-alpha01&#39;<br>kapt &#39;androidx.hilt:hilt-compiler:1.0.0-alpha01&#39;</pre><p>When everything is synced up, we now need to annotate our application class with @HiltAndroidApp, this will generate the different Hilt components along with the base class of our application.</p><p>For our Activity/Fragment we would annotate it with@AndroidEntryPoint, this will generate the required component that will receive the dependencies that are going to be injected in our Activity/Fragment.</p><p>In cases that we have a class that has a required constructor argument</p><pre>class SampleClass (val anotherSampleClass: AnotherSampleClass) {}</pre><p>We can use Hilt modules to inject the required argument. Take a look at the sample below.</p><pre>@Module<br>@InstallIn(ActivityComponent::class)<br>class SampleModule {<br><br>  @Provides<br>  fun provideAnotherSampleClass(...: ...) = AnotherSampleClass(...)<br>}</pre><p>Hilt reuses Dagger’s @Module annotation but in Hilt, instead of specifying which modules the component will use, we specify in each module that we create in which component it will be installed in, @InstallIn(...Component::class) and we would still use @Provides and @Binds annotation as to how we use to before.</p><h3>ViewModel</h3><p>Any ViewModel that is annotated with @ViewModelInject constructor() can be provided from the ViewModelFactory of Hilt. This will generate, behind the scenes, the respective factories. The ViewModel can also receive the SavedStateHandle using the annotation @Assisted, without any more configuration. Sweet!</p><pre>class SampleViewModel @ViewModelInject constructor(<br>   val argument: AnotherSampleClass, <br>   @Assisted val savedStateHandle: SavedStateHandle<br>) : ViewModel() {}</pre><p>And in our Activity/Fragment, we can get the of the view model by ktx extension function.</p><pre>@AndroidEntryPoint<br>class SampleFragment : Fragment() {    </pre><pre>   val viewModel by viewModels&lt;SampleViewModel&gt;()<br>}</pre><h3><strong>Conclusion</strong></h3><p>With what we’ve just seen above, we have set up our Android app with DI with the use of Dagger-Hilt. It surely reduced the boilerplate in setting up the whole dependency injection in Android which was quite cumbersome before Hilt came along.</p><p>It allowed us to be up and running the DI in no time and with less code. It hides the complexity from us, developers, to let us focus on building other important things.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=979dce3c8788" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/a-brief-intro-to-dagger-hilt-979dce3c8788">A Brief Intro to Dagger Hilt</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android is better off with Kotlin]]></title>
            <link>https://medium.com/@karlomiguelpyu/android-is-better-off-with-kotlin-4a9a6e80de6d?source=rss-c9d340064674------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a9a6e80de6d</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Karlo Miguel]]></dc:creator>
            <pubDate>Mon, 05 Feb 2018 13:22:53 GMT</pubDate>
            <atom:updated>2018-11-07T14:28:10.336Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*nCrl3O_a5jccxdmYHsGfLw@2x.png" /></figure><p>There was a lot of buzz going on around about Kotlin and I just recently gave it a try and after a month or so with it, I said to myself that this is the way to go for all Android developers out there especially that Android Studio now <strong>officially supports</strong> Kotlin out of the box. ;)</p><blockquote>Here’s some quick facts about Kotlin.<br>- it reduces a lot of boilerplate code that we all hate<br>- it is null safe<br>- it is 100% interoperable with java<br>- exceptions are unchecked, only in runtime<br>- leaner syntax<br>- and many many more…</blockquote><pre>class MainActivity : AppCompatActivity() {<br>    override fun onCreate(savedInstanceState: Bundle?) {<br>    super.onCreate(savedInstanceState)<br>    setContentView(R.layout.activity_main)<br>  }<br>}</pre><p>When extending or inheriting something in Java we use the <em>extends</em> keyword but as you can see above, MainActivity : AppCompatActivity(), it was replaced by a : in Kotlin which makes everything more easier to read.</p><p>And the ? symbol after Bundle means that <em>savedInstanceState</em> can be of <em>Bundle</em> type or <em>null</em>. As I’ve stated earlier, Kotlin is a <strong>null safe</strong> language. We’ll talk more of that later on this post.</p><p>Furthermore, we <strong>don’t need</strong> to end each line of code with a ;, yey!!!, but you may if you like.</p><h3>It’s all about having fun in Kotlin</h3><p>Declarations of functions starts with the keyword fun, which unsurprisingly, stands for function and the return type comes at the end, separated by a :.</p><pre>fun getUser(id: Int): User { ... }</pre><p>There is no void in Kotlin, it’s called <strong>Unit</strong> instead. To return a Unit, just omit the return type in the end like in:</p><pre>fun initRecyclerview() { ... }</pre><h3>Overloading Functions</h3><p>In Java, when two or more methods within the same class with the same name but with different parameters, the methods are said to be overloaded. So let’s say we have to create an overloaded method with a maximum of 3 parameters.</p><pre>public void disp(String s) {<br>  // <em>do something</em><br>}<br>public void disp(String s, int i) {<br>  // <em>do something</em><br>}<br>public void disp(String s, int i, double d) {<br>  // <em>do something</em><br>}</pre><p>And which method to be called is determined through the types and number of parameters.</p><pre>disp(&quot;sample&quot;);          // <em>calls first method above</em><br>disp(&quot;sample&quot;,10);       // <em>calls the second method above</em><br>disp(&quot;sample&quot;,10,23.56); // <em>calls the third method above</em></pre><p>With Kotlin, we have something called <strong>default arguments, </strong>you can specify a default value for a parameter. The default value will be used when the corresponding argument is omitted from the function call.</p><pre>fun display(s: String = &quot;default&quot;, i: Int = 0, d: Double = 1.0) {<br>  // <em>do something<br></em>}</pre><p>This will allow us to call the function as:</p><pre>display(&quot;sample&quot;)          // <em>sample 0 1.0</em><br>display(&quot;sample&quot;,10)       // sample 10 1.0 <br>display(&quot;sample&quot;,10,23.56) // sample 10 23.56<br>display(10)                // default 10 23.56<br>display(&quot;sample&quot;,23.56)    // sample 0 23.56</pre><p>If the function declaration has a default argument and preceded by a non-default argument, then the default argument can’t be used while calling the function. Consider the following example.</p><pre>fun display(s: String = &quot;default&quot;, i: Int, d: Double = 1.0) {<br>  // <em>do something<br></em>}</pre><p>The i from the function above does not have a default value so the default value of s can’t be used and also you can’t omit the parameter i from the call.</p><pre>display(23.56) // <em>this will cause an error because no value for i</em></pre><p>A function with a position-based arguments is that the first argument corresponds to the first parameter, the second argument corresponds to the second parameter, etc.</p><p>So for passing a value to the second parameter, i, we first need to specify a value for the first parameter.</p><pre>display(&quot;sample&quot;,10)<br>display(&quot;sample&quot;,10,23.56)</pre><p>However, this is also solved with another feature of Kotlin called <strong><em>Named Arguments</em></strong>.</p><p>Kotlin allows you to name the arguments that you’re passing to the function. This allows you to pass a value of a parameter selectively if other parameters have default values.</p><pre>fun display(s: String = &quot;default&quot;, i: Int, d: Double = 1.0) {<br>  // <em>do something<br></em>}</pre><pre>display(i = 10)</pre><p>We can call the function with all the parameters as well.</p><pre>display(s = &quot;sample&quot;,i = 10,d = 23.56)</pre><p>We can also reorder the specifying of arguments.</p><pre>display(d = 23.56, s = &quot;sample&quot;, i = 10)</pre><p>You can also do something like this:</p><pre>display(&quot;sample&quot;,i = 10)<br>display(&quot;sample&quot;,i = 10,23.56)</pre><h3>Declaring Variables</h3><p>Variable declarations in Kotlin do not start with the variable’s type as with compared to Java, same with function declarations which starts with a keyword, it always starts with val or var. For example in Java: int i = 29, the very same declaration in Kotlin is: var i : Int = 29.</p><p>But the very nice thing about Kotlin is that even though it is strongly typed, <strong><em>you don’t need to declare the variable’s type explicitly</em></strong><em>,</em> but let the compiler figure it out by itself. So the declaration in Kotlin just becomes var i = 29.</p><h4>val or var?</h4><p>So with the variables declared with the keyword var can be reassigned later on, while those declared with the val keyword is final.</p><pre>private val api = RestApi()</pre><p>Kotlin got rid of the new keyword, so as you can see, new instances are constructed without it, just call the constructor like any other method.</p><p>Visibility modifiers means the same thing as in Java. The default visibility, if there is no modifier specified, is public. Otherwise, specify it to be private.</p><h3>Safety Features of Kotlin</h3><p>To start, you have to declare if a variable may be null or not.</p><pre>var a : String</pre><p>You will get a compilation error as opposed to a <strong>NullPointerException (NPE)</strong> at runtime, because variable a must be initialised. So you have to write it as</p><pre>var a: String = “A”</pre><p>Also, you will get a compilation error when you set a to null, to make it nullable, you have to add ? to the variable’s type:</p><pre>var a: String? = null</pre><p>So now, if we try a.length it will give us a another compilation error because Kotlin will not allow us to do such a thing because a can be null at some point. It will force us to use ? or !! operator.</p><pre>a?.length</pre><p>Now, the line will only proceed if a is not null, This is a neat feature of Kotlin because it helps us avoid NPE. But if we use !! operator instead, a!!.length, we must be sure that a will <strong>never, ever be null</strong> or else we’ll have NPE, yet again, it’s just for adventurers like me. ;)</p><h3>Timer Saver for Properties</h3><p>This can be very tedious, requiring a getter/setter method for each field in Java. For reference, take this:</p><pre>public class User <strong>{</strong><br>  private String firstName;<br>  …</pre><pre>  public User(String firstName, …) <strong>{</strong><br>    this.firstName = firstName;<br>    …<br>  <strong>}</strong></pre><pre>  public void setFirstName(String firstName) <strong>{</strong><br>    this.firstName = firstName;<br> <strong> }</strong><br> <br>  public String getFirstName()<strong> {</strong><br>    return this.firstName;<br>  <strong>}</strong></pre><pre>  …<br><strong>}</strong></pre><p>And the Kotlin equivalence for this is:</p><pre>data class User(var firstName: String, …)</pre><p>Bunch of lines of codes for Java compared to Kotlin. It’s simple. elegant and easy on the eyes. HA! In your face Java! :D</p><p>We have to put the data keyword before class to let Kotlin know that it is our data model.</p><pre>user.firstName = “Karlo”<br>var fN = user.firstName</pre><p>Kotlin is smart enough here to convert it to Java getter/setter, so when running this you are actually calling user.setFirstName(“Karlo”) and user.getFirstName() behind the scenes.</p><h3>Extension Functions</h3><p>This is another great feature of Kotlin, you can add behaviour to a class we did not write ourselves without directly extending it. <em>This is</em> <em>safe and clean</em>. You call a function from an object as if it were part of its class.</p><p>Imagine you always have to format dates in your project. Traditionally you’ll make a utility class for this, just for example:</p><pre>fun formatDate(date: String) : String <strong>{</strong> <br>  ...<br>  format.parse(date)<br>  // <em>do formatting</em> <br>  return foramattedDate<br><strong>}</strong></pre><p>Then we use it like, UtilityClass.formatDate( “01/01/2018”). But we can do it better with extension functions.</p><pre>fun String.formatDate(): String <strong>{</strong><br>  ...<br>  format.parse(this)<br>  // <em>do formatting</em><br>  return foramattedDate<br><strong>}</strong></pre><p>The String. prefix before the function name is the so called <em>receiver type</em>, meaning the type being extended which in this case is <strong>String</strong> in our example.</p><p>We basically teach the String class how to format dates and return it. Then we just call it like any other member function.</p><pre>val formattedDate = “01/01/2018”.formatDate()</pre><p>Also, as there is no more an argument within the function’s body compared to the traditional utility class, we use this instead to refer to it, <em>i.e. </em><em>“01/01/2018”.formatDate() — the instance the function gets called on becomes </em><em>this in our declaration.</em></p><h3>Scoping Functions</h3><p>This is one of the features that I like. Let’s take an example from Java:</p><pre>Address address = new Address();<br>address.setStreet = &quot;Foo Street&quot;;<br>address.setCity = &quot;Bar City&quot;;<br>address.setCountry = &quot;FooBar&quot;;<br>address.setPostalCode = 20521;</pre><p>In Kotlin this would be:</p><pre>val address = Address()<br>address.street = &quot;Foo Street&quot;<br>address.city = &quot;Bar City&quot;<br>address.country = &quot;FooBar&quot;<br>address.postalCode = 20521</pre><p>But because of scoping functions in Kotlin, this can be:</p><pre>val address = Address().<em>apply</em><strong>{</strong><br>   street = &quot;Foo Street&quot;<br>   city = &quot;Bar City&quot;<br>   country = &quot;FooBar&quot;<br>   postalCode = 20521<br><strong>}</strong></pre><p>With apply, you can enclose the assignment of an object in a single expression, which looks less redundant and a very readable code.</p><p>Besides apply, there are still other scoping functions signature like with,run, let, etc. It really depends on the developer when to use one from another. Let’s take a recyclerview as an example.</p><h4>with and run</h4><p>with is being used as a function, so the receiver is passed as an argument</p><pre><em>with</em>(sampleRecyclerView) <strong>{<br>    </strong>hasFocus()<br>    smoothScrollMapToPosition(2)<br>    setHasFixedSize(true)<br><strong>}</strong></pre><p>whereas run is being called directly from the receiver as it is an extension function</p><pre>sampleRecyclerView.<em>run </em><strong>{<br>    </strong>hasFocus()<br>    smoothScrollMapToPosition(2)<br>    setHasFixedSize(true)<br><strong>}</strong></pre><p>Both really are pretty much the same, however, run has an advantage for handling nullability compared to with:</p><pre><em>// with<br>with</em>(sampleRecyclerView) <strong>{<br>    this</strong>?.<em>hasFocus</em>()<br>    <strong>this</strong>?.<em>smoothScrollMapToPosition</em>(2)<br>    <strong>this</strong>?.<em>setHasFixedSize</em>(true)<br><strong>}</strong></pre><pre>// <em>run</em><br>sampleRecyclerView?.<em>run </em><strong>{<br>    </strong>hasFocus()<br>    smoothScrollMapToPosition(2)<br>    setHasFixedSize(true)<br><strong>}</strong></pre><p>So in this case, run is way better as we could check for nullability before using it and it is way more pleasing in our eyes than having multiple this?..</p><h4>run and let</h4><p>Both are extension functions so they basically are pretty much the same but just for one thing, accepting arguments.</p><p>All scopes when using run can be referred as this, and most of the time it can be omitted. However, let is sending itself into the function, it’s like a lambda argument sent it, so all scopes within are referred as it.</p><pre>// <em>run</em><br>sampleRecyclerView.<em>run </em><strong>{<br>    </strong>hasFocus()<br>    smoothScrollMapToPosition(2)<br>    setHasFixedSize(true)<br><strong>}<br><br></strong>// <em>let</em><strong><br></strong>sampleRecyclerView.<em>let </em><strong>{<br>    it</strong>.<em>hasFocus</em>()<br>    <strong>it</strong>.<em>smoothScrollMapToPosition</em>(2)<br>    <strong>it</strong>.<em>setHasFixedSize</em>(true)<br><strong>}</strong></pre><p>So you’d think that run is better, but sometimes let can have some advantages too.</p><ul><li>when it is sent as a parameter, obviously it is shorter to write than this and it’s clearer.</li><li>let allows better naming, so you can rename it to your liking.</li></ul><pre>sampleRecyclerView.<em>let </em><strong>{ <br>    recyclerview</strong> <strong>-&gt;<br>        recyclerview</strong>.<em>hasFocus</em>()<br>        <strong>recyclerview</strong>.<em>smoothScrollMapToPosition</em>(2)<br>        <strong>recyclerview</strong>.<em>setHasFixedSize</em>(true)<br><strong>}</strong></pre><p>These are just some of the features that Kotlin offers. There are still a lot of what this programming language can do and address some of the shortcomings of Java.</p><h4>So should you learn Kotlin?</h4><p>A definite <strong>YES</strong>, even Google is making its bet on Kotlin and as I’ve said earlier, it officially supported the language as an Android development language. It’s safe to say that Kotlin is here for a big run.</p><p>So if you wanna learn more, their <a href="https://kotlinlang.org/docs/tutorials/">Kotlin tutorial</a> is a good start as it’s also the most reliable source to learn the language and you can also give it a <a href="http://try.kotlinlang.org/#">try</a> via your web browser.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a9a6e80de6d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why I switched to mobile app development]]></title>
            <link>https://medium.com/@karlomiguelpyu/why-i-switched-to-mobile-app-development-5c8e73216188?source=rss-c9d340064674------2</link>
            <guid isPermaLink="false">https://medium.com/p/5c8e73216188</guid>
            <dc:creator><![CDATA[Karlo Miguel]]></dc:creator>
            <pubDate>Wed, 03 Jan 2018 10:37:48 GMT</pubDate>
            <atom:updated>2018-01-07T21:15:30.940Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IVeaSNHdS7YbZGmo0pK2Wg.jpeg" /></figure><p>Since smartphones were introduce, it made quite a mark to people to become their dominant platform over the well-loved desktop computing machine. Currently, the markets are filled with these devices with different sizes, shapes and configurations. Although the web is not going to die out anytime soon but more and more people have devices in their pockets that can access the internet. So companies or brands now came to a realisation that they want to target people with this devices and it will just grow even further.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*glWyraLzcV2fTTqWS883rw.jpeg" /></figure><h3><strong>Mobile devices are rising in usage</strong></h3><p>As a web developer before, I always put into consideration a responsive web design for the smaller screens. After all it is a must and a great solution. Yet, I was having a feeling I was missing out on something very valuable.</p><p>Switching or should I say adding mobile app development to my skillset seems a little bit daunting. After spending years learning and harnessing my craft it kinda sucks to go back from the start and struggle over something again. (<a href="https://medium.com/@karlomiguelpyu/why-learning-new-programming-languages-is-good-for-you-f4e9adbc00fc"><em>Here</em></a>, I talk about why it is also good to learn new programming languages)</p><p>To tell you honestly, the only reason for me at first why I started learning it because my previous company asked me if I am willing to. Of course I said yes! But little did I know that later on in my life I’ll make the leap, not because they told me so but I came to learn to love the platform.</p><h3><strong>Use of Existing Web Development Skills</strong></h3><p>Mobile app development utilises the core basics of programming and some of the web technologies that are key in web domain. Which means you do not need to learn a lot of things in order to get started with mobile app development.</p><p>Although using this approach has some limitations compared to the native approach, it will be certainly make the transition easier. It is also an attractive option for developers who have great knowledge or experience with web development, but not with mobile.</p><h3><strong>Possibilities are endless with mobile apps</strong></h3><p>Mobile apps are becoming smarter since they are now becoming part of our daily lives. People are so integrated with their hand-held devices that we can come up with some very interesting, personalised features leveraging locations, speed &amp; duration, etc. of the user.</p><h3><strong>Sell your apps</strong></h3><p>You can go ahead and just sell your apps. Submitting what you have made to the App Store allows for discoverability and in the process, earn money.</p><p>In overall, I still continue in getting up to date with web technologies but learning mobile development comes with a lot of benefits and you should surely not miss on them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5c8e73216188" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why learning new programming languages is good for you?]]></title>
            <link>https://medium.com/@karlomiguelpyu/why-learning-new-programming-languages-is-good-for-you-f4e9adbc00fc?source=rss-c9d340064674------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4e9adbc00fc</guid>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Karlo Miguel]]></dc:creator>
            <pubDate>Tue, 12 Dec 2017 14:06:27 GMT</pubDate>
            <atom:updated>2017-12-12T14:31:48.456Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2bLFtUYzWWz6EE8TgJ6P-Q.jpeg" /></figure><p><em>“Why should I start learning a new programming language?”</em> is the question we always ask ourselves because nowadays we are too busy in trying to learn new things.</p><p>Being a software developer, I didn’t really give it a thought of needing to constantly learn new programming languages because I was already comfortable with what I know. So instead, I just focus at it to become more efficient, effective and productive. And also with that reason I didn’t want to struggle from learning the basics again and again. Why fix something if it ain’t broken, right? But later on in my life I came to realise that my decision was <strong>wrong</strong><em>, at least for me.</em></p><p>My journey from being a web developer to being an android developer with the use of different programming languages for each platform taught me to think in different ways outside of the normal thinking pattern that I have. The new perspective can really teach you new ways to address problems and also an outdated technology is often replaced with something new and a bit more modern.</p><blockquote>Don’t you love to challenge yourself in learning something new?</blockquote><h3><strong>We should really try to learn and adapt to new technology because it is not just the next new thing that we’ll be hearing or reading all over the internet.</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/1*IAG5q3tpFSaGRPj7hrw5Pw.jpeg" /></figure><p>I know <strong>it will be hard and long journey</strong>, believe me I’ve been there, but the thing is it will be <strong>worth it in the end</strong>, not just with your career path but for your soul as well. It can help you broaden your thinking and also avoid being stuck with something. Every programming language has its strengths, weaknesses and different techniques in tackling certain things which is valuable to know even if you only have a little or passing knowledge of it. As I’ve said, we <strong>learn <em>better</em> ways</strong> in doing things. It will be worthwhile to add new tools to your toolbox.</p><p>In this era, it is quite easy to learn new things with the help of the internet. Follow a good tutorial and build the sample application step by step or exactly as it is being described. Follow the conventions or standards of the language instead of going in your own way. <strong>Do not try to do the <em>same old way</em> of doing things that you already know</strong>. The point here is to learn something new and see how other people with the knowledge or experience of that language write and structure their code. You can also learn a few tips and tricks from the examples that you did not know about. Make sure you understand what you are doing and get the most out of it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4e9adbc00fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>