To learn Kotlin for Android development and transition from Java, here is a detailed guide on how to approach the learning process:

1. Understand the Kotlin Ecosystem

Basic Language Features:

• Familiarize yourself with Kotlin's basic syntax and language features. Kotlin's official documentation is an excellent starting point.

• Learn about variables, data types, control flow, and functions.

Advanced Features:

• Dive into advanced topics such as extension functions, higher-order functions, and lambdas.

• Understand Kotlin's null safety features, which are a significant advantage over Java.

Kotlin's Standard Library:

• Explore the Kotlin standard library which provides utility functions that make everyday tasks more concise.

2. Setup Development Environment

IDE Support:

• Install Android Studio, which has first-class support for Kotlin.

• Use the built-in tools and plugins in Android Studio to convert Java code to Kotlin.

Build Tools:

• Configure your project to use Gradle with Kotlin DSL for build scripts if you wish to fully embrace Kotlin.

3. Java Interoperability

Interoperability Practice:

• Practice using Java and Kotlin code side by side to understand how they interoperate.

• Convert existing Java classes to Kotlin using Android Studio's built-in tools and understand how the Java interoperability works.

4. Kotlin for Android Specifics

Android KTX:

• Use Android KTX, a set of Kotlin extensions that are part of the Android Jetpack libraries. They make Android API calls more Kotlin idiomatic.

Architecture Components:

• Learn about Android's Architecture Components and how to use them with Kotlin for a robust and maintainable app structure.

5. Hands-On Practice

Convert Java Code to Kotlin:

• Start converting existing Java Android projects to Kotlin. Begin with small classes and gradually work up to more complex ones.

Kotlin-First Libraries:

• Utilize Kotlin-first libraries such as Coroutines for asynchronous operations, which are a powerful feature of Kotlin.

6. Understanding Coroutines

Asynchronous Programming:

• Understand Kotlin Coroutines for managing background tasks efficiently and handling asynchronous operations.

Coroutine Context and Dispatchers:

• Learn about the coroutine context, dispatchers, and how to write non-blocking code.

7. Mastering Functional Programming

Functional Concepts:

• Embrace Kotlin's functional programming concepts, including immutability and the use of stateless functions.

Collection Operations:

• Practice with Kotlin's powerful collection processing features like map, filter, and fold.

8. Project-Based Learning

Build Projects:

• Start building Android applications with Kotlin to apply what you've learned. Begin with simple projects and progressively build more complex applications.

Review and Refactor:

• Continuously review and refactor your code to apply best practices and improve your Kotlin proficiency.

9. Get Involved in the Community

Community Engagement:

• Engage with the Kotlin community. Participate in forums, attend meetups, and contribute to open-source projects.

Resources:

• Utilize online resources, such as tutorials, courses, and videos, which can provide structured learning paths and practical examples.

Kotlin Challenges:

• Solve Kotlin coding challenges on platforms like Exercism or LeetCode to sharpen your problem-solving skills in Kotlin.

10. Keep Up-to-Date

Stay Informed:

• Keep up with the latest changes in Kotlin by following the Kotlin blog, attending conferences, and watching talks from Kotlin experts.

Learning Kotlin involves understanding its syntax and features, applying them in Android app development, and embracing its functional and asynchronous programming paradigms. By following these steps and continuously practicing, you can effectively transition from Java to Kotlin in Android app development.

________

Mastering Kotlin for Android development requires a structured approach. Here's a comprehensive framework to guide your learning process:

Foundational Knowledge

1. Syntax and Basics

   • Understand Kotlin's syntax and basic constructs.

   • Learn about variables, basic types, control flow, and functions.

   • Work with nullability in Kotlin to avoid null pointer exceptions.

2. Object-Oriented Programming

   • Dive into classes, objects, inheritance, interfaces, and abstraction.

   • Explore properties, field encapsulation, and data classes.

3. Functional Programming

   • Embrace Kotlin’s functional aspects such as higher-order functions, lambdas, and inline functions.

   • Utilize Kotlin’s collection operations like map, filter, reduce, and flatMap.

Intermediate Concepts

4. Kotlin Standard Library

   • Get comfortable with the Kotlin standard library and its various extensions.

   • Explore list, set, and map operations.

5. Coroutines and Asynchronous Programming

   • Gain a solid understanding of coroutines for asynchronous tasks.

   • Implement coroutine scopes, context, and learn about structured concurrency.

6. Interoperability with Java

   • Practice using Kotlin alongside Java and understand the interop-features.

   • Convert Java code to Kotlin and learn to call Kotlin from Java and vice versa.

Advanced Techniques

7. DSL and Type-Safe Builders

   • Learn to create domain-specific languages (DSLs) in Kotlin.

   • Utilize type-safe builders to create expressive and concise APIs.

8. Generics and Variance

   • Deep dive into generics and type variance (in, out).

   • Understand reified type parameters for inline functions.

9. Annotations and Reflection

   • Learn how to use annotations to provide metadata in your code.

   • Utilize Kotlin’s reflection capabilities to inspect and modify code at runtime.

Android-Specific Learning

10. Android KTX and Jetpack Libraries

    • Use Android KTX for more idiomatic Kotlin code.

    • Integrate Android Jetpack components like ViewModel, LiveData, and Room.

11. Architecture Components and MVVM

    • Master Android Architecture Components.

    • Implement the Model-View-ViewModel (MVVM) pattern with Kotlin.

12. UI Development with Kotlin

    • Understand how to build user interfaces with Kotlin.

    • Learn about view binding and Kotlin synthetics (deprecated, but good for legacy projects).

Practical Application

13. Building Real Apps

    • Apply your skills by building complete Android applications.

    • Focus on creating well-structured and performant Kotlin code.

14. Testing and Debugging

    • Write unit tests using JUnit and mockK for Kotlin.

    • Master debugging tools in Android Studio for Kotlin code.

15. Performance and Optimization

    • Profile and optimize Kotlin code performance.

    • Understand inline functions, crossinline, and noinline to optimize lambda usages.

Continuous Improvement

16. Best Practices and Code Reviews

    • Adopt Kotlin coding conventions and best practices.

    • Engage in code reviews with peers to learn from collective knowledge.

17. Design Patterns

    • Implement design patterns in Kotlin tailored for Android development.

18. Kotlin Multiplatform

    • Explore Kotlin Multiplatform for sharing code between Android and other platforms.

Community Engagement and Resources

19. Engagement

    • Participate in Kotlin and Android communities.

    • Contribute to open-source projects to gain real-world experience.

20. Stay Updated

    • Follow Kotlin's evolution and updates.

    • Attend webinars, workshops, and conferences dedicated to Kotlin.

Learning Resources

• Official Kotlin Documentation

• Books like "Kotlin in Action" and "Kotlin Programming: The Big Nerd Ranch Guide"

• Online Courses and Tutorials on platforms like Udacity, Coursera, and Codecademy

• Code Labs and Workshops offered by JetBrains and Google

Mastering Kotlin is a journey that requires dedication to learning, practice, and staying updated with the latest trends and practices. By following this framework, you can systematically increase your Kotlin proficiency and apply it effectively to Android app development.

________

For each foundational concept, I will provide a simple example to illustrate how it might look in Kotlin when developing Android apps. Remember, these are basic examples meant to introduce the syntax and concepts, and real-world applications will be more complex.

1. Syntax and Basics

Variables and Basic Types:

kotlin

fun basicTypes() {

    val name: String = "Android" // Immutable variable

    var version: Int = 10        // Mutable variable

    println("Platform: $name, Version: $version")

}

2. Object-Oriented Programming

Classes and Inheritance:

kotlin

open class Animal(val name: String) {

    open fun makeSound() {

        println("$name makes a sound")

    }

}

class Dog(name: String) : Animal(name) {

    override fun makeSound() {

        println("$name barks")

    }

}

fun tryClasses() {

    val myDog = Dog("Buddy")

    myDog.makeSound()

}

3. Functional Programming

Lambdas and Higher-Order Functions:

kotlin

fun calculate(x: Int, y: Int, operation: (Int, Int) -> Int): Int {

    return operation(x, y)

}

fun lambdasExample() {

    val sumResult = calculate(4, 5) { a, b -> a + b }

    println("Sum: $sumResult")

}

4. Kotlin Standard Library

Working with Collections:

kotlin

fun workWithCollections() {

    val numbers = listOf(1, 2, 3, 4, 5)

    val doubled = numbers.map { it * 2 }

    println("Doubled: $doubled")

}

5. Coroutines and Asynchronous Programming

Using Coroutines for Asynchronous Tasks:

kotlin

import kotlinx.coroutines.*

fun fetchDoc() {

    GlobalScope.launch {

        val doc = async { getTheDocument() }

        println(doc.await())

    }

}

suspend fun getTheDocument(): String {

    delay(1000) // Simulate long-running task

    return "Document"

}

6. Interoperability with Java

Calling Kotlin Functions from Java:

kotlin

// Kotlin

class Greeter {

    fun greet() {

        println("Hello from Kotlin!")

    }

}

// Java

public class JavaActivity extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        Greeter greeter = new Greeter();

        greeter.greet();

    }

}

Each of these examples demonstrates how you might start replacing Java code with Kotlin in an Android app. Kotlin's conciseness, safety features, and functional programming capabilities can make your Android development more efficient and enjoyable. Remember that to run these examples in an actual Android project, you need to have them within the scope of an Activity, Fragment, or another component of the Android framework, and you must properly set up coroutines with a suitable scope and lifecycle awareness.

________

Here's a second set of examples demonstrating various Kotlin concepts with a focus on Android development:

1. Syntax and Basics

Control Flow - Using when as an Expression:

kotlin

fun getDeviceType(model: String): String {

    return when (model) {

        "Pixel", "Galaxy" -> "Phone"

        "Nexus 9", "Galaxy Tab" -> "Tablet"

        else -> "Unknown"

    }

}

2. Object-Oriented Programming

Interfaces and Delegation:

kotlin

interface ClickListener {

    fun onClick(event: String)

}

class Button(val clickListener: ClickListener) {

    fun press() {

        clickListener.onClick("Button Pressed")

    }

}

class Activity : ClickListener {

    override fun onClick(event: String) {

        println(event)

    }

}

fun tryInterfaces() {

    val activity = Activity()

    val button = Button(activity)

    button.press()

}

3. Functional Programming

Extension Functions and Null Safety:

kotlin

fun String?.printWithDefault(default: String) = println(this ?: default)

fun tryExtensionFunction() {

    val nullableString: String? = null

    nullableString.printWithDefault("Default String")

}

4. Kotlin Standard Library

Elvis Operator and List Filtering:

kotlin

data class User(val name: String, val age: Int?)

fun filterUsers(users: List<User>) {

    val adults = users.filter { it.age ?: 0 >= 18 }

    adults.forEach { println(it.name) }

}

5. Coroutines and Asynchronous Programming

Structured Concurrency with runBlocking:

kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {

    launch {

        delay(1000L)

        println("World!")

    }

    println("Hello,")

}

6. Interoperability with Java

Using Java Libraries in Kotlin:

kotlin

import java.text.SimpleDateFormat

import java.util.*

fun getCurrentTime(): String {

    val formatter = SimpleDateFormat("HH:mm:ss", Locale.getDefault())

    return formatter.format(Date())

}

These examples further illustrate the capabilities of Kotlin and how they can be applied to Android development. Remember, Kotlin is designed to interoperate fully with Java, so you can gradually introduce Kotlin into existing Java Android applications.

________

For the third set of examples, let's explore more advanced features and see how they can be applied in the context of Android app development with Kotlin.

1. Syntax and Basics

Destructuring Declarations:

kotlin

data class User(val username: String, val email: String)

fun displayUserInfo(user: User) {

    val (username, email) = user

    println("Username: $username, Email: $email")

}

fun tryDestructuring() {

    val user = User("kotlindev", "developer@example.com")

    displayUserInfo(user)

}

2. Object-Oriented Programming

Properties and Backing Fields:

kotlin

class UserProfile {

    var name: String = "John Doe"

        get() = field.toUpperCase()

        set(value) {

            field = value.trim()

        }

}

fun tryProperties() {

    val profile = UserProfile()

    profile.name = "  Jane Smith  "

    println(profile.name) // Prints "JANE SMITH"

}

3. Functional Programming

Use of with and Scope Functions:

kotlin

data class Configuration(var darkMode: Boolean, var fontSize: Int)

fun applyConfiguration(config: Configuration) {

    with(config) {

        darkMode = true

        fontSize = 12

    }

}

fun tryWith() {

    val config = Configuration(false, 14)

    applyConfiguration(config)

    println(config)

}

4. Kotlin Standard Library

Sequences for Lazy Collections Operations:

kotlin

fun processLargeList(largeList: List<Int>) {

    largeList.asSequence()

        .filter { it > 100 }

        .map { it * 2 }

        .forEach { println(it) }

}

fun trySequences() {

    processLargeList((1..1000).toList())

}

5. Coroutines and Asynchronous Programming

Using async and await for Concurrent Operations:

kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {

    val deferredResult = async {

        delay(1000) // Simulate a long-running task

        42 // The answer to everything

    }

    println("Waiting for the result...")

    println("Result: ${deferredResult.await()}")

}

6. Interoperability with Java

Using Java Streams in Kotlin:

kotlin

import java.util.stream.Collectors

fun getSortedUniqueNumbers(numbers: List<Int>): List<Int> {

    return numbers.stream()

        .distinct()

        .sorted()

        .collect(Collectors.toList())

}

fun tryJavaStreams() {

    val numbers = listOf(7, 3, 5, 7, 3)

    val uniqueSortedNumbers = getSortedUniqueNumbers(numbers)

    println(uniqueSortedNumbers)

}

In these examples, we've illustrated a variety of Kotlin concepts from destructuring declarations to advanced use of collections and interoperability features with Java. In Android development, these language features can be employed to write cleaner, more maintainable code, and to leverage existing Java libraries effectively within Kotlin.

________

Let's illustrate additional examples for each of the discussed concepts.

1. Syntax and Basics

Ranges and For-Loop:

kotlin

fun printAlphabet() {

    for (c in 'A'..'Z') {

        print("$c ")

    }

}

This loop will print all the letters in the alphabet using Kotlin's range expression.

2. Object-Oriented Programming

Secondary Constructors:

kotlin

class Rectangle {

    var height: Double

    var width: Double

    constructor(_height: Double, _width: Double) {

        height = _height

        width = _width

    }

    constructor(side: Double) : this(side, side)

    fun area() = height * width

}

This class Rectangle has two constructors: one for a general rectangle and one for a square.

3. Functional Programming

Let Function and Safe Calls:

kotlin

data class Person(val name: String, val age: Int?)

fun printPersonAge(person: Person?) {

    person?.let {

        println("${it.name}'s age is ${it.age}")

    }

}

The let function is often used for executing a code block only with non-null values.

4. Kotlin Standard Library

Using takeIf and takeUnless:

kotlin

fun getUserPositiveAge(user: User): Int? {

    return user.age.takeIf { it != null && it > 0 }

}

This function will return the user's age if it is positive, or null otherwise.

5. Coroutines and Asynchronous Programming

Cancellation and Timeouts:

kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {

    val job = launch {

        withTimeout(1000L) {

            repeat(1000) { i ->

                println("Job: I'm sleeping $i ...")

                delay(500L)

            }

        }

    }

    delay(1300L)

    println("main: I'm tired of waiting!")

    job.cancelAndJoin()

    println("main: Now I can quit.")

}

This coroutine will get cancelled if it takes more than a second to execute, demonstrating structured concurrency and timeout control.

6. Interoperability with Java

Calling Kotlin Extension Functions from Java:

Kotlin:

kotlin

// Define an extension function in Kotlin

fun String.exclaim() = this + "!"

Java:

java

public class Main {

    public static void main(String[] args) {

        String message = StringUtilKt.exclaim("Hello from Java");

        System.out.println(message); // Output: Hello from Java!

    }

}

Extension functions are compiled to static methods in a utility class named after the Kotlin file they're declared in (StringUtil.kt in this case).

These additional examples further demonstrate the versatility of Kotlin when developing Android apps. Each concept showcases Kotlin's ability to provide more concise and expressive ways to accomplish common programming tasks compared to Java.

________

Here's a fifth set of examples, each illustrating a different aspect of Kotlin programming within the context of Android app development.

1. Syntax and Basics

String Templates:

kotlin

fun greetUser(username: String, isAdmin: Boolean) {

    val adminStatus = if (isAdmin) "Admin" else "User"

    println("Hello, $username! You're logged in as an $adminStatus.")

}

In this example, we use Kotlin's string templates to insert variables directly into strings.

2. Object-Oriented Programming

Visibility Modifiers:

kotlin

open class Person(protected val name: String) {

    private fun printSecret() = println("This is a secret")

    fun introduce() {

        printSecret()

        println("My name is $name")

    }

}

class Student(name: String, val school: String) : Person(name) {

    fun sayHello() {

        // printSecret() // Error: Cannot access 'printSecret': it is private in 'Person'

        println("I study at $school")

    }

}

This example demonstrates the use of visibility modifiers (private and protected) to control access to class members.

3. Functional Programming

The apply Scope Function:

kotlin

data class Settings(var darkMode: Boolean = false, var fontSize: Int = 12)

fun configureSettings() {

    val mySettings = Settings().apply {

        darkMode = true

        fontSize = 16

    }

    println(mySettings)

}

The apply scope function allows you to initialize or configure an object upon its creation.

4. Kotlin Standard Library

groupBy and mapValues:

kotlin

data class Task(val id: Int, val completed: Boolean)

fun categorizeTasks(tasks: List<Task>) {

    tasks.groupBy { it.completed }

         .mapValues { (_, tasks) -> tasks.size }

         .forEach { (completed, count) ->

             val status = if (completed) "Completed" else "Pending"

             println("$status tasks: $count")

         }

}

In this example, tasks are grouped by their completion status, and we count how many tasks are in each group.

5. Coroutines and Asynchronous Programming

Flow for Reactive Streams:

kotlin

import kotlinx.coroutines.*

import kotlinx.coroutines.flow.*

fun fetchNumbers(): Flow<Int> = flow {

    for (i in 1..5) {

        delay(100) // pretend we are doing something useful here

        emit(i) // emit next number

    }

}

fun main() = runBlocking {

    launch {

        fetchNumbers().collect { value ->

            println(value)

        }

    }

}

Flow is a type that can emit multiple values sequentially, as opposed to suspend functions which return only a single result.

6. Interoperability with Java

Kotlin Collections and Java:

kotlin

fun processListInJavaStyle(list: List<Int>): List<Int> {

    return Collections.unmodifiableList(list.filter { it > 10 }.sorted())

}

This Kotlin function uses Java's Collections class to create an unmodifiable list, demonstrating interoperability between Kotlin and Java collections.

These examples are meant to provide a practical introduction to various Kotlin features and how they can be applied in Android app development. As you gain more experience, you'll be able to use these constructs in more complex scenarios, including actual Android app components.

________

Let's explore another set of examples for each key concept, further demonstrating the versatility and functionality of Kotlin, especially when used for Android development.

1. Syntax and Basics

Named Arguments and Default Parameters:

kotlin

fun createProfile(name: String, email: String, age: Int = 0, isAdmin: Boolean = false) {

    println("Name: $name, Email: $email, Age: $age, Admin: $isAdmin")

}

fun namedArgumentsExample() {

    // Specifying only required arguments, using default for others

    createProfile(name = "Jane", email = "jane@example.com")

    // Specifying all arguments, with named arguments

    createProfile(name = "John", email = "john@example.com", age = 30, isAdmin = true)

}

Named arguments enhance code readability, and default parameters allow for more flexible function calls.

2. Object-Oriented Programming

Companion Objects:

kotlin

class Database private constructor() {

    companion object {

        private var instance: Database? = null

        fun getInstance(): Database {

            if (instance == null) {

                instance = Database()

            }

            return instance!!

        }

    }

    fun query(sql: String) {

        println("Executing query: $sql")

    }

}

fun companionObjectsExample() {

    val database = Database.getInstance()

    database.query("SELECT * FROM users")

}

The companion object in Kotlin is similar to the static methods in Java, providing a way to access methods and properties from a class without creating an instance.

3. Functional Programming

The also Scope Function:

kotlin

data class ScreenConfiguration(var density: Int, var fontScale: Float)

fun adjustScreenConfiguration() {

    val config = ScreenConfiguration(density = 240, fontScale = 1.0f).also { config ->

        println("Adjusting screen configuration: $config")

    }

    // config is now available here, potentially after some logging or other operations

}

The also function is useful for additional operations such as logging or debugging when initializing objects.

4. Kotlin Standard Library

fold for Accumulating Values:

kotlin

fun calculateSum(numbers: List<Int>): Int {

    return numbers.fold(0) { sum, number -> sum + number }

}

fun foldExample() {

    val sum = calculateSum(listOf(1, 2, 3, 4, 5))

    println("The sum is $sum")

}

The fold function accumulates values starting with an initial value and applying an operation from the left to the right of the collection.

5. Coroutines and Asynchronous Programming

Exception Handling in Coroutines:

kotlin

import kotlinx.coroutines.*

fun main() = runBlocking {

    val job = launch {

        try {

            doRiskyWork()

        } catch (e: Exception) {

            println("Error: ${e.message}")

        }

    }

    job.join()

}

suspend fun doRiskyWork() {

    throw Exception("Something went wrong")

}

Exception handling within coroutines can be managed with try-catch blocks just like in regular Kotlin code.

6. Interoperability with Java

Using Kotlin Lambda with Java Interfaces:

kotlin

fun interface IntPredicate {

    fun accept(i: Int): Boolean

}

fun checkNumber(predicate: IntPredicate) {

    val listOfNums = listOf(1, 2, 3, 4, 5)

    for (num in listOfNums) {

        if (predicate.accept(num)) {

            println("Number $num accepted by the predicate")

        }

    }

}

fun interoperabilityExample() {

    checkNumber(IntPredicate { it % 2 == 0 }) // Using Kotlin lambda

}

Kotlin's functional interfaces are interoperable with Java's single-method interfaces, allowing you to pass Kotlin lambdas where a Java interface is expected.

These examples should provide a clearer understanding of how Kotlin's features can be used in developing Android applications, especially as you replace or interoperate with Java code.

________

Learning a programming language like Kotlin and retaining the knowledge involves active practice and understanding of the core concepts. Here are some questions and activities that can help students consolidate their understanding of Kotlin and its use in Android development:

Fundamental Concepts

1. What are val and var, and when should each be used?

2. How do you declare a function with default parameters in Kotlin?

3. Can you explain how null safety works in Kotlin and compare it with Java's approach?

4. Write a small program that uses a when statement to handle multiple conditions.

Object-Oriented Programming

5. How do you define a data class in Kotlin? Create an example.

6. What are the differences between abstract classes and interfaces in Kotlin?

7. Can you illustrate the use of companion objects with an example?

8. Create a class with a primary constructor and a secondary constructor.

Functional Programming

9. What are higher-order functions and how are they used in Kotlin?

10. How do Kotlin's extension functions work? Write an extension function for the String class.

11. Demonstrate the use of the let, run, with, apply, and also scope functions with examples.

12. Write a lambda expression that takes two integers and returns their product.

Kotlin Standard Library

13. How do you work with collections in Kotlin differently than in Java?

14. What are some of the common standard library functions you can use with lists and other collections?

15. Create a small program that demonstrates the use of the map, filter, and fold functions on a collection.

16. How would you implement a custom sorting logic on a list of objects in Kotlin?

Coroutines and Asynchronous Programming

17. Explain what coroutines are and how they differ from traditional threads.

18. What are suspend functions, and how do you use them?

19. Write a coroutine that performs a simple background task and returns a result to the main thread.

20. How can you handle exceptions in coroutines?

Android-Specific Kotlin Usage

21. How does Kotlin improve Android development compared to Java?

22. Demonstrate how to use LiveData with Kotlin for reactive UI updates.

23. Create a ViewModel in Kotlin and explain its role in the MVVM architecture.

24. What is Android KTX, and how does it make Android development more Kotlin idiomatic?

Retention and Mastery

25. How can you use an Anki deck or other spaced repetition software to remember Kotlin syntax and functions?

26. What projects can you start to apply and consolidate your Kotlin knowledge?

27. How often should you revisit fundamental concepts to keep them fresh in your memory?

28. Explain the importance of code reviews and pair programming in learning and retaining programming skills.

For each question, students should not only be able to theoretically answer them but also provide coding examples where possible. The key to long-term retention of a programming language is consistent practice and application of the concepts in real-world projects. Encourage students to build small applications, contribute to open-source projects, and engage with the Kotlin community to deepen their understanding and retention of the language.