Forem: Joshua de Guzman

Deploy Flutter Apps on Android to Testers Using Firebase App Distribution with Semaphore

Joshua de Guzman — Tue, 09 Nov 2021 06:30:43 +0000

Building features and beautiful UIs is a satisfying feeling, but shipping them to users should be the goal to keep in mind. Having your app tested by real users before public release is a critical part of the software development cycle. In this article, you will learn how to distribute your Flutter Apps (on Android) to your testers using Firebase App Distribution, and automate your deployments using Semaphore.

Originally published at Semaphore blog on November 3, 2021.

Automating Testing in Flutter 2.0

Joshua de Guzman — Fri, 30 Jul 2021 07:24:27 +0000

Hi everyone!

I've written an article on how you can automate your Flutter tests with SemaphoreCI. SemaphoreCI is a cloud-based CI/CD platform built for speed and performance — it works well with Flutter apps too!

Here’s an excerpt from the blog:

Building beautiful and functional apps in Flutter is easy, but how do we make sure that we deliver a great user experience at scale? We can do it by integrating and running automated tests for every new change pushed to our codebase.

Continue reading it on Semaphore Blog.

Keeping It Simple: Integrate GraphQL and MobX to your Flutter apps

Joshua de Guzman — Mon, 02 Nov 2020 15:21:45 +0000

Introduction

I stumbled upon the following questions and issues on the web when I was trying to do the same thing for my work---Integrate GraphQL and MobX in Flutter:

I found out... there are not many available resources that demonstrate how to request and send data back to the server, using GraphQL with MobX inside a Flutter app.

So I decided to write a tutorial on this topic with a slight touch of clean architecture. ✍️

Disclaimer

This is not an introduction to GraphQL or MobX. If you haven't heard or tried using either one of them, I suggest looking into ResoCoder's tutorial on MobX or reading my previous article regarding Flutter and GraphQL.

Project

Your goal is to create a simple Flutter app that retrieves a list of artists based on a search query sent to a Spotify GraphQL server.

Search Artists via Spotify API

You can download the final project here.

Overview

Overview of the project's structure

Setup the Flutter project

At the time of writing, I am using the Flutter SDK stable v1.17.5.

a. From your terminal, clone the repository:

https://github.com/joshuadeguzman/flutter-mobx-graphql-starter

b. In the pubspec.yaml, add the following dependencies

dependencies:
  ...

  mobx: ^1.2.1+1
  flutter_mobx: ^1.1.0+1
  graphql: ^3.0.0
  either_option: ^1.0.6

dev_dependencies:
  ...

  mobx_codegen: ^1.1.0+1
  build_runner: ^1.10.0

Few things to note 💡

mobx is the package the helps you write reactive applications following MobX's principles
mobx_codegen makes it super easy for you to use mobx and writing store files through annotations and code generation
either_option is a small library that allows you to have typed and safe error handling when invoking functions in your Dart code such as a network or API call

c. Retrieve dependencies of the project

flutter packages get

Setup GraphQL client

a. In the main.dart file, add the following to your _MyAppState class

class _MyAppState extends State<MyApp> {
    HttpLink _httpLink;
    GraphQLClient _client;

    @override
    void initState() {
        _httpLink = HttpLink(
            uri: 'https://spotify-graphql-server.herokuapp.com/graphql',
        );
        _client = GraphQLClient(
            cache: InMemoryCache(),
            link: _httpLink,
        );

        /// Add other initializations here
    }
}

b. Pass the GraphQLClient's instance to the data source class

class _MyAppState extends State<MyApp> {
    HttpLink _httpLink;
    GraphQLClient _client;

    /// Add the following
    ISpotifyApiDataSource _spotifyApiDataSource;
    ISpotifyApiRepository _spotifyApiRepository;

    @override
    void initState() {
        ...

        /// Pass the [GraphQLClient]'s instance
        _spotifyApiDataSource = SpotifyApiDataSource(_client);
        _spotifyApiRepository = SpotifyApiRepository(_spotifyApiDataSource);

        super.initState();
    }
}

c. Provide the _spotifyApiRepository to the ArtistsStore

Provider(
  create: (_) => ArtistsStore(_spotifyApiRepository),
),

In a real app, you shouldn't always be creating the instances of store classes at the top most part of the tree when providing it. Otherwise, they'll get exposed to other unrelated features of the app.

But for simplicitly, let's just leave it here. 🤷‍♂️

GraphQL Integration

GraphQL 101

In a typical setup of a GraphQL, you only have to connect your app to a single endpoint
GraphQLClient supports several caching mechanisms right out of the box
Placing the GraphQL client in the data source layer helps you separate the queries from the widget tree

Prepare the data source

GraphQL queries are placed in the data source layer of the app

a. In the file spotify_api_datasource.dart, create a query to retrieve the artists from the server

...
@override
Future<List<Artist>> getArtists(String name) async {
  try {
    const String query = r'''
      query getArtists($name: String!) {
          queryArtists(byName: $name) {
              name
              id
              image
              albums {
                id
                name
              }
          }
      }
    ''';

    ...
  }
}

This query variable is where you specify the data that you need to pass or retrieve data from the server.

Similarly, this is how you use the query in a GraphQL playground.

https://spotify-graphql-server.herokuapp.com/

b. Add the following QueryOptions, and assign the query variable to the gql

final response = await _client.query(
  QueryOptions(
    documentNode: gql(query),
    variables: {
      'name': name, /// Search input of the user
    },
  ),
);

gql turns your String query into a standard GraphQL AST (a.k.a. Abstract Syntax Tree). To put it simply, Stephen Schneider once mentioned that AST is just a fancy way of saying heavily nested objects from his video.

Prepare the repository

A single repository can retrieve data from one or multiple data sources, eg. local or remote

a. In the file spotify_api_repository.dart, call the getArtists from the data source

@override
Future<Either<Failure, List<Artist>>> getArtists(String name) async {
  try {
    /// Add the following
    final data = await dataSource.getArtists(name);
    return Right(data);
  } ... catch (e) {
    return Left(UnhandledFailure());
  }
}

In the getArtists function, you are trying to catch the Exceptions returned after you query the data source.

try {
  ...
} on OperationException catch (e) {
  /// Handle exceptions that you receive from the [GraphQLClient]
  return Left(OperationFailure(e.graphqlErrors.first.message));
} on NoResultsFoundException {
  return Left(NoResultsFoundFailure());
} on Exception {
  return Left(ServerFailure());
} catch (e) {
  return Left(UnhandledFailure());
}

This is where the package either_option comes in handy. Either is a result type that represents a value of one of the two possible types you assigned to it.

In this project, the function is returning either a:

type Failure, which is a custom class that swallows an Exception with a custom message
or a List<Artist> which is the result that you need to populate the artists' list

MobX Integration

Credits: https://pub.dev/packages/mobx

MobX in a nutshell

observables are the notifiers to your UI observing the changes in the values
actions are simply functions where you can to change the values of your observables
reactions are listeners where you handle the side-effects coming from your store---typically used when you need to process something outside the Observer widget

Prepare the store class

A store can call functions from one or more repositories

a. Add a function to retrieve artists from the repository and annotate it with @action

@action
searchArtists(String name) async {
  _artistsFuture = ObservableFuture(_repository.getArtists(name));

  final either = await _artistsFuture;

  artistsResult = either.fold(
    (left) {
      /// [Failure]s are handled here
      this.reset();
      errorMessage = left.message;
      return null;
    },
    (right) {
      /// Results are handled here,
      /// in this case it is of type [List<Artist>]
      return right;
    },
  );
}

b. Generate the store file

Run the following command to generate a store file

flutter pub run build_runner build

If you have encountered issues regarding conflicting files, just run

flutter pub run build_runner build --delete-conflicting-outputs

c. In the artists.screen.dart, call the function searchArtists

class _ArtistsScreenState extends State<ArtistsScreen> {
  ...

  @override
  void didChangeDependencies() {
    ...

    _store.searchArtists(_name);
  }
}

Observing values in the UI

Final step in integrating GraphQL and MobX is to observe changes in the UI

a. Load the artistsResult to the ArtistList widget

Observer(
  builder: (_) {
    switch (_store.state) {
      case StoreState.loading:
        ...
        break;

      /// Add the following widgets to display the artists
      default:
        return Expanded(
          child: SingleChildScrollView(
            child: Container(
              margin: const EdgeInsets.symmetric(horizontal: 20),
              child: ArtistsList(
                artists: _store.artistsResult ?? [],
              ),
            ),
          ),
        );
    }
  },
),

Few things to note 💡

Observer rebuilds itself whenever there are changes to the value/s it observes inside its build method
In this Observer, it rebuilds whenever _store.state or _store.artistsResult's value is changed
Introduce an Observer only to the widget that needs to rebuild whenever data changes

Unit testing

This article won't be complete without adding any unit tests!

One of the benefits of separating business logic from the UI is that you get to test a small chunk of the code that makes your whole app.

Here's a snippet from the store unit tests

test(
  "should SET the [artistsResult] when the repository returns the results",
  () {
    // Arrange
    final name = "Carpenters";
    final result = [
      Artist(name: "The Carpenters"),
      Artist(name: "Carpenters"),
    ];
    when(_repository.getArtists(name)).thenAnswer(
      (_) async => Right(result),
    );

    // Act
    _store.searchArtists(name);

    // Assert
    expect(_store.artistsResult, result);
    expect(_store.artistsResult.length, 2);
    expect(_store.artistsResult.first.name, result.first.name);
  },
);

And a snippet from the repository unit tests

test(
    "should RETURN [List<Artist>] when the data source returns the results from the server",
    () async {
  // Arrange
  final name = "Carpenters";
  final result = [
    Artist(name: "The Carpenters"),
    Artist(name: "Carpenters"),
  ];
  when(_dataSource.getArtists(name)).thenAnswer((_) async => result);

  // Act
  final response = await _repository.getArtists(name);

  // Assert
  expect(response, isA<Right<Failure, List<Artist>>>());
  expect(response.isLeft, false);
  expect(response.isRight, true);
});

You can view all the unit tests included in this project here.

Run the tests

flutter test

Conclusion

For brevity, I focused on the missing parts of the app that matter when integrating GraphQL and MobX to your Flutter apps. You can always read the comments I left on the source code for more details.

In contrast to the use of Mutation and Query widget builders in the widget tree using graphql_flutter, this project setup makes your app less dependent on using GraphQL's implementation.

If you are planning to include data sources from traditional SOAP or RESTful APIs in the future, you only have to implement it differently on the data sources layer and continue what you are currently doing with the other parts of your app.

Connecting to multiple remote data sources

That's it for now, see you on the next one!

References

This was originally posted on my blog. Say hi! 👋

Integrating GraphQL in Flutter using graphql_flutter

Joshua de Guzman — Mon, 02 Nov 2020 15:19:25 +0000

Introduction

Ever wonder how the big guys like Facebook, Twitter, Airbnb create robust frontend applications for their platforms? Well, one of the key ingredients in their success is the use of GraphQL.

But, what exactly is GraphQL?

GraphQL is a query language---surprisingly, that’s what the last two letters represent.

It’s a query language for your API. It enables the frontend app (a.k.a. client) to request the exact data they need from the server, whether for a specific page, component, or just whenever they need it.

Sample GraphQL query requesting for upcoming launch data

Technically speaking, it's just a specification---not an implementation. For you to be able to write and host GraphQL APIs, you need a server library that contains the implementation written for the platform of your choice---one of my favorites is the Apollo Server for NodeJS.

And for you to be able to consume these GraphQL APIs, you need to use one of the client-side implementations, such as the graphql_flutter.

You can find an exhaustive list of supported server and client libraries for GraphQL here.

Some benefits for frontend developers:

You only have to connect your app to a single endpoint
You don't necessarily have to deal with multiple API/endpoint chainings yourself
Multiple caching mechanisms supported right out of the box

Most of the tedious work is likely to be handled in the backend---but hey, they also get extra time to rest because you don't always have to ping them anymore whenever you need something changed ASAP.

Project

In this article, I will teach you how you can request or send data to a GraphQL API from a Flutter application.

Download the final project here.

Flutter application utilizing SpaceX GraphQL API

Setup the Flutter project

At the time of writing, I am using the Flutter SDK stable v1.17.5.

From your terminal, clone the repository:

https://github.com/joshuadeguzman/spacex-land-starter

In the pubspec.yaml, add the dependency graphql_flutter

dependencies:
  flutter:
    sdk: flutter

  cupertino_icons: ^0.1.3
  google_fonts: ^1.1.0
  intl: ^0.16.1
  cached_network_image: ^2.2.0+1
  graphql_flutter: ^3.0.0 # Add it here

Retrieve dependencies of the project

flutter packages get

Setup GraphQL client

In the main.dart file, add the following to your main() function

void main() {
  WidgetsFlutterBinding.ensureInitialized();

  final HttpLink link = HttpLink(
    uri: 'https://api.spacex.land/graphql/',
  );

  ValueNotifier<GraphQLClient> client = ValueNotifier(
    GraphQLClient(
      cache: InMemoryCache(),
      link: link,
    ),
  );

  runApp(MyApp(client: client));
}

As mentioned earlier, you only have to establish a connection to a single endpoint. In the project, you are only querying anonymously on this API---no authentication tokens or cookies are involved.

To finish the setup, you need to provide the GraphQL instance throughout the app by wrapping the MaterialApp with GraphQLProvider.

class MyApp extends StatelessWidget {
  final ValueNotifier<GraphQLClient> client;

  const MyApp({Key key, this.client}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    final textTheme = Theme.of(context).textTheme;

    return GraphQLProvider(
      client: client,
      child: CacheProvider(
        child: MaterialApp(
          ...
          home: HomeScreen(),
        ),
      ),
    );
  }
}

Let's get going and start querying the API.

Queries

In GraphQL, a query allows you to explicitly tell the API that you are only requesting data from the server. In a traditional RESTful API, this is equivalent to a GET method request.

Querying the launch history from the API

Fetching the data from the server

Your first goal is to retrieve the users from the server, and display it on a list.

a. In the users.page.dart, import the graphql_flutter dependency

import 'package:graphql_flutter/graphql_flutter.dart

b. Remove the Center widget and uncomment the Query widget

class _UsersPageState extends State<UsersPage> {
  @override
  Widget build(BuildContext context) {
    // Remove this widget
    return Center();

    // Uncomment the entire [Query] widget
    return Query(
       ...
    );
  }
}

c. Add the users query

class _UsersPageState extends State<UsersPage> {
  final String _query = """
    query users {
      users {
        id
        name
        rocket
        twitter
      }
    }
  """;

  @override
  Widget build(BuildContext context) {
    ...
  }
}

As you can imagine, this is the exact query you are using in the GraphQL playground to get all the users from the server.

https://api.spacex.land/graphql/

d. Next, add gql(_query) to the documentNode of QueryOptions

Query(
    options: QueryOptions(
      documentNode: gql(_query),
    ),
    builder: (
      QueryResult result, {
      VoidCallback refetch,
      FetchMore fetchMore,
    })
    ...
)

gql turns your String query into a standard GraphQL AST (a.k.a. Abstract Syntax Tree). To put it simply, Stephen Schneider once mentioned that AST is just a fancy way of saying heavily nested objects from his video.

e. Hit hot restart or press SHIFT + R in your terminal

Astronaut's landing page (pun intended)

Everything else is self-descriptive, but what is happening here?

After you finished querying the server, you parse the data using final List users = result.data["users"];
Next, you retrieve each user from the list using final user = users[index]; inside a ListView.builder
Lastly, you retrieve the data from the user, i.e. user['name'], and display it in a Text widget

For a more structured way on how to parse JSON objects, please read more about it here.

Optional: If for some reason you need to display the timestamp that indicates when the user was created, add timestamp in the String query.

final String _query = """
  query users {
    users {
      id
      name
      rocket
      twitter
      timestamp
    }
  }
""";

And add a widget to display the timestamp data, user['timestamp'], in the list.

Displaying timestamp in the list

Phew, that went easy.

I challenge you to do the same for the upcoming launches and launch history screens. I'll leave you with the queries I used for the final project.

Upcoming launches query

/// lib/screens/home/launch_upcoming.page.dart

class LaunchUpcomingPage extends StatelessWidget {
  final DateFormat _dateFormat = DateFormat("MMMM dd, yyyy");

  final String _query = """
    query launchUpcoming {
        launchesUpcoming(limit: 10) {
          mission_name
          launch_date_utc
          rocket {
            rocket_name
            rocket_type
          }
          links {
            flickr_images
          }
        }
      }
  """;
}

Launch history query

/// lib/screens/home/launch_history.page.dart

class LaunchHistoryPage extends StatelessWidget {
  final DateFormat _dateFormat = DateFormat("MMMM dd, yyyy");

  final String _query = """
    query launchHistory {
        launchesPast(limit: 10) {
          mission_name
          launch_date_utc
          rocket {
            rocket_name
            rocket_type
          }
          links {
            flickr_images
          }
        }
      }
  """;
}

You might have noticed the limit parameter in the query, this is just simply to tell the server that you only need the first 10 items in the database. I'll discuss GraphQL pagination on a separate article.

Mutations

A mutation is used when you want to modify a single or set of data on the server. You might have guessed it, using a mutation is the equivalent of using POST, PATCH, or PUT, DELETE methods in a traditional RESTful API.

Creating a new user

a. Inside the add_user.screen.dart, wrap the Form widget inside a Mutation widget

Simplest hack to wrap your Form inside a Mutation widget, this imports graphql_flutter as well

b. Add the following mutation to create a new user in the server

class _AddUserScreenState extends State<AddUserScreen> {
  ...

  String insertUser() {
    return """
      mutation insertUser(\$name: String!, \$rocket: String!, \$twitter: String!) {
        insert_users(objects: {
          name: \$name,
          rocket: \$rocket,
          twitter: \$twitter,
        }) {
          returning {
            id
            name
            twitter
            rocket
          }
        }
      }
    """;
  }

  ...
}

Notice how parameters are escaped in this query, these are examples of GraphQL variables.

c. Update the Mutation's options and builder respectively

Mutation(
  options: MutationOptions(
    /// Insert mutation here
    documentNode: gql(insertUser()),

    /// Tell the GraphQL client to fetch the data from
    /// the network only and don't cache it
    fetchPolicy: FetchPolicy.noCache,

    /// Whenever the [Form] closes, this tells the previous [route]
    /// whether it needs to rebuild itself or not
    onCompleted: (data) => Navigator.pop(context, data != null),
  ),
  builder: (
    RunMutation runMutation,
    QueryResult result,
  ) {
    ...
  }
)

d. Look for the FlatButton, and add the following to its onPressed callback

if (_formKey.currentState.validate()) {
  ...

  runMutation({
    'name': _nameController.text,
    'rocket': _rocketNameController.text,
    'twitter': _twitterController.text,
  });
}

With runMutation, you can tell the GraphQL client when exactly do you need to modify a data in the server. You can call this function within the scope of the Mutation builder.

In addition, this is where you pass the data to the variables from the insertUser() mutation.

e. Hit hot restart or press SHIFT + R in your terminal

Adding @jeffbezos with his heavy-lift orbital launch vehicle

Awesome!

Now, I'll challenge you again to add functionality to update the details of the users on the server.

Update user details query

class _UpdateUserScreenState extends State<UpdateUserScreen> {
/// lib/screens/update_user/update_user.screen.dart

  ...

  String _updateUser() {
    return """
    mutation updateUser(\$id: uuid!, \$name: String!, \$rocket: String!, \$twitter: String!) {
      update_users(_set: {name: \$name, rocket: \$rocket, twitter: \$twitter}, where: {id: {_eq: \$id}}) {
        returning {
          id
          name
          twitter
          rocket
        }
      }
    }
    """;
  }
}

Conclusion

GraphQL makes it easy for frontend developers to play around with the server-side data and just focus on building the features. I encourage you to watch the documentary on how Facebook engineers invented GraphQL to help solve their issues on building native apps for the platform.

Q: Is GraphQL going to replace traditional RESTful APIs? No. At least not in the near future. There are still some cases where RESTful API may be a better choice over GraphQL. And just like any other solutions in software development, there's no silver bullet that will solve every business' problems when it comes to serving APIs.

What's next?

I have shared with you one of the simplest ways on how you can request and send data back to the server using graphql_flutter. But you'll probably look for a better way of implementing this on your apps if scalability and maintainability are some of your major concerns.

For example, when working with large teams, you may need to have typesafe queries and mutations, auto-generated classes, tests and more. Well, I’ll show them to you in action next time. 👋

References

This was originally posted on my blog. Say hi! 👋

Flutter Firestore Series

Joshua de Guzman — Wed, 18 Mar 2020 06:30:01 +0000

Flutter 💙 + Firestore 🔥 = 🧡

Ever wonder how you can leverage the power of Cloud Firestore in your Flutter app? What you are about to read is a practical guide that is sure to help you do it.

What is Flutter?

Flutter is a UI toolkit that allows you to build beautifully designed and high performing applications for multiple platforms, with improved developer productivity.
Using a single codebase, you can deploy your apps to Android, iOS, web, and desktop.

What is Dart?

Dart is the programming language used in building Flutter apps. Dart supports object-oriented programming, class definitions, as well as garbage collection.
Knowing Java, C, or similar programming languages can come in handy if you’re just starting to learn Dart.

What is Firestore?

Cloud Firestore (a.k.a Firestore) is a flexible, and scalable database for mobile, web and server development. It keeps your data in-sync across multiple clients through realtime listeners and offers offline support for both mobile and web.

Show some 💙 for this series

Flutter Firestore Series

Part I — Firebase and Flutter Setup
Part II — CRUD operations
Part III — Firebase for Flutter Web (Coming soon!)
Part IV — Dealing with complex queries (Coming soon!)

Resources

For Flutter trainers and organizers, I have written this in a codelab format — please check it out!

If this helped you, please don’t forget to ⭐ the repo. Thank you!

flutter-examples

Let's connect!

Twitter @joshuamdeguzman
Github @joshuadeguzman

We are hiring Android Software Engineers!

Joshua de Guzman — Sat, 27 Jul 2019 05:32:16 +0000

Freelancer.com is hiring!

We're looking for Android Software Engineers that will help us develop new features on our Freelancer Android App (with over 1M downloads)!

Freelancer.com

Eleven-time Webby award-winning Freelancer.com is the world's largest freelancing and crowdsourcing marketplace. We connect millions of employers to freelancers across the globe, and every day thousands of jobs are described, bid on, negotiated, and managed through our site.
We think it is pretty cool that our dataset details a real life economy, where work is undertaken in every area you can think of. From design, writing, data entry and software development; through to sales, marketing, accounting and legal services - even NASA uses us!

Mobile is intrinsic to our global business, and has been subject to rapid growth. Our Android app alone has exceeded a million downloads and we have around 20,000 daily active users. But we have more work to do!

In this role, you will be responsible for building scalable mobile applications, and develop new features as we update the main site. And not only will you build software that scales, but you will have the chance to ship code on your first day, and get instant feedback from millions of users worldwide.

WHO YOU ARE

• Tertiary Degree in Computer Science / Engineering, or related discipline (MS or PhD a plus)
• A deep familiarity and understanding with Java, RxJava, GIT, JSON
• Experience with Android SDK
• Experience using the Android testing tools (Espresso, Mockito)
• Experience with libraries such as Retrofit, Okhttp, Dagger 2
• Experience with Coordinator layouts and layout performance enhancements
• Experience with different Android structure patterns such as MVP, MVC, MVVM
• Ability to work with old Android OS versions from KitKat (4.4)
• Ability to build well-optimised and scalable mobile applications
• Solid understanding of the full mobile development life cycle
• Experience building Android apps, with examples in Google Play or as APKs

WHAT YOU'LL GET

• A chance to develop new features on a platform that help change lives with over 35 million users globally!
• Fully stocked kitchen / pantry
• Free lunch EVERYDAY
• Play whenever you want with our in-house table tennis, PS4 consoles, billiards
• Gym membership discounts
• Work-life-balance experience with our various in-house physical activities: Yoga, Circuit training, Boxing
• ... and many more!

IF YOU ARE INTERESTED, PLEASE VISIT:

http://bit.ly/freelancer-android-apply-now

android #software #engineering #career

Developing Restful APIs with Python, Django and Django Rest Framework

Joshua de Guzman — Sun, 16 Jun 2019 11:46:19 +0000

Introduction

This article is a definitive guide for starters who want to develop projects with RESTful APIs using Python, Django and Django Rest Framework.

Django is a web framework written in Python
Python is an interpreted high-level programming language for general-purpose programming
API or Application Programming Interface is a set of rules and mechanisms by which one application or component interacts with the others
REST or Representational State Transfer is a software architecture

REST APIs

As described in a dissertion by Roy Fielding,

REST is an "architectural style' that basically exploits the existing technology and protocols of the web.

In simple definition, it is the data representation for a client in the format that is suitable for it.

Hence, RESTful + API is a commonly used terminology for the implementation of such architecture and constraints (eg. in web services).

Here is an example GET request from GitHub's API

$ curl https://api.github.com/users/joshuadeguzman

You will see an output similar to this

{
  "login": "joshuadeguzman",
  "id": 20706361,
  "node_id": "MDQ6VXNlcjIwNzA2MzYx",
  "avatar_url": "https://avatars1.githubusercontent.com/u/20706361?v=4",
  "gravatar_id": "",
  "url": "https://api.github.com/users/joshuadeguzman",
  "html_url": "https://github.com/joshuadeguzman",
  "followers_url": "https://api.github.com/users/joshuadeguzman/followers",
  "following_url": "https://api.github.com/users/joshuadeguzman/following{/other_user}",
  "gists_url": "https://api.github.com/users/joshuadeguzman/gists{/gist_id}",
  "starred_url": "https://api.github.com/users/joshuadeguzman/starred{/owner}{/repo}",
  "subscriptions_url": "https://api.github.com/users/joshuadeguzman/subscriptions",
  "organizations_url": "https://api.github.com/users/joshuadeguzman/orgs",
  "repos_url": "https://api.github.com/users/joshuadeguzman/repos",
  "events_url": "https://api.github.com/users/joshuadeguzman/events{/privacy}",
  "received_events_url": "https://api.github.com/users/joshuadeguzman/received_events",
  "type": "User",
  "site_admin": false,
  "name": "Joshua de Guzman",
  "company": "@freelancer",
  "blog": "https://joshuadeguzman.me",
  "location": "Manila, PH",
  "email": null,
  "hireable": true,
  "bio": "Android Engineer at @freelancer. Building tools for humans.",
  "public_repos": 75,
  "public_gists": 2,
  "followers": 38,
  "following": 10,
  "created_at": "2016-07-28T15:19:54Z",
  "updated_at": "2019-06-16T10:26:39Z"
}

Shown above is a data set in JSON format.

JSON or JavaScript Object Notation is an open-standard file format that uses human-readable text to transmit data objects consisting of attribute–value pairs and array data types.

Other formats include XML, INI, CSV, etc. But today, JSON is widely use for its structure is intuitive, making it comfortable to read and map domain objects no matter what programming language is being used.

Python and Django

Python, according to its creator, Guido van Rossum, is a

high-level programming language, and its core design philosophy is all about code readability and a syntax which allows programmers to express concepts in a few lines of code.

Python uses english like words representation (eg. for methods, reserve keywords and control flow) that makes it easier for any beginner to jump right into it. It also features dynamic type system meaning it verifies the type safety of program at runtime. It also does automatic memory management.

print(5 + 5) # This will result to 10

Django is a high-level Python Web Framework that enables developers to deliver projects on time with clean and pragmatic design.

Its flagship features include a design for fast development, a secure and scalable product.

Quick Django Overview

Django's way of propagating changes to your database schema is by means of its migration modules.

Sample User model

from django.db import models

class User(models.Model):
    first_name = models.CharField(max_length=50)
    middle_name = models.CharField(max_length=50)
    last_name = models.CharField(max_length=50)

    def __str__(self):
        return self.name

If any changes are made on your models, run makemigrations

$ python manage.py makemigrations

Finally, you can synchronize the database with the set of models and migrations

$ python manage.py migrate

REST APIs with Django Rest Framework

DRF or Django REST Framework is a powerful and flexible toolkit for building Web APIs. It helps the developers to not reinvent the wheel by rolling out complex and solid REST API from scratch by themselves. Because when your projects become more and more complex, you will soon realise the need of using DRF or other helpful rest framework.

1. Installation & Project Setup

Create project directory

$ mkdir djangoapi

Install virtualenv via pip

A virtual environment enables a project to have additional libraries or changes in packages within its environment without disturbing global or libraries of other environments.

pip is a package management system used to install and manage software packages written in Python.

$ pip install virtualenv

To create an environment folder in your project's directory

$ cd djangoapi
$ virtualenv venv

To activate the environment

$ source venv/bin/activate

To undo these changes to your path, simply run deactivate. More on virtualenv.

Install django, djangorestframework

$ pip install django
$ pip install djangorestframework

Creating a django project

$ django-admin startproject blog

Running your project

$ python manage.py runserver

System check identified no issues (0 silenced).

You have 15 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

August 16, 2018 - 09:58:36
Django version 2.1, using settings 'blog.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

The unapplied migrations refer to the default migration files included when you start a django project.

To synchronize these migration files, simply run migrate

$ python manage.py migrate

Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying sessions.0001_initial... OK

The default database in our project is currently set to SQLite named db.sqlite3.

Creating a django project's app

$ cd blog
$ python manage.py startapp posts

The project structure should look like

$ find .
./posts
./posts/migrations
./posts/migrations/__init__.py
./posts/models.py
./posts/__init__.py
./posts/apps.py
./posts/admin.py
./posts/tests.py
./posts/views.py
./db.sqlite3
./blog
./blog/__init__.py
./blog/__pycache__
./blog/__pycache__/settings.cpython-36.pyc
./blog/__pycache__/wsgi.cpython-36.pyc
./blog/__pycache__/__init__.cpython-36.pyc
./blog/__pycache__/urls.cpython-36.pyc
./blog/settings.py
./blog/urls.py
./blog/wsgi.py
./manage.py

2. Model

Each model instance is a definitive source of the information about your data. In general, each model pertains to a single table in your database.

# djangoapi/blog/posts/models.py
from django.db import models

# Create your models here.

class Post(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    is_featured = models.BooleanField(default=False)

    def __str__(self):
        return self.name

__str__ is called by the str() built-in function and by the print statement to compute the "informal" string representation of an object.

If you try running makemigrations, django won't see those changes yet.

$ No changes detected

To solve this, add your posts app to your project's installed apps.

# djangoapi/blog/blog/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'posts' # Add it here
]

To continue with the migration of models

$ python manage.py makemigrations

Migrations for 'posts':
  posts/migrations/0001_initial.py
    - Create model Post

$ python manage.py migrate

Operations to perform:
  Apply all migrations: admin, auth, contenttypes, posts, sessions
Running migrations:
  Applying posts.0001_initial... OK

3. Serialization

Serializers allow data structure or object state to be translated into a format that can be stored or transmitted and be reconstructed later on.

Create API's serializers.py and views.py files and isolate them like this

# posts/api
posts/api/serializers.py
posts/api/views.py

# posts/migrations
posts/migrations/

# posts
posts/admin.py
posts/apps.py
posts/models.py
posts/tests.py
posts/views.py

# posts/api/serializers.py

from ..models import Post
from rest_framework import serializers

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = ('title', 'content', 'is_featured') # if not declared, all fields of the model will be shown

In this tutorial we have used ModelSerializer, more on this.

4. Views

A view function, or view for short, is a Python function that takes a Web request and returns a Web response.

# posts/api/views.py

from ..models import Post
from . import serializers
from rest_framework import generics, status
from rest_framework.response import Response

class PostListView(generics.ListAPIView):
    queryset = Post.objects.all()
    serializer_class = serializers.PostSerializer

As seen above, ListAPIView is used for read-only endpoints to represent a collection of model instances.

In this code snippet, we use generics view methods from the rest_framework, more on this.

5. URLs

This is where we setup our routes or URL paths to our designated views in which we expect specific responses for each.

# posts/urls.py

from django.urls import path
from . import views
from .api import views

urlpatterns = [
    path('', views.PostListView.as_view(), name=None)
]

6. Finalizing Setup

Ensure that the rest_framework is added to our project's apps.

# djangoapi/blog/blog/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework', # Add it here
    'posts'
]

7. Django Admin

Since we haven't setup our POST requests yet, we will be populating the database through django's admin panel.

To do that, create a superuser account admin with password 1234password.

$ python manage.py createsuperuser --email admin@example.com --username admin

Password:
Password (again):
This password is too common.
Bypass password validation and create user anyway? [y/N]: y
Superuser created successfully.

# posts/admin.py

from django.contrib import admin
from .models import Post

# Register your models here.
admin.site.register(Post)

That's it. Visit the admin panel and update posts model's records. More on this.

8. Testing our API

$ python manage.py runserver

GET /api/v1/posts/

HTTP 200 OK
Allow: GET, HEAD, OPTIONS
Content-Type: application/json
Vary: Accept

[
    {
        "title": "Example Post #1",
        "content": "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
        "is_featured": false
    },
    {
        "title": "Example Post #2",
        "content": "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
        "is_featured": true
    }
]

Great. Now it's time for us to update our views and finish the standard CRUD operations.

9. Adding more views

POST is a method used for creating (sometimes updating) a resource in the database.

# posts/api/views.py

from ..models import Post
from . import serializers
from rest_framework import generics, status
from rest_framework.response import Response

class PostCreateView(generics.CreateAPIView):
    queryset = Post.objects.all()
    serializer_class = serializers.PostSerializer

    def create(self, request, *args, **kwargs):
        super(PostCreateView, self).create(request, args, kwargs)
        response = {"status_code": status.HTTP_200_OK,
                    "message": "Successfully created",
                    "result": request.data}
        return Response(response)

Most often, we separate List and Create view classes when we want to expose a list of data set while easily preventing a certain request to POST or create a resource in the database for that specific List view.

Usecase always varies for apps, you are opt to use ListCreateAPIView or even ViewSets for combining the logic for a set of related views.

Optional: Since we want to display the data in a more systematic way, we override create method and map our inline custom response handler.

Adding more views with methods GET, PATCH, DELETE to handle a specific blog post detail.

class PostDetailView(generics.RetrieveUpdateDestroyAPIView):
    queryset = Post.objects.all()
    serializer_class = serializers.PostSerializer

    def retrieve(self, request, *args, **kwargs):
        super(PostDetailView, self).retrieve(request, args, kwargs)
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        data = serializer.data
        response = {"status_code": status.HTTP_200_OK,
                    "message": "Successfully retrieved",
                    "result": data}
        return Response(response)

    def patch(self, request, *args, **kwargs):
        super(PostDetailView, self).patch(request, args, kwargs)
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        data = serializer.data
        response = {"status_code": status.HTTP_200_OK,
                    "message": "Successfully updated",
                    "result": data}
        return Response(response)

    def delete(self, request, *args, **kwargs):
        super(PostDetailView, self).delete(request, args, kwargs)
        response = {"status_code": status.HTTP_200_OK,
                    "message": "Successfully deleted"}
        return Response(response)

10. Updating URLs

# posts/urls.py

from django.urls import path
from . import views
from .api import views

urlpatterns = [
    path('', views.PostListView.as_view(), name=None),
    path('create/', views.PostCreateView.as_view(), name=None),
    path('<int:pk>/', views.PostDetailView.as_view(), name=None)
]

Now you can send requests to your API via Postman, your app or do a GET requests from your browser, examples:

POST /api/v1/posts/create/

HTTP 200 OK
Allow: POST, OPTIONS
Content-Type: application/json
Vary: Accept

{
    "status_code": 200,
    "message": "Successfully created",
    "result": {
        "csrfmiddlewaretoken": "rnSUN3XOIghnXA0yKghnQgxg0do39xhorYene5ALw3gWGThK5MjG6YjL8VUb7v2h",
        "title": "Creating a resource",
        "content": "Howdy mate!"
    }
}

GET /api/v1/posts/1/

HTTP 200 OK
Allow: GET, PUT, PATCH, DELETE, HEAD, OPTIONS
Content-Type: application/json
Vary: Accept

{
    "status_code": 200,
    "message": "Successfully retrieved",
    "result": {
        "title": "Sample Post",
        "content": "Sample Post Content",
        "is_featured": false
    }
}

That's it. You have successfully managed to develop RESTful APIs with DRF! Cheers!

Source code

Available on GitHub.

Bonus

I'll cover another article covering Testable RESTful API with RESTful Authentication using JSON Web Tokens and include a link on here soon, stay tuned!

For inquiries or suggestions, feel free to comment or contact me.

Speed Up Your Android Project's Gradle Builds!

Joshua de Guzman — Mon, 10 Jun 2019 10:21:42 +0000

Introduction

Slower project build times may result in lower productivity. Lower productivity is lost money for the business. In this article, I provided a list of configurations, and tips you can implement for speeding up your Android project's Gradle builds.

DISCLAIMER: Some of the tips will include estimations, these estimations may not exactly match your project's build time improvement. Several factors affect the estimations -- including, but not limited to, your project's architecture, number of tests written, lint checks, current gradle configuration, your computer's hardware specifications, and the list goes on.

With that said, I hope this list will improve your overall team's productivity when building awesome apps!

Improving Your Project Build Time

1. Profile, profile, profile!

Profile your build, numbers don't lie. As we may have different project architecture, tests, and way of writing code, it's best that you always profile your own build -- preferrably on each optimization configuration change you make. You can pass on --profile directly on the command-line when invoking Gradle task.

For example, ./gradlew assembleDebug --profile.

Or, you can add it on the command-line options under Preferences when running the project on Android Studio.

This is a sample report after running the task with --profile.

2. Always use the latest Gradle Plugin for Android

Gradle team release newer versions of Gradle with faster compilation and build times. At the time of writing, the latest release currently available is Gradle 5.4.1.

Note, newer version changes may introduce unwanted compilation errors or compatibility issues, make sure to check out and follow the migration guide when upgrading your Gradle.

Image from https://gradle.org/whats-new/gradle-5/

Estimates that this will reduce 20-25% of your build time.

3. Avoid Legacy Multidex

A brief introduction on multidex

Android build architecture has a limitation of 65,536 method references, a.k.a. the 64K limit, once a single Dalvik Executable or DEX file reached the limit, you will encounter a build error. Multidex was introduced to help you avoid the 64K limit.

To support multidex, just add and set multiDexEnabled to true.

android {
    defaultConfig {
        ...
        minSdkVersion 21
        targetSdkVersion 28
        multiDexEnabled true
    }
}

If your minSdkVersion is set to 20 or lower, then you must add the support library.

android {
    defaultConfig {
        ...
        minSdkVersion 15
        targetSdkVersion 28
        multiDexEnabled true
    }

    dependencies {
        implementation 'com.android.support:multidex:1.0.3'
    }
}

However, this project setup will make your builds run with legacy multidex.

Legacy Multidex

Legacy multidex happens when you build your project with multidex enabled and minSdkVersion is set to 20 or lower. Clean and incremental builds are significantly slower on this.

The simplest way to solve this is by creating a build variant for development. With this, you can now run an isolated build variant on your test device without worrying about legacy multidex.

android {
    defaultConfig {...}
    buildTypes {...}
    sourceSets {...}
    productFlavors {
        // Create a separate build variant for development which has a minSdkVersion of 21
        dev {
            ...
            minSdkVersion 21
        }

        prod {...}
    }
}

Estimates that this will reduce 5-10% of your build time.

4. Disable lint checks on development

NOTE: IMHO, I only recommend this step for a team that have computers with lower specs and does not have a strict requirement on lint checks during development.

If lint checks, especially if your project is large, take up at least 30% of your time every build, think again. You may only want to run your lint checks when you are creating a diff, such as running a script with lint checks specified as one of the tasks to execute before diff creation.

Option 1. Disabling lint check on gradle.properties. Not recommended when you are running builds in your CI, as you may want to enable lint checks for your release builds.

gradle=build -x lint

Option 2. When using Android Studio to run your project, pass -x lint in your command-line options under Preferences.

Option 3. Pass -x lint via command-line when executing a Gradle task.

For example, ./gradlew assembleDebug -x lint.

5. Disable multi-APK generation

Google Play Store allows us to publish multiple APKs for specific device configuration. splits block allows us to configure the Multiple APK support.

This is a sample configuration for multi-APK support.

android {
    splits {
        density {
            enable true
            exclude 'ldpi', 'xxxhdpi'
            compatibleScreens 'small', 'xlarge'
        }
    }
}

However, we don't need to generate multiple APKs during development.

if (project.hasProperty('devBuild')) {
    // Prevent multi apk generation on development
    splits.abi.enable = false
    splits.density.enable = false
}

Gradle executes the project's build file against the Project instance to configure the project.

Note, you have to add -PdevBuild to your command to trigger the block with property check of the project instance.

For example, ./gradlew assembleDebug -PdevBuild.

Or, when you are using Android Studio to run your project, pass it in your command-line options under Preferences.

Estimates that this will reduce 5-10% of your build time.

6. Include minimal resources

Avoid compiling unnecessary resources that you aren't testing. Including, but not limited to, additional language localizations, and screen density resources.

For development, you can optimize your project build time by specifying one language resource or screen density.

android {
    productFlavors {
        dev {
            ...
            resConfigs ("en", "xxhdpi")
        }
    }
}

7. Disable PNG crunching

Android performs automatic image compression every time you build your app regardless whether it is a release or debug build type. It helps reduce the size of your app by optimizing the images for release builds, but it will slow down project build times when you are on development.

Update: It's available since Android Studio 3.0 Canary 5 release.

PNG crunching is enabled by default for the release build and disabled by default for the debug build type.

android {
    buildTypes {
        release {
            // Disables PNG crunching on RELEASE build type
            crunchPngs false // Enabled by default for RELEASE build type
        }
    }
}

For older versions of the plugin

android {
    aaptOptions {
        cruncherEnabled false
    }
}

8. Configure DexOptions wisely

Gradle provides you a DSL object for configuring dex options. One of the options that can be configured is preDexLibraries. You have the choice on whether you want your project to pre-dex libraries. Take note that this can improve incremental builds, but can slow down your clean builds.

If you wish to enable it, you can do this.

android {
    dexOptions {
        preDexLibraries true
    }
}

Configure wisely based on your development workflow preference. You should disable when doing clean builds on your CI builds.

9. Use Crashlytics only when needed

Every build, Crashlytics always generate unique build ID. You can speed up your debug build by disabling the Crashlytics plugin.

android {
    buildTypes {
        debug {
            ext.enableCrashlytics = false
        }
    }
}

Next, disable the kit at runtime for debug builds when initializing it.

val crashlytics = Crashlytics.Builder()
                .core(CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
                .build()
Fabric.with(this, crashlytics)

But if you need to use Crashlytics on debug build, you can still improve your incremental builds by preventing it from updating app resources with its own unique build ID every build.

android {
    buildTypes {
        debug {
            ext.alwaysUpdateBuildId = false
        }
    }
}

10. Use static dependency versions

You must declare static or hard-coded version numbers for your dependencies in your build.gradle. You should avoid dynamic dependencies, represented by using plus sign (+), otherwise you might encounter unexpected version updates. Dynamic dependency declarations also slower your builds as it continue checking for updates online.

android {
    dependencies {
        // What you should not do
        // implementation "androidx.paging:paging-runtime:2.+"

        // What you should do
        implementation "androidx.paging:paging-runtime:2.1.0"
    }
}

11. Enable build caching

By default, build cache is not enabled. To use build cache, you can invoke it by passing --build-cache on the command-line when executing a Gradle task.

For example, ./gradlew assembleDebug --build-cache.

You can also configure build caching on your gradle.properties file.

org.gradle.caching=true // Add this line to enable build cache

Estimates that this will improve your full clean build by up to 3 times faster, and incremental builds by up to 10 times faster!

12. Configure the heap size for the JVM

Gradle daemon now starts with 512MB of heap instead of 1GB. By default, this configuration may work best for a smaller project. But if you have a large project, you should update the heap size by setting org.gradle.jvmargs property in your gradle.properties file.

Here is the default configuration.

org.gradle.jvmargs=-Xmx512m "-XX:MaxMetaspaceSize=256m"

If you want to update the heap size to 2GB for larger projects.

org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8

Bonus, you need to set the right file.encoding properties when the JVM executes the Gradle build (eg. Gradle Daemon boot up). In this example, we are setting it to UTF-8.

More on Gradle's default memory settings.

13. Modularize your project

Modularizing your project codebase allows the Gradle build system to compile only the modules you modify and cache those outputs for future builds.

Here's a quick overview of project modularization.

How the build system compiles your project based on module specific changes.

I recommend modularization not only because of module re-use, or for optimizing build times, but also because it is ready to support the latest Android's Dynamic Features and Instant App.

Here's an article by Joe Birch regarding Modularization of Android Applications.

This is a detailed article how modularization can improve your Android app's build time by Nikita Koslov.

14. Runners-up: Always-on daemon, parallel build execution, and configure on demand.

Gradle Daemon

By default Gradle Daemon is enabled, but if the current project you are managing disabled the daemon for the every build and it annoys you -- you might want to update the configuration by enabling it.

org.gradle.daemon=true

Parallel Build Execution

This configuration is effective only when your project is modularized. It will allow you to fully utilize the processing resources you have in your computer.

org.gradle.parallel=true

Configure On Demand

You will only benefit from this configuration if you have a multi-project builds that have decoupled projects -- take note, it's multi-project, not just a modularized project.

Let's make an example out of the Google I/O 2018 Android App.

Notice the project structure, it includes various projects such as mobile, and tv. Configure on demand will attempt to configure only the projects that are relevant for the requested tasks (eg. configure only mobile for the requested task).

NOTE: The configuration on demand feature is incubating so not every build is guaranteed to work correctly.

Conclusion

Keep your team updated with the latest Gradle releases, and lookout for the possible API deprecation. Always profile your build, and adjust the configurations accordingly based on the results you get.

With these tips, I hope you will significantly improve your team's productivity and help each other make great apps again!

If you have questions or suggestions, feel free to comment below or ask me on my twitter @devjdg.

Happy coding!

Getting In-Depth With Kotlin Strings

Joshua de Guzman — Sat, 08 Jun 2019 13:01:10 +0000

Introduction

A string is a basic data type in a programming language. Strings are represented by the type String. Strings are immutable. Kotlin Strings are more or less similar to Java Strings, however Kotlin has more APIs for working with strings.

This article will cover:

Introduction
- This article will cover:
String Basic Usage
- Declaration
- String Concatenation
- String with Multiple Lines
Accessing Characters of a String
- Index Access
- Iterate through a String
Immutability of a String
- Re-assigning String values
String Properties
- Determining length of a String
String Functions
- compareTo
- equals
- get
- toString
Contribution

String Basic Usage

Declaration

// Explicit type declaration
var firstName : String = "Elon"

// or Implicit type declaration and will still compile
val lastName = "Musk"

In addition, notice the usage of val variable type, here is how it behaves

firstName = "Mark" // can be changed
lastName = "Zuckerberg" // cannot be changed
lastName = 12 // Error: type mismatch

val keyword indicates that the variable is read-only. Read Kotlin Variables.

Kotlin has a null-safety type system, before you even compile your application, it is already giving out indications of possible nullable values.

For a String, here is how it can be done

var firstName: String? = "Joshua"
var lastName: String = "de Guzman"

firstName = null // will compile
lastName = null // will not compile

Notice the firstName's type? It has an explicit type of String?, therefore it indicates that the variable is optional and can either contain a String object or a null value. Read Kotlin Nullability.

String Concatenation

Shown in the code snippet, just like Java, appending Int to
String will result to a String output

// Declaration
var str = "abc" + 1
println(str + "def")

// Output
$ abc1def

Even without explicitly converting Int value 1 to String object first, the resulting output is still a String.

In Kotlin, you can also concatenate using StringBuilder

// Declaration
val a = "Hello"
val b = "World"

val sb = StringBuilder()
sb.append(a).append(b)
val str = sb.toString()

println(str)

// Output
$ HelloWorld

You can also use Kotlin String Templates, which will be futher discussed below

// Declaration
val a = "Hello"
val b = "World"
val str = "$a $b"

println(str)

// Output
$ Hello World

String with Multiple Lines

Programmers can declare String variables with multiple lines by using triple quotes instead of double quotes

// Declaration
var str = """
        This is line 1
        This is line 2
        This is line 3
        """
println(str)

// Output
$        This is line 1
$        This is line 2
$        This is line 3

or with .trimIndent()

The use of trimIndent() will additionally help to provide a clean output format by removing excess and unnecessary indentions on each line. Examine the code snippet below:

// Declaration
var str = """
        This is line 1
        This is line 2
        This is line 3
        """.trimIndent()
println(str)

// Output
$ This is line 1
$ This is line 2
$ This is line 3

Accessing Characters of a String

Index Access

Programmers can access elements (characters) of a string using index access operator:

// Declaration
var str = "Example"
println(str[0]) // first character of the string
println(str[str.length-1]) // last character of the string

// Output
$ E
$ e

You can also retrieve characters using extension functions

// Declaration
var str = "Example"
println(str.first()) // retrieves the first character in a string
println(str.last()) // retrieves the last character in a string

// Output
$ E 
$ e

It's just like accessing an element from an array, in Kotlin Strings you can also have some IndexOutOfBoundsException when character being accessed is out of range

// Declaration
var str = "Example"
println(str[9]) 

// Output
// Error: index out of bounds

You can also use String.get() in Kotlin, which is equivalent to Java's String.chartAt()

// Declaration
var str = "Example"
var char = str.get(6)
println(char)

// Output
$ e

Iterate through a String

Elements of a String are characters that can be accessed by the indexing operation: s[i]

// Declaration
var str = "Example"
for (c in str) {
    println(c)
}

// Output
$ E
$ x
$ a
$ m
$ p
$ l
$ e

Kotlin also allows you to use iterator's extension functions to a String, for example forEach

// Declaration
var str = "Hello"
str.forEach { c ->
    println(c)
}

// Output
$ H
$ e
$ l
$ l
$ o

Immutability of a String

Just like Java, you cannot change individual elements of a String

// Declaration
var str = "Example"
str[2] = "b" // Error

However you can use some operations such as replace(), if you wish to replace a specific character from a String

// Declaration
var str = "Example"
str = str.replace("m", "p")
println(str)

// Output
$ Exapple

Re-assigning String values

// Declaration
var str = "Example"
println(str)
str = "Example was changed"
println(str)

// Output
$ Example
$ Example was changed

String Properties

Determining length of a String

length returns the length of a character sequence

// Declaration
var str = "Example"
println(str.length)
println(str.length - 5) // with length() function returning Int, you can do arithmetic operations just like any other Integer value

// Output
$ 7
$ 2

String Functions

These are some of the common String functions available from the current Kotlin version

compareTo

Compares this object with the specified object for order. Returns zero if this object is equal to the specified other object, a negative number if it's less than other, or a positive number if it's greater than other

// Declaration
var str = "Example"
var str2 = "Example123"
var str3 = "Example12345"
println(str.compareTo(str2)) // str has fewer (3) characters than str2
println(str.compareTo(str3)) // str has fewer (5) characters than str3
println(str3.compareTo(str)) // str3 has more (5) characters than str
println(str.compareTo("Example")) // zero denotes that the String objects being compared are equal

// Output
$ -3
$ -5
$ 5
$ 0

equals

Indicates whether a String object is exactly equal to another String object

// Declaration
var str = "Example"
var str2 = "Example2"
println(str.equals("Example"))
println(str2.equals("Example"))

// Output
$ true
$ false

get

Returns the character at the specified index in this character sequence

// Declaration
var str = "Example"
println(str.get(3))

// Output
$ m

toString

Returns a string representation of the object

// Declaration
println(9.toString() + 10)
println(9 + 10)

// Output
$ "910"
$ 19

Contribution

Here is a simplified version of this article I wrote for freeCodeCamp.
This is the reference to my pull request for the article submission.

For inquiries or suggestions, feel free to comment or contact me.