I recently finished an online course whose goal was to teach concepts in programming languages. As a Software Developer, I was already comfortable with most of the ideas, but the highlight of this course was that I could learn functional programming for the very first time. All with a language I didn't hear before: Standard ML (SML).

Programming Languages, Part A | Coursera

Why a course in SML?

If you never heard about SML (which I will call ML from now on) before, do not worry, you aren’t behind the trends! ML is a programming language mostly used in academy.

I didn't choose this course because of the language, but instead I chose it because it was teaching functional programming for people that have programming experience, but not necessarily knowledge on functional programming.

In this post I share some of the main language concepts that I have learned in the course, starting with the basics to more complex functional programming concepts.

Note: comments are surrounded by (* *)

Bindings

A binding is any sequence that will get type-checked and evaluated in ML.

As any other language, you can declare variables and functions:

val x = 4;

fun sum(x: int, y: int) = x + y

Let expression

The let expression allows you to define bindings in a local scope. You can declare local variables within a function:

fun double_plus_one(number: int) = 
    let val x = 1  
    in
        number * 2 + x
    end

Or define local functions within a function!

fun double_plus_one(number: int) = 
    let fun sum_one x = x + 1
    in 
      sum_one(number * 2)
    end

Options

option is a construct that can either have a value or not. An option in ML has only two states: NONE or SOME v, where v is a value.

In the example below, numbers_in_list returns NONE when the list is empty, and SOME when the list has numbers in it.

fun numbers_in_list(numbers: int list) = 
    case numbers of 
        []  => NONE          (* the list is empty *)
        | _ => SOME numbers  (* _ is a wildcard pattern *)

Recursion

Recursion is when a function calls itself but without causing an infinite loop, by stoping at some point and returning the solution.

fun sum_list(numbers : int list) =
  if null numbers
  then 0
  else hd numbers + sum_list(tl numbers) (* hd = head, tl = tail *)

What was mind-blowing for me was to learn that any for loop can be written using recursion. I didn’t write any for loops during this course, but instead I had to only use recursion, which required a shift on they way I usually work.

Any for loop can be written using recursion.

Pattern matching

Pattern matching is a mechanism from ML that checks a value against a pattern. Similar to switch/case in Java or when in Kotlin, but way more powerful.

We can rewrite the function sum_list we wrote in the previous section to use pattern matching:

fun sum_list(numbers : int list) =
  case numbers of 
    []  => 0                                  (* if list is empty *)
    | _ => hd numbers + sum_list(tl numbers)  (* any other match *)

We specify that we want to pattern match the list by writing case numbers of. Then we first match numbers to an empty list [] and do something (return 0 in this case). And finally for any other match, the “else” case, we'll take the first element from the list and sum the tail calling the function recursively.

In this example, we already declared the type of the parameter numbers as an int list, so the second pattern we matched was basically any int list that isn't empty.

We can leverage pattern matching by not explicitly declaring the type of the function parameter:

fun sum_list(numbers) =
  case numbers of 
    []  => 0                     
    | x::x' => x + sum_list(x')  

In this example, numbers' type is inferred to be an int list because we are adding with a sum operation. Then we match numbers to a second pattern: x::x' which means that if numbers is a construct that has an element as head (x) that can be concatenated (::) with the rest of the elements (x'), then do something: a list.

This is very powerful, as it extracts the head element into x and the rest of the list into x'.

Pattern matching looks cool but why using pattern matching if I can achieve the same with an if else statement?

Imagine you write the same function but with an if else statement:

fun sum_list(numbers : int list) =
  (hd numbers + sum_list(tl numbers))

and let's say you forget the case when the list is empty. Your program will still compile, but it will fail when the list is empty. The head of an empty list hd [] will throw an exception.

By using Pattern Matching, the compiler will let you know with a warning that you forgot to check all the cases. It's better to get a compiler warning that a runtime exception!

By using Pattern Matching, the compiler will let you know with a warning that you forgot to check all the cases.

Tail recursion

Tail recursion is the same as recursion because a function will call itself, but the difference is that when the recursion ends there is no extra computation to do.

Notice that in the previous example where we had a recursive call, we were doing x + sum_list(x') , meaning that once we get to the end of the list, we still have to go back and apply sum all the heads of the list (x).

We can rewrite the same function but using tail recursion. To do so, we can define a local helper function that will hold the total sum. This is so we have a way to accumulate the result plus a function that will call itself:

fun sum_list(numbers) = 
  let fun helper(list, result) =
    case list of 
      [] => result
      | x'::x'' =>  helper(x'', result + x') 
  in 
    helper(numbers, 0)  (* initial state *)
  end;

The compiler can optimise the call stack when there is tail recursion, therefore tail recursion is an effective recursive function.

Functions as arguments

Functions can be passed as arguments to other functions.

Let's say we already have a function implemented called double_function

fun double_plus_one (double_function, x) = 
   double_function(x) + 1

and now we need another function that will add 1 to the double of a number. We can create the function double_plus_one that expects you to pass a a function that doubles a number, and a number:

fun double_plus_one (double_function, x) = 
   double_function(x) + 1

fun double x = x * 2

double_plus_one (double_function, 3)

Combining functions

What if we already had the function double and another one that adds 1 to a number, couldn't we combine them instead of creating the previous function?

Yes! We can do it:

fun double x = x * 2
fun plus_one x = x + 1

fun double_plus_one x = plus_one o double x

where o indicates that you combine two functions.

Currying

Any function that can take multiple arguments can be called only with the first argument, and the output will be another function that takes the rest of arguments.

This technique is called currying, where a function takes an argument and returns another function that will take a second argument, and so on.

Like in this example, the function my_curry takes the arguments a and b:

fun my_curry a b  (* same as ((mycurry a) b) *)

val out_a = my_curry a
val out_b = out_a b

'out_b' is the same as 'my_curry a b'

Calling my_curry a outputs a new function that takes one parameter. The resulting function can now be called with b. And this is exactly the same as calling my_curry a b.

While learning Standard ML, I’ve found some similarities with languages I use nowadays like Kotlin or Dart, while other features are not supported by those languages, like currying.

And as well, there’s other things like creating Type classes, closures and fold, that were taught in the course but I didn’t cover here.

The course content was very well explained, though have in mind that only covers the surface of functional programming. Unfortunately, I found the assignments quite difficult, so this is something to keep in mind.

I hope that this article has inspired you to learn a new programming paradigm like functional programming. Happy learning!

Flutter Europe 2020 sketched

From desktop to convincing your stakeholders

Flutter Europe 2020 is the first edition of the biggest Flutter Conference. Two days, two tracks, 26 talks and 2 keynotes!

Here I present you the talks I attended and was able to sketch live in the conference. The videos aren't available yet, but once they are published, I will link them here.

Flutter for desktop — what is it good for?

Talk by Dominik Roszkowski.

Performance: Optimizing your Flutter app

Talk by Filip Hracek.

Flutter at work

Talk by Swav Kulinski.

Flutter at scale

Talk by Jorge Coca.

Navigator and Routes and Transitions… Oh, My!

Talk by Simon Lightfoot.

I'm personally very looking forward to Flutter Europe 2021 😉

Learn by reading, doing courses and watching videos

Everyone learns in different ways. Whether you prefer reading articles and documentation, watch videos, do courses or a mix, I have you covered!

Reading

Official documentation

The official documentation is pretty nice as it's well explained and contains lots of examples:

Flutter documentation

If you come from Android, iOS, React Native, web or Xamarin, in the Flutter docs you will find an explanation on how Flutter compares to the platform you already know: https://flutter.dev/docs/get-started/flutter-for/

Flutter Cookbook

The Flutter team created a cookbook where you will find many recipes that will teach how you can implement different mobile application components like navigation, persistence, animations, networking and more.

Cookbook

Blog Posts

You can find articles written by members of the Flutter team:

Flutter

as well as many articles written by developers from the community:

Flutter Community

Flutter Gallery

This is an application showcasing the power of Flutter. It also allows you to switch platform to iOS to see how the same application behaves if your mobile device ran iOS.

Find it on Google Play, or if you wish to take a look at the source code, here is the repository: https://github.com/flutter/flutter/tree/master/examples/flutter_gallery

Sample apps

If you want to learn looking at code, there's a list of sample applications linked in the Flutter repository:

flutter/samples

Practicing

Codelabs

If you like to learn by coding while following some tutorials, I recommend you the Google Codelabs. You will find a Dart Google Codelab and several Flutter Google Codelabs:

• Intro to Dart for Java Developers
• Codelabs

Udacity Flutter Course

Google and Udacity collaborated creating a course to learn how to build apps using Flutter:

Build Native Mobile Apps with Flutter | Udacity

Flutter Meetup Events

Meetup events focused on Flutter are appearing in many cities. Find one close to you!

Flutter Study Jam

If you want to learn together with a group of people, I suggest you to look for Flutter Study Jams. These are study groups organized by Google Developer Groups (GDG). Check if there are any GDG groups in your area, then check if they are planning to run a Flutter Study Jam and join them!

Watching

Flutter YouTube Channel

The Flutter team has an official YouTube channel where they post different content as talks given at conferences, tutorials and events:

From the video series they publish, the ones I like the most are:

1. Flutter in Focus. This video series are 5–10 minutes Flutter tutorials:

2. The Boring Flutter Development Show. In this show, two developers will code, get stuck and debug together different Flutter components while building apps. Playlist

3. Flutter Widget of the Week. Every week they present a Widget, explaining what it is for and how to use it. This is a cool way to learn new widgets every week: Playlist.

MTechViral

Flutter tutorials created by Pawan Kumar:

MTECHVIRAL

WhatsUpCoders

Flutter tutorials created by Kamal:

whatsupcoders

Those are the resources I like the most. I wish you a happy learning! 😃

Would you like to send me a question? Do it here https://ask.fm/asklariki

Resources to learn Flutter was originally published in Flutter Community on Medium, where people are continuing the conversation by highlighting and responding to this story.

Lara's Q&A — vol. 1

Questions about technology, Software Development and careers

Here I answer some of the interesting questions I received via https://ask.fm/AskLariki

Q: I just started learning Android. Should I learn Kotlin or Java?

I would focus first on the basics of Android, and learn Java or Kotlin on the go. Later on you can learn the best practices for each programming language. As an Android Developer, you'll probably use both Java and Kotlin, depending on the project you're working on, as you will probably have to maintain both at work.

Don’t worry, once you are able write in one programming language, the next programming languages will be easy to learn! 🙂

Q: People suggest me to learn JavaScript. I like learning Android with Kotlin and Java. Most of the job postings I see are for JavaScript positions. Should I learn JavaScript or Android?

If there's a lesson I learned is that you should focus on things you're passionate about. I learned Android because I loved it. I am learning Flutter because I enjoy it.

It's true it's more difficult to find entry level jobs for Android than other platforms. It also depends on the area you live, though. So keep in mind the local market, specially if you're starting. Participate in local communities to see how it is. That can also help you decide. I personally found the Berlin Android community awesome and that helped me.

Q: How to progress to tech lead?

I haven't done that. I have only seen people getting into that role. For me, a good tech lead is not someone that only has a great technical knowledge and can work cross teams taking important technical decisions. But someone who is good at working with people, at communicating with all roles and levels, and can help others grow.

It's difficult to find this kind of roles in the market, but it seems those roles appear naturally as the team grows. Be good at communication, organization and personal time management, and you will grow into the role.

Q: How do some of the famous twitter devs get time to write blog posts on all the latest tech?

I often ask myself the same. I can only answer from my own experience. The truth is that I dedicate part of my free time for creating blog posts, talks and learning. You can find time during the day in some ways. For example, when I work from home and don't commute, that saves me 1.5h that I can use for it. The support I get from my family is also crucial, otherwise it would be almost impossible.

Q: How to start contributing to open source?

The easiest way I found is fixing documentation, typos and examples. Reporting bugs is also very important, even better if you can create projects or tests that can reproduce the issue.

You can also create examples for existing libraries, to help others learn how to use it. For example the architecture samples for Flutter.

Q: What’s your preferred state management approach in Flutter?

I don't have a preferred one. All have their advantages and disadvantages. I'm right now using ScopedModel for a small project. Next I want to give a try to Provider, which I haven't used yet.

Q: What should I expect at my final onsite interview?

It depends on the hiring process. If you already had the technical interview, then at your final onsite you will probably talk with managers and spend some time getting to know the team.

The worst part already passed, just be nice and be yourself. At this stage you are very very close to get in. Take the opportunity to see if they are the right fit for you. They will be doing the same.

Q: How can I change my career into programming?

Long story short: I started learning programming a long time ago, but I was never focusing on it. I took my first step into tech by getting a job as Quality Assurance. During that time, I spent my evenings and weekends learning Android programming. By already being a QA, it made my switch to professional Android development less difficult.

I wrote some blog posts about my path that will give you more details:

• How I took my first step in tech
• A year of Android

Q: What are the topics an Android developer needs to know to work in cool tech companies like Blinkist?

If you want to work on a modern code base you "need" to know: RxJava, Dagger, architecture patterns like MVP and MVVM, Kotlin and testing. You don't have to be an expert on those, but you need to know how to explain concepts to your peers, like what they do or why you need those libraries.

Q: Can you be my mentor?

Sometimes I get this question. Unfortunately I cannot be your mentor, as I barely have time ☹️.

I suggest you to go to local meetups and study groups. Finding one peer is all it takes, so that you will be able to help each other! You have to be accountable for each other: if you say you will study every weekend, you need them to check you are doing that.

Thank you all for taking the time to send me questions 😊 If you have any question you would like to send me, you can do it directly here https://ask.fm/AskLariki or on Twitter at http://twitter.com/lariki 😃

From design to architecture and language features

Beyond Mobile: Material Design, Adaptable UIs, and Flutter

Talk by Will Larche and Anthony Robledo.

Building for iOS with Flutter

Talk by Andrew Brogdon and Brett Morgan.

Beyond Mobile: Building Flutter Apps for iOS, Android, Chrome OS, and Web

Talk by Emily Shack and Emily Fortuna.

Dart: Productive, Fast, Multi-Platform — Pick 3

Talk by Kevin Moore and Bob Nystrom.

Pragmatic State Management in Flutter

Talk by Filip Hracek and Matt Sullivan.

I researched if the Navigation Architecture Components could be integrated with our own navigation system at work. The navigation of this app was implemented via "pushing and popping" fragments.

One thing I could not find was how to deal with Master-Detail views and Navigation Components. A Master-Detail view is a view that contains a list of items on the side of the layout, and by tapping an item, the detail is shown next to it. These views are mostly used in big devices such as tablets, as they have more space to display more information.

In this article, I will show you how you can have Master-Detail views with Navigation Components, but without going into details on how Navigation Components work. For deep-dives on Navigation Components, I recommend you to take a course, or read these series of articles.

Sample App

The Sample Application that I will use to explain this, is basically a BottomNavigationView with three “master” screens: Feed, Messages and Profile.

When opening the Profile, the user can navigate deep into Account, Notifications and Settings, and navigate back to the Profile.

When we are using a tablet, we want to display the Profile master screen as seen below. The idea is to have the Profile Fragment screen on the left, and the detail screens on the right. This is what we call the Master-Detail views.

Creating The Navigation Graphs

The way we are going to solve this, is by having two navigation graphs.

The “main” navigation graph, covers the whole application navigation, for both phones and tablets, but with an exception, as we won’t be using the actions that take the user from the Profile to the details screens when using a tablet. More on that later.

The “profile” navigation graph contains only the three details screens. This graph is going to be used only on tablet, on the right side of the screen.

You may have an idea already of how are we going to solve this. On tablets, we are going to have a second NavHostFragment which is going to use the nav_graph_profile.xml. Let’s see now how to do that.

How To Handle Tablet Mode

A trick I love to use to easily know if we are on a tablet or a phone is to use a resource value that is going to change depending on the device configuration.

1. Create a bools.xml file in your values folder.
2. Create a variant of the same file, under values-sw600dp, which will be used by “big” devices.

On values we will have:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="isTablet">false</bool>
</resources>

On values-sw600dp:

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <bool name="isTablet">true</bool>
</resources>

Now let’s look on how to handle this on the ProfileFragment.

Loading A Different Layout On Tablet

In our onCreateView we will load a different layout depending on the type of device, we can do that with a snippet like this one:

val isTablet = context.resources.getBoolean(R.bool.isTablet)

when {
    isTablet -> {
        view = inflater.inflate(R.layout.fragment_profile_land, ...)
        displayMasterDetailLayout(view)
    }
    else -> {
        view = inflater.inflate(R.layout.fragment_profile, ...)
        displaySingleLayout(view)
    }
}

The fragment_profile.xml layout is very simple, and it only contains three buttons.

The profile fragment_profile_land.xml is a bit more complex:

On the left we have exactly the same layout as we had in the fragment_profile.xml, but on the right, there’s another Fragment with the id profile_nav_container, the NavHostFragment (which is previewed as the Account screen).

<fragment
        android:id="@+id/profile_nav_container"
        android:name="androidx.navigation.fragment.NavHostFragment"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:defaultNavHost="false"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toEndOf="@id/guideline"
        app:layout_constraintTop_toTopOf="parent"
        app:navGraph="@navigation/nav_graph_profile"/>

As you can see, the navGraph is the nav_graph_profile we defined before, and here is were the Master-Detail navigation will happen.

If we run the project like that, it will look correct both on phone and tablet, but the navigation wouldn’t work yet, because we have to implement it.

How To Navigate

You noticed before that I had two methods: displaySingleLayout and displayMasterDetailLayout. These methods take care of configuring the navigation on both cases.

Let’s see how:

On displaySingleLayout, I am just configuring the buttons I have to navigate to the corresponding detail screen. So for example, the account_textview is going to navigate to the Account Fragment using the action_profile_fragment_to_fragment_account Action.

With the displayMasterDetailLayout function is a bit more complicated.

The idea is to use the NavHostFragment we have on the right of the screen to perform navigation, instead of using the one contained in the MainActivity.

First, obtain the NavHostFragment by calling to the childFragmentManager.findFragmentById and then passing the id of the NavHostFragment.

Then, instead of using the createNavigateOnClickListener, we need to call to navigate manually using the NavHostFragment we just got.

WOW! 🤯

Summary

Handling tablet navigation can be daunting task, but if we apply the principles of the Navigation Component, we can create our own solutions easily. However, this may not be obvious when looking at the official documentation.

The way I solved this was by having two navigation graphs, and by having two different layouts for my ProfileFragment.

Having more than one navigation graph is completely OK, so don’t be afraid of doing that.

You can find all the code from this article here:

laramartin/android-navigation-master-detail

Update:

As Nicole Borrelli pointed out, we could place the layout for tablet in the resource folder layout-sw600dp and name our two layouts the same. Then, as we are trusting that the layout for tablet will be the one with the second NavHostFragment, we could reduce our code as:

val isTablet = context.resources.getBoolean(R.bool.isTablet)

view = inflater.inflate(R.layout.fragment_profile, ...)

if (isTablet) displayMasterDetailLayout(view) else displaySingleLayout(view)

Thank you, Nicole Borrelli!! 💚

Master-Detail views with Navigation Components was originally published in ProAndroidDev on Medium, where people are continuing the conversation by highlighting and responding to this story.

Growth for Juniors and Seniors

We often talk about the importance of hiring Juniors, a topic that pops up every now and then, but it is still undecided how to solve this problem, specially in smaller companies. I’m going to share with you my experience and the tips that helped me and other Juniors grow in a professional environment, but also, how that helps the rest of the team.

Problem

In the tech industry there’s a high demand nowadays for software developers, and this is widely known. Perhaps you are struggling finding developers to join your team, and you discussed many times with your manager who to hire. “What is the level we are looking for?” you might have asked.

Seniors, we only want Seniors.

Sadly, when it comes to hiring, companies prefer Seniors. This may be because Seniors already have the knowledge and the experience, and companies are always chasing after the market with their products, but even some big companies pride themselves saying they only hire Seniors! So even big names aren’t investing in Juniors.

“Where do Seniors come from?”

No one is being born a Senior. You all have been Juniors before.

It’s very difficult for Juniors to find their first job, as there are just a fewer job openings for that level. But companies forget that Juniors also bring lots of good things to your team.

Juniors bring good things

Juniors bring fresh motivation. They are really excited to have their first job and to work with you!! Their motivation is contagious 😊

Juniors bring a learning mindset. They are excited to learn. They are excited to learn with you and from you! You, Senior, might not have the motivation sometimes to learn something new. However, Juniors are continuously learning to improve. They’ll probably share what they’re doing with you, and this will motivate you.

Juniors bring fresh knowledge, as they have probably played with new components and libraries you didn’t have the chance to try out yet. And more importantly: every person is different. Everyone has different life experiences and backgrounds. Perhaps the Junior has some knowledge on AI, Biology, or data science!

Juniors bring a flexible mindset. Let’s be honest, when it comes to new technologies and libraries, Seniors may not be flexible sometimes. Perhaps because they want to keep a stable product, but…sometimes because they just don’t have the energy or motivation to learn something new.

What Seniors gain

At this point you have seen that Juniors will benefit your team, but you might be thinking…

“What do I, the Senior, gain from it?”

You will demonstrate your company that you can lead.

Most importantly, this will help your career growth. As part of your Senior role, you are expected to be able to mentor people.

Are you ready to mentor Juniors? I will give you some tips on making your mentoring more effective. But first, let’s see what mentoring is.

Mentoring

Mentoring is not a teacher-student relationship. Mentoring works both ways. The key of mentoring is sharing your knowledge.

How can I share my knowledge if I don’t act as a teacher? Well, you can share your knowledge in many ways!

You are sharing your knowledge…

• when you give constructive answers in code reviews
• when you share an article or a talk
• when you explain why you’re using certain library in your project because that another one didn’t fit
• when you talk about how certain approach or new library you think could benefit your product

Make your mentoring more effective

There are many things that helped me growing as a Junior developer. Though, believe it or not, all the things I will mention here, apply to any level.

Focus on one topic

Choose one single topic to explain in a session. If you are working on something complex, choose only one topic to explain. Let’s say you want to focus the learning session on the architecture pattern your app follows. Whenever another topic comes up, like Dependency Injection or Reactive Programming, you can let the Junior copy an example or guide them step by step, without going into details.

This way you will introduce concepts slowly and without overwhelming.

Communication

This is probably the hardest skill to master for Software developers. Think of “effective communication”. How can you explain a complex concept to a Junior?

Have pen and paper always available. Write and draw while making complex explanations. This won’t only help the Junior, but anyone else listening to you. Besides, if you draw diagrams on a paper, Juniors will have it as reference for the next time they need it. :)

When communicating, always be constructive. Be constructive when writing code reviews. Never say directly “Why did you do this?”. Instead, you can say “As I understand, you used this because of this reason. However, have you considered using this other approach instead?”.

Be constructive!

Environment

Be sure you have a good environment, with good mood and without sexism. If Seniors ask questions without attacking each other, Juniors will do the same!

Tasks

With time, you will see the Junior’s capacity. Don’t give them always the same kind of tasks. Instead, give them diverse tasks so they see different parts of the project. From end to end, from API to UI. Always challenge their capacity!

Also, don’t give them difficult tasks to do nor review. You don’t want to overwhelm them. In little time you will start understanding what they can do and you will feel more comfortable suggesting them tasks to do.

Pair Programming

Not everyone nor every company understands how good and effective pair programming is. Pair programming is NOT “you code what I say”. Pair programming is a conversation around a problem.

To help the Junior feel more comfortable doing pair programming with you, do it in their space. Let them take over the keyboard. They will feel more comfortable being in their space. Sit next to them.

Be patient.

Tips for Juniors

Starting a task

When the Sprint starts, we get excited to start working on tasks. But when you read again the acceptance criteria, you might thinking “I have no idea on how to start this task!”.

A little tip: ask for guidance! A teammate can help you breaking down the task in small Todos and steps you can follow.

But what if you already have a rough idea of what to do? Ask for guidance too! But instead, this time you can write the list of Todos and steps, and then share it with your teammates. They can help you spot things you need to consider when not knowing the project.

Asking questions

Keep in mind that you have to ask questions and you have to bother your teammates. They won’t mind, they will get back to focus really quickly. The right time to ask a question is at any time.

I got stuck!

Welcome to the developers life! We all get stuck! Although, not everyone has the same capacity to move forward.

“Is it too soon to ask for help?” Something that helps a lot when getting stuck is to time-box it. Give yourself 1–3 hours of research before asking for help.

However, sometimes we just need to take a break. Take breaks! Getting stuck is normal, and sometimes what we need is to stop focusing on the problem and refresh our minds. Go for a walk, make a tea, have some laughs with a colleague, watch a cute video of a puppy. Once you get back to your problem, you will see it from another perspective. I’m sure you solved many problems before by taking a break! :)

Nice tips, but…I’m still stuck!

One thing I also recommend doing when debugging your code, is Rubber Duck Debugging. Have a rubber duck next to you (or any other toy) and start explaining to it what you wanted to achieve with your code and every step you’ve done. Many times you can spot the issue yourself when explain it. And you can do the human version too: the Human Duck Debugging :) Tell a colleague you are stuck with something and start explaining them the problem. Again. Many times you will spot the issue alone, and that’s good! Other times, your colleagues will ask you questions that will help you debugging.

Copy-Pasting

Copy-Pasting is OK! We all google problems, we all copy code from StackOverflow. Copy-pasting is OK as long as you understand the problem you have and the solution you are copying.

One type of copy-pasting I suggest you to do is copying code from your own project. Search within your project some examples of what you want to do. This will help you see the patterns they follow, so you keep the code consistent.

Final words

We all are aware on the problem of the lack of Juniors in our industry. Only a few see the benefits that Juniors can bring. Be one of those few!

Remember:

• You will learn a lot, the best way to master something is to teach it.
• You will have a rewarding experience by helping others grow and learn.

Being nice to your Juniors can help you in the future too. You never know when you will need their help!

As part of my self-learning goals at work, I am reading “Kotlin in Action” in detail. I want to share with you something I learned that blew my mind!

In Kotlin, when you define a class, you can declare the constructor with the keyword constructor (which you can also omit) followed by the arguments required to initialize that class within parenthesis. This constructor is the primary constructor of your class.

Let's say we want to create the class Gamer that requires a username to be passed as an argument in its constructor.

Then you can declare any properties you want in the body of your class. But not only that, you can also declare one or more init blocks that can contain code that is needed for the initialization of the class.

Following our example, in our class Gamer we declare the property val username : String first, then within the init block, we assign the value we get from the constructor to the property:

But there is a concise way to write the same code in only one line:

YES! You can declare the property within the constructor. It behaves the same, and generates the same Java code. When you add the keyword val in front of an argument in the constructor, Kotlin will generate the property for you and will assign the value passed to the class to the property when the class is initialized.

To verify that they are 100% equivalent, I decompiled them to Java, so we can compare the Java-equivalent source code. I will rename the 1 line class declaration to GamerConciseSyntax.

Here you can see how they look like in Java:

As you can see, the two code snippets look exactly the same. The Kotlin compiler is generating exactly the same bytecode for both, so there is no reason for you to not use the concise constructor syntax.

WOW! 🤯

Wow! Declaring classes in Kotlin was originally published in ProAndroidDev on Medium, where people are continuing the conversation by highlighting and responding to this story.

Unleash your creativity while actively listening to talks! Sketchnoting is the art of using visuals to record and share ideas. Come to learn about taking notes, and how to make beautiful sketches with the help of lettering techniques.

Taking notes in a visual way, while actively listening to talks, is an excellent way to remember the most important ideas and going back to them in the future. You can also use sketchnoting to share ideas at work or to organize your day.

You will learn sketchnoting techniques from us while making your first sketch! And as well, you will learn the basics of lettering, the art of writing beautiful captions. We will be also sketchnoting with you, sharing our process live!

Everyone can get started with sketchnoting, you only need pen and paper!

Join us at DACHFest! The workshop is free for all conference attendees, and the conference tickets are already on sale!

Sketchnoting & Lettering Workshop was originally published in DACHFest on Medium, where people are continuing the conversation by highlighting and responding to this story.

Two years ago I started my career in tech. I started as QA Tester and then transitioned into a developer role a year after. Not without a lot of effort and a lot of personal time invested.

You can find that part of the story in this post about how I switch careers from Biology to tech and how I learned Android for a year. Today I want to talk about how I started my first role as Android developer, how I switched companies and how my first year as Android Engineer has been overall.

My first role

My first role as Android developer started out just a year ago. The company I was working at provided me with the opportunity to transition from QA to Android developer by dedicating half of the time to each role.

This transition was thanks to the time I invested learning Android on evenings and weekends. I went through the Android Basics Nanodegree, the Android Developer Nanodegree and as well I got the Google Developers Certification. That part of the story is explained in more detail here.

After two months I switched to full time when they hired another QA. Here's were all the challenges began!

Transitioning someone into a developer role is a lot harder than just providing them with a laptop and a git account. And here I explain some of the roadblocks I got during that time:

Lack of expectations

The first problem I faced was not knowing the expectations that the company had on me. My thought was that they expected me to deliver since the very first day, probably not like my experienced colleagues, but deliver by doing small tasks. This feeling caused me a lot of pressure. By not having clear goals, I was constantly thinking I wasn't good enough and that I was an impostor.

Lack of mentorship

There was no concept of mentorship in the company and the environment didn’t allow us to work together. We barely did pair-programming, because there was always a deadline and the company wanted us to keep delivering. Luckily my colleagues were always willing to help! They sat with me to help me whenever I got stuck or asked for help.

Lack of feedback

I never got any feedback during that time. What was I doing well or bad? What could I improve? I didn't know since I didn’t have anyone whom to report.

Lack of learning culture

I think that in order to keep up to date we need to continue learning by reading blog posts, watching talks, attending conferences, trying new things, etc. The company didn’t offer learning hours during working time, which is unfortunately quite common as other devs told me. Without having learning time, I felt I wasn't entitled to spend even 10 minutes to read a blog post I found to be interesting and relevant for my job.

The problem was not only the lack of an explicit learning time allowance, but also that when I requested it, it got denied.

An example of that occurred when I finished my tasks for the sprint and we were already at the end of it, so I asked if I could spend the rest of the day learning Kotlin. This request got denied.

Another case was when I requested to attend an Android conference, and then I was asked to take days from my paid time off.

Impostor syndrome

The lack of expectations, the lack of feedback, and the lack of learning culture in the company made the first 9 months of my developer career even more challenging. I have the feeling that it contributed to increase my internal impostors syndrome.

One example of it was opening and reviewing pull requests. Sometimes I'd ask a colleague to check my code privately, rather than opening a pull request, to avoid showing my code to everyone.

Other times, when I was reviewing, I would spend minutes staring the "approve" button, worried of approving something that another colleague would have considered wrong.

And when I didn't agree on something, I was never speaking loud enough worried of a backslash due to my lack of knowledge.

Sometimes I’d ask a colleague to check my code privately […] to avoid showing my code to everyone.

New company, new challenges

Later on I got a new opportunity in my hands. I was invited to the hiring process for a Junior Android Engineer position at Babbel thanks to a friend who worked with me in the past.

I met the team while volunteering in a local meet-up that was hosted at their offices. That helped me a lot when deciding to apply. I loved the company's motto: learning for all. Also everyone was very friendly and looked happy working there! But I didn't apply straight away, because why would I apply if I though that I wasn't good enough?

Luckily my friend and my partner pushed me to do it. They gave me the strength I needed to send my CV. Shortly after I got into the interview process. It was fairly simple: I had to do a coding challenge in the form of a small app, and then later a technical interview with the team and team fit interview with the hiring manager.

Hiring process

I spent the weekend with the coding challenge and sent it right after on Monday. Soon after I got invited for an on-site interview.

The technical interview was about the coding challenge itself, we talked about good and bad things on Android, why did I implement things in a way, how could it be improved, etc. It followed a short team fit interview with the hiring manager, where we talked about challenges I faced, how I solved this problems, and so on.

They offered me the job and I accepted the offer!

On my first year working as Android developer, I spent 9 months in a company and the next 3 with my current employer.

Learning environment

One big change for me is having 1:1 meetings with my Engineering Manager every two weeks. That way, it's clear for me what are our expectations.

We are getting constant feedback and ideas on what to improve and how to help and be helped. Beside the internal trainings they offer, I also have a weekly learning time allowance to learn anything I want. So far, I've been using it to improve my Kotlin and RxJava knowledge.

We also do pair-programming almost daily. There's always paper and pens nearby my desk to sketch ideas. And I keep a second chair by my side so my colleagues can sit with me :-)

However, I still struggle with the impostor syndrome.

Still the Impostor syndrome

I still struggle with it. For example, when doing pair-programming, if we reach a topic I don't quite understand, even when my colleagues have the patience to explain it to me many times, there are times I just can't get it.

After the second or third time I start feeling a big pressure on my chest. How come I don't get it? Why is it so difficult for me to understand? This situation creates me anxiety.

I realized I need to accept that I might not understand a given topic but that getting the idea is the first step! Sometimes we just require more time and practice so it finally "compiles in our brains" :-)

For example, I used to struggle with Java interfaces vs. abstract classes, I just couldn't understand them completely, no matter how many examples I saw. But then I started using them, and even if I could not explain how they worked, I knew how and when to use them.

Confidence

The learning environment in my current company helps me in building confidence. Even if I've been asking a lot of questions, there's always room for more!

Having less experience doesn't mean your opinions will be less valued. For example if a proposed solution seems too complex, I will challenge them to write it in a clearer way. Also, I provide a different set of experience and points of view, which has been helpful so far for polishing the app user experience.

To improve

The engineer role isn't just coding, but rather a broad range of skills. I am still at the beginning of the journey, and on my way of mastering it, I want to focus on the following ideas:

• Communication: as English isn't my first language, sometimes I struggle to transmit an idea, which is essential for my job. I can work on that by writing, reading and talking more.
• Give constructive feedback: I want to give meaningful feedback to my colleagues so they can grow with me as well.
• Be proud of my achievements: I need to create a list to track all kind of achievements, small or big, and my overall progress, so I can look back and feel good when I struggle.
• Not being obsessed on what I don't know: hard to do when there's so many new things coming up, so keeping focused on the essentials, and what's required for my project in hand, is important.
• Share more knowledge with my colleagues! That I'm a junior doesn't mean I don't have anything to share! I need to keep sharing articles and talks I find interesting. I know my colleagues appreciate that.
• Be patient and constantly learn: keep learning as I am doing, but being more patient with myself.
• Self-care: take breaks whenever needed and don't be hard with myself. Relaxing is also productive.

I am very happy at my new job, and I want to keep learning, improving and sharing. I hope that my experience can help you achieve your goals.

A year as Android Engineer was originally published in ProAndroidDev on Medium, where people are continuing the conversation by highlighting and responding to this story.