Greetings and welcome back to our startup building series with KMM! In our last blog, we talked about the initial ideation and MVP design of Pocketbook, our revolutionary finance and budgeting app. Now, it’s time to delve into the technical aspects and explore the backend system design in detail. In this blog, I’ll take you through the UML diagrams and microservices architecture that we’ll use to bring Pocketbook to fruition. Get ready to join us on this exhilarating journey, and let’s kick things off!

Building Startup with KMM [2/n]— Brainstorming ideas and MVP with ChatGPT

The ChatGPT only had limited use in this case, but most of its properties were very generic. It is not much autonomus as I expected. Not something out of the box. Though it was really useful during my research. Though the name PocketBook given by ChatGPT.

Simple System Design

Here is what I have an overall idea of the system. I am trying to over-engineer everything, so it is a learning opportunity for me, the comprehensive end-to-end flow.

The Clients hit the API Gateway, which will discover the service and pass it to that service. We also have a caching layer with Redis Datastore. Then we have to follow a microservice pattern based on the domain they are divided into. Now for the database part, I will be using Postgres and Elasticsearch using Postgres for all the POST/PATCH/DELETE requests. Since this app is expected to have many graphs, so querying data at a large scale would be an issue, so we will be syncing data with Elasticsearch. This will help us to make our queries (for graphs) and text searches faster. We will be later some other use cases where Elasticsearch will be beneficial. We are using gRPC for inter-service and overall communication to have a more unified and resilient contact, smaller payload size and faster functionality over REST.

Some References for what I did and why I did

• How we optimized Django APIs using Elasticsearch & PostgreSQL Functions
• What are microservices?
• Microservices Pattern: Pattern: API Gateway / Backends for Frontends
• How To Configure API Gateway in Microservices Architecture
• Client-side caching in Redis

Postgres Database Design

The next step was to plan a basic database schema. So It took me a while to decide what to consider and want not to do. Initially, I intended to make a Database per service; however, it was really complicated stuff that made it easier for me to make a monolithic database to handle all the foreign keys and cascading things for the MVP.

Trying to reduce the monolithic database by design, making sure that only a specific service can access the specific table so that it is easier to separate in the long run.

You check the DB schema and commands here: https://dbdiagram.io/d/63a9b6ea7d39e42284e791dd

I added Postgres Indexes and tried to normalize the tables as much as possible, it follows the basics of designing the database. Have a look at the detailed explanation of the design. Do comment if you have some views.

• DBMS Normalization: 1NF, 2NF, 3NF Database Example
• PostgreSQL - INDEXES

Will be using a managed service, for now, PlanetScale really great free tier. For the authentication layer, I will be using Auth0 and some managed service for the Redis Layer from Upstash (Not Sure presently).

Elasticsearch Design

Keeping this section simple, I will be doing one-to-one mapping tables in Postgres with Elasticsearch. Have a look at this article it is really great, have a look at why I jumped into Elasticsearch.

Combining Elasticsearch with DBs: Application System Scenarios

Here is an example of how you might create a mapping for the users table from your database schema:

PUT users
{
  "mappings": {
    "properties": {
      "id": {
        "type": "integer"
      },
      "email": {
        "type": "text"
      },
      "password_hash": {
        "type": "text"
      },
      "first_name": {
        "type": "text"
      },
      "last_name": {
        "type": "text"
      },
      "date_of_birth": {
        "type": "date"
      },
      "gender": {
        "type": "keyword"
      },
      "phone": {
        "type": "text"
      },
      "profile_picture_url": {
        "type": "text"
      },
      "created_at": {
        "type": "date"
      },
      "updated_at": {
        "type": "date"
      }
    }
  }
}

You can repeat this process for each of the other tables in your database schema, defining the fields and their data types in the Elasticsearch mapping as needed.

It’s worth noting that you should choose data types for your Elasticsearch mapping based on the types of queries you will be running against your data. For example, if you want to be able to search for exact values in a field, you might want to use the keyword data type, while if you want to be able to perform full-text searches on a field, you might want to use the text data type.

I’ve covered the essential steps of basic system design and database structure in creating an MVP. In the next blog, we’ll continue our journey by diving into the development of our MVP. Who knows where this journey will take us? Stay tuned as we turn our side project into a potentially successful startup (or at least have a bit of fun along the way).

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Building Startup (Pocketbook) with KMM [3/n] — Database and System Design was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

As a mobile developer, I’m excited to see what we can accomplish with ChatGPT and a little bit of determination. If you don’t know about ChatGPT, which stands for Chat Generative Pre-trained Transformer, is a chatbot developed by OpenAI. This has taken the world by storm with its detailed responses and articulate answers across many domains of knowledge. You can find more details here.

Introducing ChatGPT

In my previous blog, we already discussed Kotlin Multiplatform Mobile(KMM)

Will Kotlin Multiplatform Mobile change the way we make mobile applications? [1/n]

Just combining two trending topics to make good use of my Wellness Holidays from my company❤️.

Note: I am planning to develop and publish the app end to end and my journey. Do add your ideas and thoughts in the comments 🙏. I will add the next blog link to this when I post next.

Building a startup can be a challenging and rewarding experience, but it doesn’t have to be all work and no play. With the right tools and a little bit of creativity, it’s possible to turn a side project into a fun and successful venture. Join me on this journey as I document the process of building a startup from scratch, all while keeping things light and enjoyable. Let’s get started!

Ideation

Initially, I had no idea in particular so I blankly asked for

Android and ios app ideas which are easy to build but really creative.

The ideas from ChatGPT were,

1. A social networking app for people with common hobbies or interests. This could be a platform for people to connect with others who have similar hobbies, such as cooking, gardening, or playing a particular sport.
2. A language learning app that gamifies the learning process. This app could include interactive quizzes, challenges, and rewards to make learning a new language more engaging.
3. A recipe app that suggests meals based on the ingredients you have available. Users could input the ingredients they have on hand, and the app would suggest recipes that use those ingredients.
4. A budgeting and finance tracking app that helps users keep track of their spending and set financial goals. The app could include features like budgeting templates, spending tracking, and alerts when users approach their budget limits.
5. A fitness tracking app that uses machine learning to suggest personalized workouts based on the user’s fitness level and goals. The app could include exercises and workouts for a variety of fitness levels, as well as progress tracking and motivation tools.
6. A mental health and self-care app that offers guided meditation, journaling prompts, and other self-care activities to help users manage stress and improve their overall well-being.
7. A travel planning app that helps users plan and organizes their trips. The app could include features like itinerary planning, travel budgeting, and destination recommendations based on the user’s preferences.

Nothing new or creative as such but let’s play along with this and see where it takes us. I continued with the budgeting and finance tracking app.

Dissecting and BrainStorming

Then I asked

Can you expand on the budgeting and finance tracking app and dissect idea into features based on market research?

And wah-lah you have a great list of features. Great!

1. Budgeting templates: Users can choose from pre-designed budget templates or create their own custom budget.
2. Spending tracking: Users can input their daily or monthly expenses to track their spending and see how it compares to their budget.
3. Bill reminders: Users can set up alerts to remind them when bills are due, helping them avoid late fees and maintain a good credit score.
4. Savings goals: Users can set savings goals and track their progress towards achieving them. The app could also provide recommendations on how to save more money, such as by cutting unnecessary expenses or finding ways to earn additional income.
5. Investment tracking: Users can track their investments and see how they are performing over time. The app could also provide recommendations on investment opportunities based on the user’s risk tolerance and financial goals.
6. Credit score monitoring: Users can track their credit score and get alerts when it changes. The app could also provide tips on how to improve their credit score, such as by paying bills on time and reducing credit card balances.
7. Debt management: Users can track their debt and create a plan to pay it off. The app could provide recommendations on the best repayment strategies, such as prioritizing high-interest debt or using the snowball method.
8. Shared budgets: Users can invite other people, such as their spouse or family members, to join their budget and track their combined spending.
9. Integration with financial accounts: Users can connect their bank, credit card, and other financial accounts to the app, allowing them to see all their financial information in one place.
10. Security: The app should prioritize the security and privacy of user data, including using strong encryption and secure servers to protect against data breaches.

I had a follow-up question regarding Budgeting templates like what it is referring to?

Budgeting templates are pre-designed budget plans from which users can choose to assist them in managing their finances. These templates usually include categories for common expenses like housing, transportation, food, and entertainment, as well as estimates for how much should be spent in each category based on the user’s income and financial goals. By providing budgeting templates, the app can provide a starting point for users who are new to budgeting or who want to quickly set up a budget without having to start from scratch. The templates can also be used as a reference for users who want to compare their own budget to a recommended plan.

Competition and Product Market Fit

When I asked regarding

Which of these features is unique to the market and not done by already existing apps? and secondly, do you have any creative suggestions for better product market fit?

The answer was quite intuitive and explanative,

It’s difficult to say which specific features are unique to the market, as new financial apps are constantly being developed and released. However, here are a few potential ideas for unique features that could differentiate a budgeting and finance tracking app from existing ones:

1. Personalized budget recommendations: The app could use machine learning algorithms to analyze the user’s spending and income patterns and provide recommendations on how to optimize their budget for their specific financial situation.
2. Gamification: The app could use gamification techniques, such as rewards and challenges, to make budgeting and financial management more engaging and motivating for users.
3. Integration with financial advisors: Users could connect with financial advisors through the app to get personalized financial advice and guidance.
4. Collaboration with financial institutions: The app could partner with banks and other financial institutions to offer users exclusive discounts and perks, such as reduced fees or higher interest rates on savings accounts.
5. Customized financial planning: The app could offer personalized financial planning services, such as helping users create a retirement plan or a budget for a major life event, such as a wedding or the birth of a child.
6. Social networking for finance: The app could include a social networking component, allowing users to connect with and learn from others in the financial community. Users could share budgeting and saving tips, share their financial goals, and offer support and encouragement to each other.

To better fit the product to the market, you could consider conducting market research to understand the needs and preferences of your target users. This could involve surveying potential users, analyzing data on existing financial apps, and conducting focus groups to gather feedback on your product ideas. Based on this research, you can tailor the features of your app to better meet the needs and desires of your target audience.

Quite an impressive answer!

Minimal Viable Product (MVP)

After a solid back-and-forth discussion with ChatGPT, I concluded the following as the basic features required for an MVP.

1. Budgeting templates: Users can choose from pre-designed budget templates or create their own custom budget.
2. Spending tracking: Users can input their daily or monthly expenses to track their spending and see how it compares to their budget.
3. Bill reminders: Users can set up alerts to remind them when bills are due.
4. Savings goals: Users can set savings goals and track their progress towards achieving them.
5. Security: The app should prioritize the security and privacy of user data, including using strong encryption and secure servers to protect against data breaches.

This MVP includes the core features of a budgeting and finance tracking app, including the ability to create a budget, track spending, and set up bill reminders. It also includes security measures to protect user data.

I’ve covered the essential steps of brainstorming ideas and creating an MVP using ChatGPT. In the next blog, we’ll continue our journey by diving into the development of our MVP. Who knows where this journey will take us? Stay tuned as we turn our side project into a potentially successful startup (or at least have a little bit of fun along the way).

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Building Startup with KMM [2/n]— Brainstorming ideas and MVP with ChatGPT was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

If you are a mobile developer and not living under a rock, you should have heard about Kotlin Multiplatform and how it revolutionizes the mobile development industry.

Let me first explain it to you Kotlin Multiplatform Mobile (KMM) is an SDK designed to simplify the development of cross-platform mobile applications. You can share common code between iOS and Android apps and write platform-specific code only where it’s necessary. Common use cases for Kotlin Multiplatform Mobile include implementing a native UI or working with platform-specific APIs.

What is Kotlin Multiplatform Mobile (KMM)?

Kotlin Multiplatform Mobile is an SDK for iOS and Android app development. It offers all the combined benefits of creating cross-platform and native apps. Maintain a single codebase for networking, data storage, analytics, and the other logic of your Android and iOS apps. Implement native UIs and leverage other features specific to Android and iOS devices.

It is trusted in production by many of the world’s leading companies, including Philips, Netflix, Leroy Merlin, and VMWare.

Problems that KMM is trying to solve?

• Time and efforts saved by sharing code — In mobile development, it is always an issue that the same code has to be written in both android and iOS with KMM it is really easy that the business logic can easily be shared between in turn will rescue the time taken to rewrite the same business logic.
• Native Performance — With cross-platform solutions performance has always been an issue. Since the introduction of KMM separated out only the business logic, the UI remains the same native, with easier access to hardware like Camara, etc. Unlike cross-platform options like Flutter, Ionic, etc.
• Connect to platform-specific APIs without overhead — KMM is not overlapped with your native device usage. If you want to access your device camera you natively access it with native Swift code for iOS and Kotlin for Android. This approach is very much better than the approach that Flutter or React Native takes.

How is KMM solving problems?

Share code on platforms

If you have common business logic for all platforms, you don’t need to write the same code for each platform — share it in the common source set.

One language for cross-platform and native apps

There’s no need to introduce any new programming languages to your codebase to make your app cross-platform. Make your existing Android app work on iOS devices without changing much of your existing code.

Kotlin syntax follows the same concepts used for iOS development and is easy for iOS developers to learn.

Connect to platform-specific APIs

If you’re developing a multiplatform application that needs to access platform-specific APIs that implement the required functionality (for example, generating a UUID), use the Kotlin mechanism of expected and actual declarations.

With this mechanism, a common source set defines an expected declaration, and platform source sets must provide the actual declaration that corresponds to the expected declaration. This works for most Kotlin declarations, such as functions, classes, interfaces, enumerations, properties, and annotations.

The compiler ensures that every declaration marked with the expect keyword in the common module has the corresponding declarations marked with the actual keyword in all platform modules. The IDE provides tools that help you create the missing actual declarations.

Familiar with tooling and ecosystem

Multiplatform Mobile leverages the multiplatform capabilities of Kotlin and provides tooling for cross-platform mobile development in Android Studio. The multiplatform library ecosystem is growing. A number of big libraries such as Ktor, SQLDelight, Apollo, and Koin have already adopted Kotlin Multiplatform.

How Kotlin Multiplatform works

• Common Kotlin includes the language, core libraries, and basic tools. Code written in common Kotlin works everywhere on all platforms.
• With Kotlin Multiplatform libraries, you can reuse the multiplatform logic in common and platform-specific code. Common code can rely on libraries that cover tasks such as HTTP, serialization, and managing coroutines.
• To interop with platforms, use platform-specific versions of Kotlin. Platform-specific versions of Kotlin (Kotlin/JVM, Kotlin/JS, Kotlin/Native) include extensions to the Kotlin language, and platform-specific libraries and tools.
• Through these platforms, you can access the platform's native code (JVM, JS, and Native) and leverage all native capabilities.

These are all the reasons why I feel Kotlin Multiplatform will change the way we think of approaches to building a mobile application. It provides the best of both worlds by providing the power to share business logic between platforms with the speed of native approaches.

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Recent Post

• Build Ktor Project with Docker and Add Nginx for Load Balancing & Reverse Proxy
• Media3 ExoPlayer in Jetpack Compose to make Snapchat Spotlight
• Adding Google Map in Jetpack Compose 🗺📌- Using AndroidView And android-maps-compose
• Replacing Retrofit with Ktor Client and Kotlin Serialization for Android🐱‍🏍

Will Kotlin Multiplatform Mobile change the way we make mobile applications? [1/n] was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Blockchain and Cryptocurrency are the new buzzwords of Genz. I think knowledge without understanding is meaningless because it is information, not knowledge. The information doesn’t have meaning on its own, does it?

This scene from the movie “The Matrix” always intrigues me to know more and have a deeper understanding. The blue pill describes a continuity of the current state of life i.e. living life without knowing its meaning or running away from the truth in order to stay as is. The red pill is described as the solution to knowing the real truth in life.

So today here is your red pill for blockchain, to you understand this in the most simple way I can.

Assume that there are two individuals: Bob and Alice. Bob lends Alice some money, and Bob records it on a document that Alice has signed. After a few days, Alice disputes the existence of such a document and asserts that Bob faked it. It would now be challenging for Bob to demonstrate that Alice genuinely owed him money.

In this example, Alice and Bob are two nodes.

Consider the same situation now, but this time it’s a society. As a result, “k” pairs of people are interacting with one another. And that piece of paper is the only evidence each duo has. Kate offers a remedy after considering this situation. She advises that the entire society keep a shared journal of transactions. She chooses town hall as the location for all conversations. Every couple records their transactions in the shared notebook, which is subsequently stored securely. People are happy with Kate as their leader and accept her.

That notebook can be called a database.

But the notebook gets wine on it one day. The notebook is now impossible to read. Alice takes advantage of this circumstance and refutes taking money from Bob once more.

This is the problem databases face: a single point of failure.

Angered by this issue, Kate finds a different remedy. She advises keeping several notebooks. She selects a few reliable people from the community and gives them each a notebook. Now Kate tells some of those reliable people to record every transaction or exchange that occurs between two people in their notebooks. The information is therefore repeated in the notebooks. Now, even if one notebook is lost or destroyed, it’s likely that the collection of other notebooks will still include all the transactional data.

This is a distributed database, and multiple notebooks are numerous nodes.

But the following day, a new issue appears. Bert, a friend of Kate’s, owes a lot of money to various members of society. When he asks Kate for assistance, she grants it. She tells everyone who has a notepad to cross out the lines where Bert received the cash. Based on the notebooks, Bert is now debt-free.

This is the problem with distributed databases — they are centralized. That means one single entity owns all the nodes and resources and can make changes as they deem fit.

When the members of the society know of it, they remove Kate from the leadership.

• They choose to each keep a notebook. Every time there is a transaction between any two individuals, all the residents of the town gather and record it in their individual notebooks. There are therefore n notebooks in the community if there are n people, and no one person has authority over how the transactions are represented overall. This is decentralization.
• They also decide to never remove or delete an already mentioned transaction from the notebook. This is immutability.
• Now, every person in society must make the same adjustment when members of a different group, let’s call them group CHO, attempt to alter a record in their notebooks (as mentioned in the first point above, all the people write all the transactions in their notebooks). All of the other participants see that the transaction proposed by group CHO is incorrect before it is written. They thus recognize that CHO is attempting to engage in fraud. They consequently dispute that transaction and omit to record it in their notes. Additionally, they resolve to bar Group CHO from participation in the group going forward. This is how consensus is formed, and voting is done to decide the validity of a transaction on the blockchain.
• A very enthusiastic kid suggested that the transactions form a chain, so they decided to call the collective set of fully replicated, decentralized, immutable notebooks Blockchain.

then, okay. The simplest illustration of blockchain I can think of is this.

Blockchain is a decentralized, peer-to-peer, immutable storage network that is free from censorship and regulation due to the lack of a central authority. A majority of nodes vote on each written transaction, and it is computationally very challenging to change something that has already been recorded in the chain.

Hope this is helpful in making you understand the terminologies and concepts. If this encourages you to know more about the blockchain, these links will be helpful.

• https://en.wikipedia.org/wiki/Blockchain
• https://www.ibm.com/id-en/topics/what-is-blockchain
• https://www.pwc.com/us/en/industries/financial-services/fintech/bitcoin-blockchain-cryptocurrency.html

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Happy Coding!

I will well appreciate one of these 👏

Blockchain For Dummies was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Let’s dive right into it we will start by understanding what are Runes in Dart,

Runes are a collection formed out of a String's Unicode decimal code points. A Code Point is an integer value that uniquely identifies a given Unicode Character from inside the String

A Dart String is a sequence of UTF-16 code. A Code Unit is the unit of an Encoded Code Point .

UTF-16 means the code point of a Unicode Character that has been Encoded to 16-bit Code Unit (Hexadecimal Code Point). Then the code point is a hexadecimal number, which means in dart every string is split between characters and each of these characters has a hexadecimal code point, behind the scenes in Dart, a string is no more than a list of hexadecimal code points.

String s='Helloooo' ---> 'H','e','l','l','o','o','o','o'
                       0048,0065,006C,006C,006F,006F,006F,006F

Let’s See Some Examples

We make variable runes, we can actually see a list ofutf-16 code points for that string

now, let's convert it into decimal code points in order to see its hexadecimal values, we can call toRedixSting() and set 16 bit as the base, then pad it to the left so that it will always be 4 characters long, we are using a map to call it to all characters.

By the way, Dart is amazing in providing interpolation of this Unicode to characters with the /u{} delimiter i.e, any hexadecimal Unicode can be converted including emojis.

For a character outside the Basic Multilingual Plane (plane 0) that is composed of a surrogate pair, runes combine the pair and return a single integer. For example, the Unicode character for a musical G-clef (‘𝄞’) with rune value 0x1D11E consists of a UTF-16 surrogate pair: 0xD834 and 0xDD1E. Using codeUnits returns the surrogate pair, and using runes returns their combined value:

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Dart & Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Recent Post

• Advanced Dart — Generator, Stream, Extension, Mixins, Generics…
• Build Ktor Project with Docker and Add Nginx for Load Balancing & Reverse Proxy
• Replacing Retrofit with Ktor Client and Kotlin Serialization for Android🐱‍🏍
• Media3 ExoPlayer in Jetpack Compose to make Snapchat Spotlight

Secrets Of Strings in Dart was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

I was revisiting, Flutter after some time so, I thought it will be great to put up my understanding with examples and summarise it here. These are some of the topics that people tend to ignore this gives us a wide understanding of the Dart as a language. This is important, let's start with the explanation ✨

Secrets Of Strings in Dart

1. Extension🔗

It is a simple term, you can think of it as the ability of a programmer to add functions to an existing class. It’s understood with an example.

Suppose you have a class called Dog, you need to add a function train() you can directly add to the class Dog. Now suppose you don’t have the access to the Dog class or you want to segregate the function based on some use-case and based on the use-case you want to import a set of functions. Now you can do that with an extension on the class.

You can see in the example we have added the extension function, the name Train , there is no specific reason to understand the use of the name it is generally used in case you only want to include a specific extension.

2. Async/Await & Future🔮

Before everything, you need to know about an asynchronous computation. It is when a program cannot provide a result immediately when it is started, unlike a synchronous computation which does compute a result immediately by either returning a value or by throwing. An asynchronous computation may need to wait for something external to the program (reading a file, querying a database, fetching a web page) which takes time. Instead of blocking all computation until the result is available, the asynchronous computation immediately returns a Future which will eventually "complete" the result.

To perform an asynchronous computation, you use a async function which always produces a future. Inside such an asynchronous function, you can use the await operation to delay execution until another asynchronous computation has a result. While the execution of the awaiting function is delayed, the program is not blocked and can continue doing other things.

See the below code this will help you to understand it in greater detail.

3. Stream🚝

The stream you can think of as a stream of data is asynchronous however it is continuous. You can think of it as a pipe of data it either completes successfully or never completes or errors out. A stream is a sequence of asynchronous events. It is like an asynchronous Iterable — where, instead of getting the next event when you ask for it, the stream tells you that there is an event when it is ready.

Receiving stream events

Streams can be created in many ways, which is a topic for another article. Still, they can all be used in the same way: the asynchronous for loop (commonly just called await for) iterates over the events of a stream like the for loop iterates over an Iterable. For example:

Future<int> sumStream(Stream<int> stream) async {
  var sum = 0;
  await for (final value in stream) {
    sum += value;
  }
  return sum;
}

4. Generator✈

Dart Generator is a unique function that allows us to produce a sequence of values. Generators return values on demand; the value is generated when we try to iterate over the iterators. Dart provides built-in support for two types of generator functions.

• Synchronous Generators
• Asynchronous Generators

Let's first understand the difference between LIST & ITERABLE. You can think of Iterable as a list of things which is not completely calculated when it begins, it is basically lazy collection. While List in Dart is egar i.e, it is already ready then it is being called.

yeild: The yield returns the single value to the sequence at a time but does not stop the execution of the generator function completely. It returns a value for each execution of the generator function.
sync*: The sync* keyword is used to declare the synchronize generator function. It returns the value when we try to iterator the value not when it was created.
async*: The async keyword is used to declare the asynchronous generators. It returns the stream object.

Synchronous Generator

It returns an iterable object which carries value synchronously. The yeild keyword is used along with marking the synchronous generator function body as sync* to generator values.

What is the benefit? You might think why complicating things, suppose each value you yield has heavy computation. You can break out of the while loop any time, and any values after that will not be computed.

Asynchronous Generators

It returns a stream object which carries value asynchronously. The yeild keyword is used along with marking the asynchronous generator function body as async* to generator values.

5. Mixins🛰

In OOPs, we have classes, Interfaces, Abstract Classes, etc. Dart provides one more option of Mixins.

Mixins are a way of reusing a class’s code in multiple class hierarchies.

Mixins allow you to plug in code blocks without needing to create subclasses. Mixins are a very useful way of avoiding code duplication without inheritance. You can see the two vertical images on the left and the right as the outcome with mixins.

6. Generics🚀

In Dart by default, collections are heterogeneous. However, by the use of generics, we can make a collection to hold homogeneous values. The use of Generics makes the use of a single compulsory data type to be held inside the collection. Such collections are called type-safe collections.

Generics are often required for type safety, but they have more benefits than just allowing your code to run:

• Properly specifying generic types results in better-generated code.
• You can use generics to reduce code duplication.

var names = <String>[];
names.addAll(['Seth', 'Kathy', 'Lars']);
names.add(42); // Error

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Dart & Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Recent Post

• Deploy Your Ktor Project Anywhere!
• Build Ktor Project with Docker and Add Nginx for Load Balancing & Reverse Proxy
• Replacing Retrofit with Ktor Client and Kotlin Serialization for Android🐱‍🏍
• Media3 ExoPlayer in Jetpack Compose to make Snapchat Spotlight
• Adding Google Map in Jetpack Compose 🗺📌- Using AndroidView And android-maps-compose

Advanced Dart — Generator, Stream, Extension, Mixins, Generics… was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Ktor backend is becoming more and more common since it is easy to build and lighter to run. But the main problem you may face is deploying it on your Linux server, or anywhere in general, you can do it in two ways:

• Getting everything building a jar out of the Ktor project, pushing it to the server, and running it on a JVM environment.
• Using Docker to do all the heavy lifting

We will do the Docker way here. No need to worry it is really simple and you can reuse it every time it is straightforward.

Project Setup

We will not do much on the Ktor side, we will use the Ktor Project generator to build a simple minimal project.

This is the basic structure of the Ktor Project, we will add a simple String here, in return. If you start the application it will run and return the string when we hit this endpoint http://localhost:8080/api

Build a Jar from Ktor Project

We will app a plugin in build.gradle.kt the plugins{} block

id("com.github.johnrengelman.shadow") version "7.1.2"

when we make the Gradle sync, will get a new task added to our list of Gradle tasks. We will run this task and this will create a jar for us.

gradlew shadowJar

this will create a jar inside builds/libs and you can simply run this particular jar directly it has all the requirements inside so it can run anywhere. You can see the folder structure below. You can run it will the command after you navigate inside builds/libs

java -jar com.example.docker-ktor-sample-0.0.1-all.jar

This will run on our localhost on port 8080

Deploy Ktor with Docker

Docker is really simple to use and install, install Docker Desktop will really help us to visualise the images and containers. You can see the folder structure below.

You can directly copy this, and make a file with the name Dockerfile at the base of the project. These consist of really simple setting Java 11, moving into a directory, downloading and setting up gradlew , run the gradlw shadowJar to build the jar, we the expose like open8080, we make a run folder and then copy from the build/libs to the run folder rename to server.jar , finally, we will run the java -jar /run/server.jar .

Now how to run this file? you can simply do to run this to run the servers

/*
This command at the base of project where Dockerfile is present,which build from the above Dockerfile with the name ktor-docker. '.' signifies find the Dockerfile here
*/
docker build -t ktor-docker .

/*
This command will have to run the above 'ktor-docker' with the name docker-ktor1 on port 8080
*/
docker run --name docker-ktor1 -p 8080:8080 ktor-docker

The server will start at port 8080 and it will be visible on the Docker Desktop

Wow, we were able to run our Ktor app with Docker!!🎉

Since docker gives you the flexibility to run the backend irrespective of the system preferences you can now deploy to any popular Infrastructure as a Service like GCP, AWS, Azure etc.

• Deploying Executable JAR Files
• How to Deploy Docker Containers - Amazon Web Services
• Deploying Docker containers on Azure
• 3 ways to deploy and run the Spring Boot app on GCP

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Recent Post

• Build Ktor Project with Docker and Add Nginx for Load Balancing & Reverse Proxy
• Media3 ExoPlayer in Jetpack Compose to make Snapchat Spotlight
• Adding Google Map in Jetpack Compose 🗺📌- Using AndroidView And android-maps-compose
• Replacing Retrofit with Ktor Client and Kotlin Serialization for Android🐱‍🏍

Deploy Your Ktor Project Anywhere! was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Introduction

What is Clustering?

Clustering is basically a type of Unsupervised learning method. It is the process of dividing the population into groups consisting of similar data points. Points lying in the same group are as similar as possible and points in different groups are as dissimilar as possible.

Why Clustering?

Clustering helps in understanding the natural grouping in a dataset. Their purpose is to make sense to partition the data into some group of logical groupings. The main advantage of a clustered solution is automatic recovery from failure, that is, recovery without user intervention.

Types Of Clustering:

1. Exclusive Clustering: It is considered hard clustering. Here data points/items belong exclusively to one cluster. Example: K-Means Clustering.
2. Over Lapping Clustering: It is considered soft clustering. Here data points/items belong to multiple clusters. Example: Fuzzy/C-Means Clustering.

K-Means Clustering

Introduction

K-Means Clustering is a type of unsupervised learning, which is used when you have unlabeled data (i.e., data without a Target Column). The goal of this algorithm is to find groups in the data, with the number of groups represented by the variable K.

Working

Before applying any algorithm on datasets it’s necessary to understand it’s working so, let’s deep dive into the working of K-Means Clustering:

1. At very first we need to choose the number K of Clusters (Let’s take K=2).

2. Then selecting at random K points, the centroids (not necessary from the dataset).

3. Then assign each data point to the closest centroid → that forms K Cluster.

4. Then it computes and places the new centroid of each cluster.

5. Reassigning each data point to the new closest centroid. If any reassignment took place, then we go to step 4, otherwise, our model is ready.

Note: The Above Process continues until the best cluster is formed

How to Choose the Right Number of Clusters?

Finding the right number of clusters is the most difficult and important part of the Algorithm. So, Let’s understand how to choose the right number of clusters in K-Means Clustering.

WCSS: Also known as Within-Cluster-Sum of Squared. It is the sum of the squared distance between each point and the centroid in a cluster.

I will try to show step by step what actually happens to the value of WCSS when the number of Clusters increases, Then I will show the best optimal method to find the right Cluster.

As we are able to find that WCSS is decreasing as we are trying to increase the clusters. Our main aim is to decrease the WCSS. The main task of knowing the right number of clusters is the point after which the WCSS decrease becomes almost constant. So instead of using plots, we will analyze it using the Elbow Method.

From the Above Elbow curve, we found that After 3 Clusters the value of WCSS becomes almost constant so the right number of clusters for this set of data points is 3.

What would happen if we had a bad random initialization?

Traditional k-means utilize a randomization process for initializing these centroids, poor initialization can lead to increased numbers of required clustering iterations to reach convergence, a greater overall runtime, and a less-efficient algorithm overall.

To solve this issue we have a solution that is the same as K-Means but has an advantage over bad random initialization called K-Means++. K-Means++ is a smart centroid initialization technique and the rest of the algorithm is the same as that of K-Means. The steps to follow for centroid initialization are:

• Pick the first centroid point (C_1) randomly.
• Compute the distance of all points in the dataset from the selected centroid. The distance of x_i point from the farthest centroid can be computed by

d_i: Distance of x_i point from the farthest centroid
m: number of centroids already picked

• Make the point x_i as the new centroid that is having maximum probability proportional to d_i.
• Repeat the above two steps till you find k-centroids.

Implementation:

As of now, we have a rough idea of how K-Means Clustering works. So, Let’s implement it.

1. Importing the Libraries:

2. Importing, Reading DataSet, And Creating the Feature Matrix:

CustomerID is 100% Unique so will never contribute to Model Predictions.

We are using just the last two features(Annual Income (k$)and Spending Score (1–100) ) for clustering because I wanted to show you guys how clusters actually look if I will use all the features then it will become difficult for visualizing the clusters in a 2D plot.

3. Using the Elbow method to find the optimal number of clusters:

4. Training the K-Means model on the dataset:

5. Visualising the clusters:

The source code of this is available on my GitHub repository.

Summary:

With this, we came to the end of our article on K-Means Clustering. I hope this article will help you in learning K-Means Clustering in a better manner.

For any queries contact me on LinkedIn.

K-Means Clustering was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

Kotlin is wide having a wide scale adoption both for Android and Backend. I primarily used Kotlin with SpringBoot but I feel for a simple backend and with a minimum requirement you should give Ktor a try it is worth it. Being a mobile developer I think it is a great way to enter backend development.

In this blog, we will try to deploy our Ktor app using Docker and later we will use Nginx as a load balancer. If you don’t know much about Docker or Ngnix you can get a good idea here.

The final project is here, you can check it out here:

GitHub - Debanshu777/docker-ktor-nginx-sample: Simple Example using Nginx Docker with Ktor

Project Setup

We will not do much on the Ktor side, we will use the Ktor Project generator to build a simple minimal project.

This is the basic structure of the Ktor Project, we will add a simple String here, in return. If you start the application it will run and return the string when we hit this endpoint http://localhost:8080/api

Build a Jar from Ktor Project

We will app a plugin in build.gradle.kt the plugins{} block

id("com.github.johnrengelman.shadow") version "7.1.2"

when we make the Gradle sync, will get a new task added to our list of Gradle tasks. We will run this task and this will create a jar for us.

gradlew shadowJar

this will create a jar inside builds/libs and you can simply run this particular jar directly it has all the requirements inside so it can run anywhere. You can see the folder structure below. You can run it will the command after you navigate inside builds/libs

java -jar com.example.docker-ktor-sample-0.0.1-all.jar

This will run on our localhost on port 8080

Deploy Ktor with Docker

Docker is really simple to use and install, install Docker Desktop will really help us to visualize the images and containers. You can see the folder structure below.

You can directly copy this, and make a file with the name Dockerfile at the base of the project. These consist of really simple setting Java 11, moving into a directory, downloading and setting up gradlew , run the gradlw shadowJar to build the jar, we the expose like open8080, we make a run folder and then copy from the build/libs to the run folder rename to server.jar , finally, we will run the java -jar /run/server.jar .

Now how to run this file? you can simply do to run this to run the servers

/*
This command at the base of project where Dockerfile is present,which build from the above Dockerfile with the name ktor-docker. '.' signifies find the Dockerfile here
*/

docker build -t ktor-docker .

/*
This command will have to run the above 'ktor-docker' with the name docker-ktor1 on port 8080
*/

docker run --name docker-ktor1 -p 8080:8080 ktor-docker

Wow, we were able to run our Ktor app with Docker!!🎉

Adding Nginx for Load Balancing and Reverse Proxy With Docker

Nginx, pronounced like “engine-ex”, is an open-source web server that, since its initial success as a web server, is now also used as a reverse proxy, HTTP cache, and load balancer.

We will make a folder nginx outside src. You can see the folder structure below.

Create a file with the namenginx.conf and write it with the below code. In the server{} block, we are porting it to 9090 and we are basically using location{} block, we are routing it to all the list of servers with the Round Robin Algorithm we are assuming having two instances of our Ktor server running at port 8181 and 8282 . Hence working as load balancing and also hiding the actual server location since the user will hit the link with 9090 .

Let's add Docker to help us set up our Nginx server, we will create a new Dockerfile inside the nginx folder.

use these commands to run, as explained above in the Ktor section to build and run inside ./nginx . After running this you will find a new server running in your Docker Desktop on port 9090

docker build -t nginx-docker .

docker run --name docker-nginx1 -p 9090:9090 nginx-docker

Yes, we were able to run our Nginx server with Docker, ie if you hi port `9090` you will get data from `8181` and `8282`🎉

Combine Server and Nginx together to docker-compose.yml

You can think of this as a script to run our servers in a proper way. Here we will try to run two servers running on ports 8181 & 8282 , Nginx running 9090 which will help in reverse proxy and load balancing.

We will have to add a file docker-compose.ymal at the base of the project. You can see the folder structure below.

We have added this docker-compose.yml , this file is easy to understand we are starting nginx-server:9090 which depends on 2 instances of our Ktor server service1 & service2 which is mapped to port 8181 & 8282 .

make a small change in nginx.conf we have to specify the service1 & service2 it is a small change.

We can finally get all of these syncs and start our servers together with two commands

docker-compose build

docker-compose up

Finally, we are able to start our servers and all synced if you open your Docker Desktop and your Browser you will see this.🎊

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Recent Post

• Replacing Retrofit with Ktor Client and Kotlin Serialization for Android🐱‍🏍
• Detect Swipe Direction on Jetpack Compose to trigger BottomSheetScaffold
• Media3 ExoPlayer in Jetpack Compose to make Snapchat Spotlight
• Adding Google Map in Jetpack Compose 🗺📌- Using AndroidView And android-maps-compose

Build Ktor Project with Docker and Add Nginx for Load Balancing & Reverse Proxy was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.

In my recent project, I was trying to add BottomSheet which gets triggered when the user creates a gesture of upwards swipe as you see in Snapchat Memories, where the camera works in the background and on upwards swipe we open the bottom sheet. Here is the outcome.

We will be using BottomSheetScaffold here which is ideal for this use case.

In Jetpack Compose, we have two types of bottom sheets, the BottomSheetScaffold and the ModalBottomSheetLayout.

- BottomSheetScaffold doesn’t block the screen’s main UI when it appears, and you can view and interact with both (main UI and bottom sheet) simultaneously. Also, you can set a peak height to show part of the bottom sheet all the time.

- ModalBottomSheetLayout acts like a popup view. It shows up when you press a button and blocks any interaction with the rest of the screen.

Adding BottomSheetScaffold to Compose✨

I will show you how I used it, Initially, I had a Scaffold which I wrapped with BottomSheetScaffold . We have to pass two crucial bottomSheetScoffoldState and scopewhich is used to manage the sheet's state and give the coroutine scope respectively. These are passed around to collapse or expand the bottom sheet. You can see in the image below that I have passed it to the Naviagtion composable and which in turn is passed to the CamaraScreen .

BottomSheetScafflod parameters

sheetContent - as the name suggests they provides with the content for the bottomsheet. In my case it was the MemoriesScreen.
scaffoldState - takes the bottomSheetScaffoldState defined above.
sheetShape - It is used to provide shape to the bottom sheet
sheetBackgroundColor -  as the name suggests
sheetPeekHeight - It is added to make the sheet invisible initally, since BottomSHeetScaffold have a default peek value. 

Gesture Detection In Compose✨

Now coming to the important part is how to detect the swipe and trigger the bottom sheet to expand. We have already passed the bottomSheetScaffoldState and scope to the CamaraScreen .

We have to add a new modifier to the Surface which is pointerInput() inside it we will set the detectDragGesture{} in which we get the directions based on the x and y locations which helps us to detect the direction of the swipe. Based on these inputs we will trigger the bottom sheet open and close in the main screen by changing the state.

pointerInput - Create a modifier for processing pointer input within the region of the modified element.

detectDragGestures - Gesture detector that waits for pointer down and touch slop in any direction and then calls onDrag for each drag event. It follows the touch slop detection of awaitTouchSlopOrCancellation but will consume the position change automatically once the touch slop has been crossed.

onDrag: (PointerInputChange, Offset) → Unit
OnDrag have two parameter which i have changed to change and dragAmount. This dragAmount  gives us the x and y which helps us to detect the swipe. change.comsume() consumes change event, claiming all the corresponding change info to the caller. This is usually needed when, button, when being clicked, consumed the "up" event so no other parents of this button could consume this "up" again.

If you want to video the whole code of the project you can refer here

GitHub - Debanshu777/Compose-Snapchat-Clone: Snapchat Clone with Jetpack Compose and Clean Architecture - Navigation Components, CamaraX, android-maps-compose, Exoplayer, Detekt, Coil, Gradle Secrets, Permission Handling.

Finally, you have done it wow added a swipe gesture bottom Sheet in your Compose App like Snapchat Memories!!🎉

For any doubts and suggestions, you can reach out on my Instagram, or LinkedIn. Follow me for Kotlin content and more. Happy Coding!

I will well appreciate one of these 👏

Recent Post

• Media3 ExoPlayer in Jetpack Compose to make Snapchat Spotlight
• Adding Google Map in Jetpack Compose 🗺📌- Using AndroidView And android-maps-compose
• Using Webview in Jetpack Compose and enforce Dark Mode
• Replacing Retrofit with Ktor Client and Kotlin Serialization for Android🐱‍🏍

Detect Swipe Direction on Jetpack Compose to trigger BottomSheetScaffold was originally published in Backyard Programmers on Medium, where people are continuing the conversation by highlighting and responding to this story.