DEV Community: Shan

🔧 Flutter Clean Architecture - Fast Feature-First Setup Guide

Shan — Sun, 06 Jul 2025 10:05:26 +0000

📘 Note: This is a fast and simple setup guide for structuring Flutter projects using Clean Architecture with a feature-first approach. It is consolidated from multiple references and shaped by practical experience in real projects. Intended for quick implementation. This is how i structure and work on projects.

🧪 Step-by-Step Plan

1. Analyze the Figma Design

Review the Figma design thoroughly.
Identify all distinct features based on the UI/UX.
Each feature should be represented as a folder inside the features/ directory.

2. Define API Properties per Feature

For each feature, identify the API endpoints it depends on.
Extract only the necessary properties from each API response (avoid using the entire response).

3. Create the `features/` Folder

Add a subfolder for each feature inside features/.
Each feature will contain its own:
- data/
- domain/
- presentation/

4. Create Data Models (DTOs)

Define models inside features/<feature>/data/models/.
Deserialize only the fields needed from the API.
Add a toEntity() method to convert the model to its corresponding entity.

5. Define the Entity Object

Place entity classes inside features/<feature>/domain/entities/.
These classes:
- Contain business logic
- Do not contain fromJson / toJson
Add validation and domain-level calculations here.

6. Create the Data Source Layer

Inside features/<feature>/data/datasources/:
- Define an abstract class (e.g., UserRemoteDataSource)
- Implement a concrete class (e.g., UserRemoteDataSourceImpl) using http
This layer returns models, not entities.
Optionally, support local data sources (Hive, SharedPreferences, etc.).

7. Create the Repository Layer

Define an abstract repository in features/<feature>/domain/repositories/.
- Return entities, not models.
Implement the repository in data/repositories/:
- Use the data source abstract class, not concrete one [0].
- Optionally use multiple data sources.
- Use try/catch for error handling.
- Return results using the Result pattern [2].

8. Create the Use Cases Layer

Inside features/<feature>/domain/usecases/, define use case classes.
Each use case:
- Performs one responsibility
- Depends on the repository abstract class
- Returns either entities or Result

9. Create the Presentation Layer

Inside features/<feature>/presentation/:
- Add ui/ (screens, widgets)
- Add controllers/ (ViewModels, BLoC, etc.)
Separate screens and controllers for each UI if needed.
Use internationalization for all labels and strings.

10. Create Shared and Core Folders

Outside features/, create:
- shared/: Shared features.
- core/: constants, error handling, API clients, utilities
These folders hold reusable components for the entire app.

🔁 Example Folder Structure

lib/
├── core/
│   └── (helpers, utils, constants, etc.)
├── shared/
│   └── (shared features)
├── features/
│   ├── <feature_name>/
│   │   ├── data/
│   │   │   ├── models/
│   │   │   ├── datasources/
│   │   │   └── repositories/
│   │   ├── domain/
│   │   │   ├── entities/
│   │   │   ├── repositories/
│   │   │   └── usecases/
│   │   └── presentation/
│   │       ├── ui/
│   │       └── controllers/

📚 References

Create Flavors for Flutter App - iOS

Shan — Sat, 13 Apr 2024 20:33:03 +0000

Note: If you're new to Flutter and find it tricky to sift through many resources on setting up flavors, this article is for you. Experienced Flutter developers might already be familiar with this so please feel free to skip this. If you just want to have a quick refresh then you can go through the videos 😁.

Note: It's better to save this for later reference.

Have you ever wanted to manage different versions of your Flutter app for different needs? 'Flavors' in Flutter help you do just that. They're similar to 'build configurations' in iOS. Using flavors, you can create a production version of your app for real users, a staging version for debugging, and a preview version for QA testing — all from the same code base.

To know more about 'Flavors' please go through the official documentation here.

Environment set up

Prerequisites:
- Xcode installed
- An existing Flutter project

Creating flavors in iOS

Open your project in Xcode by going to the iOS folder and double-clicking on the Runner.xcworkspace file. This action will launch Xcode for your project.

Step 2

The second step would be to define schemes. Select Product > Scheme > New Scheme from the menu to add a new Scheme.

A scheme describes how Xcode runs different actions. In this article we will define two schemes staging and production.

Step 3

Let's duplicate the existing build configurations to create separate configurations for different flavors. This process involves replicating the default configurations and appending "staging" and "production" as a suffix.

Step 4

Let's now edit the staging and production schemes to align with the newly created build configurations. Similarly, map the newly created build configurations to the production scheme.

Step 5

Now that we've got our staging and production flavors ready, we can assign different bundle identifiers for each.

Give it a shot—assign the bundle identifier for the production flavor yourself! 😁

Step 6

In the Build Settings, set the Product Name value to match each flavor. For example, add Todo Staging. For those unfamiliar, the product name in Xcode refers to the name of the app as it appears in the App Store and on devices once it's installed. Also we will be using this product name in the next step.

Oops! no video for production😌. Please try to do it yourself!

Step 7

Add the display name to Info.plist. Update the Bundle Display Name value to $(PRODUCT_NAME). When we set the Bundle Display Name to $(PRODUCT_NAME), Xcode dynamically replaces it with the actual product name of our app during the build process.

Step 8

Now it's time to setup our app icon for our staging flavor. When we create your project from a template, it automatically includes a default asset catalog (Assets.xcassets) that contains the AppIcon.

If we don’t have a default asset catalog or existing AppIcon or we want to add another, we can add an app icon to an asset catalog manually:

In the Project navigator, select an asset catalog.
Click the Add button (+) at the bottom of the outline view.
In the pop-up menu, choose OS variant > OS variant App Icon. Xcode creates a new app icon set or image stack with the name AppIcon.

Step 9

Now that we've created the asset catalog, it's time to add the icons. To ensure compatibility with all the sizes specified in Xcode, we'll need to generate icons for each size. I typically use an app icon generator like appicon.co for this.

Once you've generated the icons, simply download them and then either drag and drop them directly into the new staging asset catalog in Xcode or into the designated folder, following the steps outlined in the video.

Next, we'll need to associate the build configuration with the newly created app icon set name.

Please follow the same steps for production as well.

Step 10

"Hurray 🎉! We're almost done. Now it's time to test the changes we've made so far.

In Android Studio, add flavor configurations for both staging and production, as shown in the screenshot below:

Let's try running the staging app. If everything works fine, you should see the app installed on your emulator, similar to the screenshot below.

The Art of Inferring with Large Language Models

Shan — Tue, 23 May 2023 20:03:16 +0000

Note: This is a documented version of ChatGPT Prompt Engineering for Developers course. You can find the course here.

Inferring is a powerful tool that can be used to extract meaning from text. It can be used to understand customer feedback, to identify trends in social media.

Here are some examples of how inferring can be used in prompt engineering:

Sentiment analysis: Inferring can be used to identify the sentiment of a piece of text, such as whether it is positive, negative, or neutral. This can be used to understand customer feedback, identify trends in social media, and generate new ideas.

Eg: We can use sentiment analysis to categorize playstore reviews into positive, negative, or neutral reviews. This will help us to prioritise the issues mentioned in the reviews and identify the issues that need to be addressed. This will allow the customer support team to quickly identify and resolve issues, and the engineers to focus on fixing high priority bugs.

Topic modeling: Inferring can be used to identify the topics of a piece of text. This can be used to understand the content of a document, identify patterns in data, and generate new ideas.

Named entity recognition: Inferring can be used to identify named entities in a piece of text, such as people, places, and organizations. This can be used to understand the context of a document, identify potential customers, and generate new ideas.

For example, if you are running an e-commerce website and you have received reviews from consumers who have purchased from your website, you can use a large language model (LLM) to analyse the reviews and identify named entities, such as the shop name and product name. This information can then be used to improve the customer experience, such as by recommending similar products or providing customer support.

Section from the course starts here:

*In this article we will infer sentiment and topics from product reviews and news articles. *

lamp_review = """
Needed a nice lamp for my bedroom, and this one had \
additional storage and not too high of a price point. \
Got it fast.  The string to our lamp broke during the \
transit and the company happily sent over a new one. \
Came within a few days as well. It was easy to put \
together.  I had a missing part, so I contacted their \
support and they very quickly got me the missing piece! \
Lumina seems to me to be a great company that cares \
about their customers and products!!
"""


What is the sentiment of the following product review, 
which is delimited with triple single quotes?

Review text: '''{lamp_review}'''

Output:

As you can see from the screenshot it's a long output. We can ask the LLM to either output positive / negative as keywords.

"""
What is the sentiment of the following product review, 
which is delimited with triple single quotes?

Give your answer as a single word, either "positive" \
or "negative".

Review text: '''{lamp_review}'''
"""

Output:

we can ask an LLM to identify the emotions that the writer of a review is expressing. We can also ask the LLM if the writer is expressing any anger in their review. Additionally, we can ask the LLM to identify the company name and product name from the review. All of these tasks can be performed in a single prompt.

"""
Identify the following items from the review text: 
- Sentiment (positive or negative)
- List all the emotions expressed in the review not more than 5
- Is the reviewer expressing anger? (true or false)
- Item purchased by reviewer
- Company that made the item

The review is delimited with triple backticks. \
Format your response as a JSON object with \
"Sentiment", "Anger", Emotions, "Item" and "Brand" as the keys.
If the information isn't present, use "unknown" \
as the value.
Make your response as short as possible.
Format the Anger value as a boolean.

Review text: '''{lamp_review}'''
"""

Next topic in the course topic analysis 🙃.

Inferring can be used to identify the topics of a piece of long text.

story = """
In a recent survey conducted by the government, 
public sector employees were asked to rate their level 
of satisfaction with the department they work at. 
The results revealed that NASA was the most popular 
department with a satisfaction rating of 95%.

One NASA employee, John Smith, commented on the findings, 
stating, "I'm not surprised that NASA came out on top. 
It's a great place to work with amazing people and 
incredible opportunities. I'm proud to be a part of 
such an innovative organization."

The results were also welcomed by NASA's management team, 
with Director Tom Johnson stating, "We are thrilled to 
hear that our employees are satisfied with their work at NASA. 
We have a talented and dedicated team who work tirelessly 
to achieve our goals, and it's fantastic to see that their 
hard work is paying off."

The survey also revealed that the 
Social Security Administration had the lowest satisfaction 
rating, with only 45% of employees indicating they were 
satisfied with their job. The government has pledged to 
address the concerns raised by employees in the survey and 
work towards improving job satisfaction across all departments.
"""

Determine five topics that are being discussed in the \
following text, which is delimited by triple backticks.

Make each item one or two words long. 

Format your response as a list of items separated by commas.

Text sample: '''{story}'''

As you can see from the output we got different topics in the article that we gave to the LLM. This information can be used to recommend articles to users who are interested in those topics.

For example, Suppose if a user is subscribed to the topics "java, javascript, and AI," and the user wants to only receive article suggestions based on his/her subscription the LLM can be used to identify the topic and we could create a service that will send notifications when a new article on any of those topic comes.

Output:

Iterative Prompt Development: Iteratively analyse and refine your prompts

Shan — Sun, 21 May 2023 13:07:43 +0000

Note: This is a documented version of ChatGPT Prompt Engineering for Developers course. You can find the course here.

Note: This article is pretty boring. I have added a general summary here for all those who don't have time to read this.

In this article, we will see how to iteratively analyse and refine prompts to generate marketing copy from a product fact sheet. We will start with a simple prompt that generated a long, rambling text. We then iteratively will refine the prompt to limit the number of words, focus on the relevant details, and include the product IDs. Finally, we will add a table of dimensions. By following this iterative approach, we will be able to generate a concise and polished output that meets the needs of the marketing team. This is based on the example that is mentioned in the course.

Note: Before reading this please try to read two another articles which is part of this course. It will give you a general guidelines on how to interact with LLM in a better way.

Note: In this Article, you'll learn how to iteratively analyse and refine prompts.

We will iteratively analyse and refine our prompts to generate marketing copy from a product fact sheet.

fact_sheet_chair = """
OVERVIEW
- Part of a beautiful family of mid-century inspired office furniture, 
including filing cabinets, desks, bookcases, meeting tables, and more.
- Several options of shell color and base finishes.
- Available with plastic back and front upholstery (SWC-100) 
or full upholstery (SWC-110) in 10 fabric and 6 leather options.
- Base finish options are: stainless steel, matte black, 
gloss white, or chrome.
- Chair is available with or without armrests.
- Suitable for home or business settings.
- Qualified for contract use.

CONSTRUCTION
- 5-wheel plastic coated aluminum base.
- Pneumatic chair adjust for easy raise/lower action.

DIMENSIONS
- WIDTH 53 CM | 20.87”
- DEPTH 51 CM | 20.08”
- HEIGHT 80 CM | 31.50”
- SEAT HEIGHT 44 CM | 17.32”
- SEAT DEPTH 41 CM | 16.14”

OPTIONS
- Soft or hard-floor caster options.
- Two choices of seat foam densities: 
 medium (1.8 lb/ft3) or high (2.8 lb/ft3)
- Armless or 8 position PU armrests 

MATERIALS
SHELL BASE GLIDER
- Cast Aluminum with modified nylon PA6/PA66 coating.
- Shell thickness: 10 mm.
SEAT
- HD36 foam

COUNTRY OF ORIGIN
- Italy
"""

Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
triple hyphen.

Technical specifications: ---{fact_sheet_chair}---

As the prompt is bit big. When I unleashed this on GPT-3, it erupted with a whopping 369 words!😁. I won't be sharing the output here as it's a long text. To limit the number of words to certain limit we can tell GPT to generate at most x amount of words.

The new prompt will be:

Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
triple hyphen.

Use at most 50 words.

Technical specifications: ---{fact_sheet_chair}---

In this prompt we are mentioning the number of words to GPT to limit the output.

Issue 2 of the generated output: Text focuses on the wrong details.


Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
triple hyphen.

The description is intended for furniture retailers, 
so should be technical in nature and focus on the 
materials the product is constructed from.

Use at most 50 words.

Technical specifications: ---{fact_sheet_chair}---

Here in this prompt we are asking the model to focus on the aspects that are relevant to the intended audience. Here we need to generate the description for furniture retailers.

Output:

We can further improve this prompt to attach the product ids in the description. The updated prompt will be:

"""
Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
triple hyphen.

The description is intended for furniture retailers, 
so should be technical in nature and focus on the 
materials the product is constructed from.

At the end of the description, include every 7-character 
Product ID in the technical specification.

Use at most 50 words.

Technical specifications: ---{fact_sheet_chair}---
"""

Output:

Issue 3 - Description needs a table of dimensions

We can ask the model to generate a table for us along with the description. Here we will be generating a table of dimensions.

Your task is to help a marketing team create a 
description for a retail website of a product based 
on a technical fact sheet.

Write a product description based on the information 
provided in the technical specifications delimited by 
triple hyphen.

The description is intended for furniture retailers, 
so should be technical in nature and focus on the 
materials the product is constructed from.

At the end of the description, include every 7-character 
Product ID in the technical specification.

After the description, include a table that gives the 
product's dimensions. The table should have two columns.
In the first column include the name of the dimension. 
In the second column include the measurements in inches only.

Give the table the title 'Product Dimensions'.

Format everything as HTML that can be used in a website. 
Place the description in a <div> element.

Technical specifications: ---{fact_sheet_chair}---

Output generated is in HTML. I am not going to add the screenshot here as the output is a bit long. You can copy and paste this prompt to know how the output will look like.

Here is another example of how the iterative approach can be used to improve the quality of generated outputs. Let's say you want to write a poem about a flower. Your first prompt might be something like this:

Write a poem about a flower.

This prompt is too general and will likely result in a poem that is not very specific or creative. To improve the prompt, you could add more details about the flower, such as its colour, shape, or smell. You could also specify the tone of the poem, such as whether you want it to be happy, sad, or reflective.

Write a happy poem about a red lily.

This prompt is more likely to result in a poem that is both specific and creative. Once you have written the poem, you can then evaluate it and see if it meets your needs. If not, you can iterate on the prompt and try again until the desired output is achieved.

Principle 2 of Writing Effective Prompts for Large Language Models: Give Them Time to Think

Shan — Sat, 20 May 2023 05:42:14 +0000

Note: This is a documented version of ChatGPT Prompt Engineering for Developers course. You can find the course here.

Note: In this Article, you'll practice one prompting principle and it's related tactics in order to write effective prompts for large language models. You can view my previous article here.

Principle 2: Give the model time to “think”.

Large language models can make reasoning errors by rushing to an incorrect conclusion. This can happen if the model is given a task that is too complex or if it is not given enough time to consider all of the evidence. To prevent this, you can reframe the query to request a chain or series of relevant reasoning. This will help the model to slow down and consider all of the evidence before drawing a conclusion. Just like humans, large language models can make mistakes if they are rushed or given too much to do. Instructing the model to think longer about a problem can help to improve its accuracy.

Here are some tips for reframing a query to request a chain or series of relevant reasoning:

Use the word "explain" or "justify" in your query.
Ask the model to provide evidence to support its conclusion.
Ask the model to consider all of the relevant information.

These are the outputs that were generated for the same question asked in different ways.

Tactic 1: Specify the steps required to complete a task

text = """
In a charming village, siblings Jack and Jill set out on \ 
a quest to fetch water from a hilltop \ 
well. As they climbed, singing joyfully, misfortune \ 
struck—Jack tripped on a stone and tumbled \ 
down the hill, with Jill following suit. \ 
Though slightly battered, the pair returned home to \ 
comforting embraces. Despite the mishap, \ 
their adventurous spirits remained undimmed, and they \ 
continued exploring with delight.
"""

prompt_1 = """
Perform the following actions: 
1 - Summarise the following text delimited by triple \
hyphen with 1 sentence.
2 - Translate the summary into French.
3 - List each name in the French summary.
4 - Output a json object that contains the following \
keys: french_summary, num_names.

Separate your answers with line breaks.

Text:
---{text}---
"""

In this prompt we are specifying all the steps that should be performed by the model before arriving at a conclusion.
As seen from the screenshot, the model provided a clear and concise answer for our query.

Let us try to give another prompt that will give us a more structured output.

text = """
In a charming village, siblings Jack and Jill set out on \ 
a quest to fetch water from a hilltop \ 
well. As they climbed, singing joyfully, misfortune \ 
struck—Jack tripped on a stone and tumbled \ 
down the hill, with Jill following suit. \ 
Though slightly battered, the pair returned home to \ 
comforting embraces. Despite the mishap, \ 
their adventurous spirits remained undimmed, and they \ 
continued exploring with delight.
"""

Your task is to perform the following actions: 
1 - Summarise the following text delimited by 
  <> with 1 sentence.
2 - Translate the summary into French.
3 - List each name in the French summary.
4 - Output a json object that contains the 
  following keys: french_summary, num_names.

Use the following format:

Summary: summary
Translation: summary translation
Names: list of names in Italian summary
Output JSON: json with summary and num_names

Text: <{text}>

As seen from the screenshot the output is now more structured and follows a format.

Output:

Tactic 2: Instruct the model to work out its own solution before rushing to a conclusion

Determine if the student's solution is correct or not.

Question:
I'm building a solar power installation and I need \
 help working out the financials. 
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost \ 
me a flat $100k per year, and an additional $10 / square \
foot

What is the total cost for the first year of operations 
as a function of the number of square feet.

Student's Solution:

Let x be the size of the installation in square feet.
Costs:
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000

This prompt will give the output as the student's answer is correct but the answer is wrong because the calculation "100,000 + 100x" is wrong it should be "100,000 + 10x". So the answer should be "360x + 100,000".

Output:

To get the correct output we need to ask the model to first generate it's own answer and then compare the answer with the student's answer. Here we asking the model to do it's own analysis on the question and generate an answer for us.

To solve the problem do the following:
- First, work out your own solution to the problem. 
- Then compare your solution to the student's solution 
and evaluate if the student's solution is correct or not. 
Don't decide if the student's solution is correct until 
you have done the problem yourself.

Use the following format:
Question:
----
question here
----

Student's solution:
----
student's solution here
----

Actual solution:
----
steps to work out the solution and your solution here
----

Is the student's solution the same as actual solution \
just calculated:
---
yes or no
---

Student grade:
---
correct or incorrect
----

Question:
""""
I'm building a solar power installation and I need help \
working out the financials. 
- Land costs $100 / square foot
- I can buy solar panels for $250 / square foot
- I negotiated a contract for maintenance that will cost \
me a flat $100k per year, and an additional $10 / square \
foot
What is the total cost for the first year of operations \
as a function of the number of square feet.
""""
Student's solution:
""""
Let x be the size of the installation in square feet.
Costs:
1. Land cost: 100x
2. Solar panel cost: 250x
3. Maintenance cost: 100,000 + 100x
Total cost: 100x + 250x + 100,000 + 100x = 450x + 100,000
""""
Actual solution:

Output:

This is an example of how asking the model to do a calculation itself and breaking down the task into steps to give the model more time to think can help you
get more accurate responses. Here i am using hyphen and triple double quotes as delimiters. You can use any delimiters as you like.

To improve the accuracy and quality of the responses from large language models, it is important to give them time to "think". This can be done by reframing your query to request a chain or series of relevant reasoning, or by instructing the model to work out its own solution before rushing to a conclusion. Additionally, it is important to be as specific as possible in your queries, use natural language, use keywords, and be patient when waiting for a response.

Writing Effective Prompts for Large Language Models: Two Prompting Principles and Their Related Tactics

Shan — Fri, 19 May 2023 18:42:11 +0000

Note: This is a documented version of ChatGPT Prompt Engineering for Developers course. You can find the course here.

Note: In this Article, you'll practice one prompting principle and it's related tactics in order to write effective prompts for large language models. I will create another article on principle 2.

Prompting Principles

Principle 1: Write clear and specific instructions.
Principle 2: Give the model time to “think”.

Tactic 1: Use delimiters to clearly indicate distinct parts of the input.

Delimiters can be anything like:

Triple Quotes: ''' '''

Triple Backticks:```

Triple Dashes: --- ---

Angle Brackets: <>

Xml Tags: <tag> </tag>

For example:


text = """
You should express what you want a model to do by \ 
providing instructions that are as clear and \ 
specific as you can possibly make them. \ 
This will guide the model towards the desired output, \ 
and reduce the chances of receiving irrelevant \ 
or incorrect responses. Don't confuse writing a \ 
clear prompt with writing a short prompt. \ 
In many cases, longer prompts provide more clarity \ 
and context for the model, which can lead to \ 
more detailed and relevant outputs.
"""

prompt = """
Summarise the text delimited by angle brackets\ 
into a single sentence.
<text>
"""

Output that i got after giving this prompt to chat GPT.

Tactic 2: Ask for a structured output

JSON, HTML

"""
Generate a list of three made-up book titles along \ 
with their authors and genres. 
Provide them in JSON format with the following keys: 
book_id, title, author, genre.
"""

This prompt will generate the output in json format. If we change the value JSON to HTML then the output will be in HTML format.

JSON

{
"books": [
{
"book_id": 1,
"title": "The Secret Garden",
"author": "Emily Greenfield",
"genre": "Children's Fiction"
},
{
"book_id": 2,
"title": "Midnight Shadows",
"author": "Jacob Nightfall",
"genre": "Thriller"
}
]
}

For those who don't know what is JSON and HTML it is fine. HTML is a markup language used for structuring and presenting web content, while JSON is a data interchange format used for storing and exchanging structured data.

Tactic 3: Ask the model to check whether conditions are satisfied

text_1 = """
Making a cup of tea is easy! First, you need to get some \ 
water boiling. While that's happening, \ 
grab a cup and put a tea bag in it. Once the water is \ 
hot enough, just pour it over the tea bag. \ 
Let it sit for a bit so the tea can steep. After a \ 
few minutes, take out the tea bag. If you \ 
like, you can add some sugar or milk to taste. \ 
And that's it! You've got yourself a delicious \ 
cup of tea to enjoy.
"""
prompt = """
You will be provided with text delimited by triple quotes. 
If it contains a sequence of instructions, \ 
re-write those instructions in the following format:

Step 1 - ...
Step 2 - …
…
Step N - …

If the text does not contain a sequence of instructions, \ 
then simply write \"No steps provided.\"

\"\"\"{text_1}\"\"\"
"""

Output:

An effective use case for this tactic involves providing a code snippet that encompasses essential business logic, and subsequently leveraging AI to verify the comprehensive handling of all conditions within the code.

text_2 = """
The sun is shining brightly today, and the birds are \
singing. It's a beautiful day to go for a \ 
walk in the park. The flowers are blooming, and the \ 
trees are swaying gently in the breeze. People \ 
are out and about, enjoying the lovely weather. \ 
Some are having picnics, while others are playing \ 
games or simply relaxing on the grass. It's a \ 
perfect day to spend time outdoors and appreciate the \ 
beauty of nature.
"""
prompt = """
You will be provided with text delimited by triple quotes. 
If it contains a sequence of instructions, \ 
re-write those instructions in the following format:

Step 1 - ...
Step 2 - …
…
Step N - …

If the text does not contain a sequence of instructions, \ 
then simply write \"No steps provided.\"

\"\"\"{text_2}\"\"\"
"""

In this example you can clearly see there are not tasks mentioned in the text. Since there are not steps we need to get "No steps provided." as the output.

Output:

Tactic 4: "Few-shot" prompting

prompt = """
Your task is to answer in a consistent style.

<child>: Teach me about patience.

<grandparent>: The river that carves the deepest \ 
valley flows from a modest spring; the \ 
grandest symphony originates from a single note; \ 
the most intricate tapestry begins with a solitary thread.

<child>: Teach me about resilience.
"""

This tactic involves training the model with successful examples of tasks and subsequently requesting the model to perform a specific task based on the provided examples.

In conclusion, Principle 1 emphasizes the significance of providing clear and specific instructions to ChatGPT in order to achieve desired outputs. By expressing instructions in a precise manner, we guide the model towards the intended outcome and minimize the risk of irrelevant or incorrect responses. This principle emphasizes that clarity should not be compromised for the sake of brevity, as longer prompts can provide additional context and enhance the quality of the model's responses. When crafting prompts, it is essential to focus on writing instructions that are as explicit as possible, leaving no room for ambiguity. Following Principle 1 ensures that we harness the full potential of ChatGPT and obtain detailed and relevant outputs that align with our expectations.

AI Industry Shakeup: Massive Announcements from Top Companies Signal a New Era of Innovation

Shan — Sun, 14 May 2023 06:40:00 +0000

This week has been a game-changer for the AI industry, with major announcements from a wide range of companies, including OpenAI, Warren Buffet, Microsoft, AMD, Palantir, Tesla, Meta, Humane, IBM, Wendy's, Google, HuggingFace, Scale AI, Synthesia, Anthropic, and Stability AI.

These announcements are significant and have the potential to shape the future of AI. Each company's announcement has unique importance, and understanding them is crucial for anyone interested in the AI industry.

Overall, this week's announcements indicate that AI is rapidly evolving and becoming more integrated into our lives. From advances in language processing and computer vision to increased investment in AI research, the industry is moving at a fast pace, and these announcements demonstrate the importance of keeping up with the latest developments.

OPEN AI

OpenAI has recently made headlines again with the launch of their latest groundbreaking project. The company has released the research and code for their state-of-the-art text-to-3D model, called Shap-E. They have made the code open source and is available here.

Google

PaLM 2

This week, Google has made waves in the AI community with the release of PaLM 2, the latest iteration of its advanced language learning model. Since its launch in August 2022, developers have been utilizing the PaLM API to create various generative AI applications, including chatbots and content generation. With PaLM 2, Google aims to push the boundaries of what its predecessor achieved, boasting a more lightweight and easily deployable model, as well as more advanced technical capabilities

To know more about PaLM 2 checkout this page.

Bard

Google's rush to compete with the success of ChatGPT led to the release of their own chatbot, Google Bard, before it was fully prepared to deliver substantial value to users. However, with an upgrade to PaLM 2, Bard's capabilities have significantly improved, including enhanced coding abilities and support for more languages. Furthermore, upcoming features such as visual responses, integration with Google Lens, and extensions with external partners, demonstrate Google's continued commitment to advancing the capabilities of its AI chatbot.

To learn more and to try bard, check out this page.

Google Search's AI integration

Google unveiled its new Search Generative Experience (SGE) at Google I/O, which will provide users with AI-powered snapshots that offer concise and conversational answers to any search query. The SGE will also help users make shopping decisions by presenting them with a table that compares product features, prices, reviews, and more. This move is a smart strategy for Google to leverage its dominance in the search engine market to establish itself as a leader in the AI space.

Google's Push into AI: Generative AI Features Coming to Google Search and Workspace

Google has brought generative AI to its productivity tools such as Gmail, Google Docs, and Slides in a major update to its Google Workspace. The update also includes new AI features in Gmail, Sheets, and Slides that help users with organisation and visualisation. Google Maps and Photos are also getting AI enhancements, such as a bird's eye view of a user's route and an AI-powered photo editing tool. With this AI update, Google has a chance to outperform Microsoft, which has yet to release its own AI revamp to Office 365 apps.

Personalisation to Android Devices

Google announced new personalisation features for Android, enabled by generative AI. Magic Compose in Google messages allows users to add different tones to their messages such as "professional", "funny", and "chill". Android 14 also brings new customisable aspects to the lock screen, while new wallpaper features such as the emoji wallpaper and the cinematic wallpaper will come to Pixel devices next month.

Google unveils Duet AI, a development interface powered by AI for cloud developers

Google has unveiled Duet AI, a development interface powered by AI that assists developers on the Google Cloud platform with code and chat assistance. With AI-driven code completion and generation, the code assistant can identify errors and suggest fixes in real-time. The chat assistant can provide responses to specific cloud questions using simple natural language prompts.

Gemini

At Google I/O, DeepMind introduced Gemini, a new large language model that is currently in its early stages of development. It is expected to be utilized similarly to PaLM 2 and may potentially compete with OpenAI's GPT-4, which is their latest and most advanced language model

Unlocking the Power of JSON Web Tokens: Real-World Applications and Examples

Shan — Thu, 20 Apr 2023 16:47:58 +0000

Introduction

JSON Web Tokens (JWTs) are a popular method for securely transmitting information between parties. JWTs provide a standardized way to represent claims that can be encoded and signed, making them useful for authentication, authorization, and data exchange. In this article, we'll explore what JWTs are, how they work, and some real-world applications of JWTs.

What are JSON Web Tokens?

JSON Web Tokens (JWTs) are a compact and self-contained method for transmitting information between parties. A JWT consists of three parts: a header, a payload, and a signature. The header and payload are Base64Url encoded JSON strings, and the signature is a cryptographic hash of the header, payload, and a secret key.

The header contains metadata about the JWT, such as the algorithm used to sign the token. The payload contains claims, which are statements about an entity and additional data. Claims can be used to represent user information, permissions, or other metadata. The signature is used to verify that the JWT is valid and has not been tampered with.

How do JSON Web Tokens work?

When a user authenticates with a server, the server can issue a JWT containing the user's information and a signature. The JWT can then be transmitted to the client, which can use it to authenticate future requests.

To verify the JWT, the client can decode the header and payload and use the information to verify the signature. If the signature is valid, the JWT is considered authentic and can be used to authorize the user.

Real-world applications of JSON Web Tokens

There are many real-world applications of JWTs, including authentication, authorization, and data exchange. Let's explore some examples of how JWTs are used in practice.

Single Sign-On (SSO)

Single Sign-On (SSO) is a method of authentication that allows users to access multiple applications with a single set of credentials. JWTs can be used to implement SSO by encoding the user's authentication information in a JWT and transmitting it to the client. The client can then use the JWT to authenticate with other applications without requiring the user to re-enter their credentials.

For example, consider a user who wants to access two applications: a website and a mobile app. The user logs in to the website and is issued a JWT containing their authentication information. When the user launches the mobile app, the app can use the JWT to authenticate the user without requiring them to enter their credentials again.

Authorization

JWTs can also be used for authorization, which is the process of determining whether a user has permission to access a particular resource or perform a particular action. In this scenario, the JWT contains claims that specify the user's permissions or roles.

For example, consider an application that allows users to perform different actions based on their role. An admin user might be able to create and delete records, while a regular user can only view records. The application can use JWTs to encode the user's role in the JWT, and verify the JWT to determine the user's permissions.

Data exchange

JWTs can be used for secure data exchange between parties. In this scenario, the JWT contains claims that represent the data being transmitted. The JWT can be signed by the sender to ensure that the data has not been tampered with, and verified by the receiver to ensure that the data is authentic.

For example, consider an e-commerce website that needs to transmit order information to a payment gateway. The website can encode the order information in a JWT and sign it using a secret key. The payment gateway can then verify the JWT to ensure that the order information has not been tampered with, and process the payment accordingly.

An example of how to generate a JSON Web Token (JWT) in JavaScript using the jsonwebtoken library:

const jwt = require('jsonwebtoken');

const payload = { 
  username: 'john_doe',
  email: 'john_doe@example.com',
  isAdmin: true
};

const secret = 'my-secret-key';

const options = {
  expiresIn: '1h',
  algorithm: 'HS256'
};

const token = jwt.sign(payload, secret, options);

console.log(token);

In this example, the jwt.sign function is used to generate a JWT. The payload object contains the claims that will be encoded in the JWT. Claims are statements about the user or entity that the token represents, such as user ID, role, or email address.

The secret string is a shared secret between the client and server that is used to sign and verify the JWT. The options object contains additional options for the JWT, such as the expiration time (expiresIn) and the algorithm used to sign the token (algorithm).

When the jwt.sign function is called, it encodes the claims in the payload and generates a signature using the secret key and algorithm specified in the options. The resulting JWT can be sent to the client for use in subsequent requests.

Now let's talk about claims. Claims are statements about an entity (typically, the user) that can be encoded and signed in a JWT. Claims can contain any information that the server wants to share with the client or vice versa, such as user ID, email address, role, or permissions.

JWTs contain three types of claims: registered claims, public claims, and private claims.

Registered claims are a set of predefined claims that are recommended but not required. Registered claims include iss (issuer), sub (subject), aud (audience), exp (expiration time), nbf (not before), and iat (issued at).

Public claims are custom claims that are defined by the application and are meant to be shared with other parties. Public claims can contain any information that the server wants to share with the client or vice versa.

Private claims are custom claims that are used by the application for its own purposes and are not meant to be shared with other parties. Private claims can contain any information that the server wants to store in the JWT for its own use.

When encoding claims in a JWT, it's important to keep in mind that JWTs are not encrypted and can be decoded by anyone with access to the token. Therefore, sensitive information should not be included in the JWT.

Boost Your Productivity: How to Create and Use Custom Snippets in VS Code

Shan — Sat, 01 Apr 2023 04:25:36 +0000

As a developer, you might find yourself frequently using the same code patterns or syntax. Repeatedly typing out the same code can be tedious and can slow down your workflow. This is where snippets come in handy.

Visual Studio Code (VS Code) provides a built-in feature for defining and using snippets. Snippets are predefined templates of code that you can insert into your code file using a simple keyboard shortcut. In this article, we’ll explore how to create and use snippets in VS Code.

Defining Snippets

VS Code provides an easy way to create and define your own snippets. You can define snippets either for a specific language or for all languages. To create or edit your own snippets, go to the Command Palette by pressing Ctrl+Shift+P (Windows, Linux) or Cmd+Shift+P (macOS), and then search for "Configure User Snippets". Selecting this option will bring up a dropdown menu that allows you to choose a language-specific snippets file or a global snippets file.

Snippets files are written in JSON format, which supports C-style comments, and can define an unlimited number of snippets. Snippets support most TextMate syntax for dynamic behavior and can intelligently format whitespace based on the insertion context.

Let’s look at an example of defining a snippet for a JavaScript for loop:

// in file 'Code/User/snippets/javascript.json'
{
  "For Loop": {
    "prefix": ["for", "for-const"],
    "body": ["for (const ${2:element} of ${1:array}) {", "\t$0", "}"],
    "description": "A for loop."
  }
}

In this example, For Loop is the name of the snippet. It will be displayed via IntelliSense if no description is provided. The prefix property defines one or more trigger words that display the snippet in IntelliSense. Substring matching is performed on prefixes, so in this case, fc could match for-const. The body property is one or more lines of content, which will be joined as multiple lines upon insertion. Newlines and embedded tabs will be formatted according to the context in which the snippet is inserted. Finally, the description property is an optional description of the snippet displayed by IntelliSense.

Additionally, the body of the example above has three placeholders (listed in order of traversal): ${1:array}, ${2:element}, and $0. You can quickly jump to the next placeholder with Tab, at which point you may edit the placeholder or jump to the next one. The string after the colon : (if any) is the default text, for example element in ${2:element}. Placeholder traversal order is ascending by number, starting from one; zero is an optional special case that always comes last and exits snippet mode with the cursor at the specified position.

Using Snippets

Once you’ve defined your snippets, you can start using them in your code. To insert a snippet, simply type the prefix in your code file and press Tab. The snippet will then be inserted into your code with the cursor placed at the first placeholder. You can then use Tab to jump to the next placeholder or use Shift+Tab to jump to the previous one.

For example, if we had the "For Loop" snippet defined as above, we could use it in our JavaScript file by typing for and then pressing Tab. The snippet would be inserted into the code, and we could then fill in the placeholders as needed.

More Detailed Example

If you're interested in using the 'Freezed' package in Flutter, I've created a handy VS Code extension that provides code snippets to speed up your development process. You can find the extension on GitHub at https://github.com/ArkrootHQ/freezed-snippets, and it's completely free to use. If you have any suggestions or ideas for improving the extension, feel free to contribute to the project. Your contributions are always welcome and greatly appreciated!

Here's a quick overview of the snippets currently included in the extension.

{
  "Part statement": {
    "prefix": "pts",
    "body": ["part '${TM_FILENAME_BASE}.g.dart';"],
    "description": "Creates a filled-in part statement"
  },
  "Part 'Freezed' statement": {
    "prefix": "ptf",
    "body": ["part '${TM_FILENAME_BASE}.freezed.dart';"],
    "description": "Creates a filled-in freezed part statement"
  },
  "Freezed Data Class": {
    "prefix": ["fdataclass", "fdc"],
    "body": [
      "@freezed",
      "class ${1:DataClass} with _$${1:DataClass}{",
      "  const factory ${1:DataClass}(${2}) = _${1:DataClass};",
      "}",
      "factory ${1:DataClass}.fromJson(Map<String, dynamic> json)",
      "=> _$${1:DataClass}FromJson(json);"
    ],
    "description": "Freezed Data Class"
  },
  "Freezed Union": {
    "prefix": "funion",
    "body": [
      "@freezed",
      "class ${1:Union} with _$${1:Union}{",
      "  const factory ${1:Union}.${2}(${4}) = ${3};",
      "}"
    ],
    "description": "Freezed Union"
  },
  "Freezed Union Case": {
    "prefix": "funioncase",
    "body": ["const factory ${1:Union}.${2}(${4}) = ${3};"],
    "description": "Freezed Union Case"
  }
}

Here is an explanation of each snippet:

"Part statement": inserts a filled-in "part" statement for the current file.
"Part 'Freezed' statement": inserts a filled-in "part" statement for the generated Freezed file.
"Freezed Data Class": creates a new Freezed data class with a constructor and a "fromJson" factory method.
"Freezed Union": creates a new Freezed union with a specified number of cases.
"Freezed Union Case": inserts a new case into an existing Freezed union.

Conclusion

Snippets are a powerful feature in VS Code that can greatly increase your productivity as a developer. By defining your own snippets, you can save time

Interfaces in typescript

Shan — Fri, 31 Mar 2023 18:55:28 +0000

In TypeScript, interfaces are used to define the shape of an object, including its properties and methods. They serve as a contract that specifies what properties and methods an object should have, without specifying how they should be implemented. In this article, we will explore the use of interfaces in TypeScript with examples.

Defining an Interface

To define an interface in TypeScript, we use the keyword interface, followed by the name of the interface and a pair of curly braces. Inside the curly braces, we specify the properties and methods that should be present in the object that implements this interface. Here is an example:

interface Person {
    firstName: string;
    lastName: string;
    age: number;
    sayHello(): void;
}

In this example, we have defined an interface called Person that specifies that any object that implements this interface must have firstName, lastName, and age properties that are of type string, string, and number, respectively. Additionally, the object must have a sayHello() method that returns void.

Implementing an Interface

To implement an interface, we create a new object and specify the properties and methods that are required by the interface. Here is an example:

class Employee implements Person {
    firstName: string;
    lastName: string;
    age: number;

    constructor(firstName: string, lastName: string, age: number) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    sayHello() {
        console.log("Hello, my name is " + this.firstName + " " + this.lastName);
    }
}

let employee = new Employee("John", "Doe", 30);
employee.sayHello(); // Output: "Hello, my name is John Doe"

In this example, we have created a Person interface, which specifies the properties and methods that should be present in an object that implements this interface. We have also created a class called Employee that implements the Person interface by defining all the required properties and methods.

Using an Interface as a Type

In addition to defining the shape of an object, interfaces can also be used as a type. This allows us to specify that a variable or function parameter should be of a certain type, based on an interface. Here is an example:

function printPerson(person: Person) {
    console.log("Name: " + person.firstName + " " + person.lastName);
    console.log("Age: " + person.age);
    person.sayHello();
}

let employee = new Employee("John", "Doe", 30);
printPerson(employee); // Output: "Name: John Doe", "Age: 30", "Hello, my name is John Doe"

In this example, we have defined a printPerson() function that takes an argument of type Person. We have also created an Employee object and passed it as an argument to the printPerson() function. Since the Employee class implements the Person interface, it is also considered to be of type Person, and the function can be called with an instance of Employee.

Interfaces in TypeScript have several real-world applications, and they are used extensively in the development of software systems. Here are some examples of how interfaces are used in real-world applications.

API Design

When designing an API, interfaces are used to define the data structures that will be used to exchange data between the client and the server. This allows the client and server to agree on the format of the data, making it easier to communicate and reducing the likelihood of errors. For example, consider the following interface that defines the structure of a User object in a social media application:

interface User {
  id: number;
  name: string;
  email: string;
  dateOfBirth: Date;
  gender: 'Male' | 'Female' | 'Other';
}

This interface can be used to define the structure of the JSON data that is sent and received by the API.

Object-oriented Programming

In object-oriented programming, interfaces are used to define contracts that classes must adhere to. This allows classes to be interchangeable, making it easier to write modular and maintainable code. For example, consider the following interface that defines the contract for a Vehicle class:

interface Vehicle {
  startEngine(): void;
  stopEngine(): void;
  accelerate(speed: number): void;
  brake(): void;
}

This interface can be implemented by various classes such as Car, Motorcycle, and Truck, each of which would provide their own implementation of the methods.

Third-party Libraries

Interfaces are also used by third-party libraries to define the structure of their API. This allows developers to use the library in a consistent and predictable manner, reducing the likelihood of errors. For example, the following interface defines the structure of the Moment.js library, which is used to manipulate dates and times in JavaScript:

interface Moment {
  (input?: MomentInput, format?: MomentFormatSpecification, strict?: boolean): Moment;
  format(format: string): string;
  add(amount: MomentInput, unit: MomentUnit): Moment;
  subtract(amount: MomentInput, unit: MomentUnit): Moment;
  isBefore(other: Moment | string | number | Date | (number | string | Date)[]): boolean;
  isAfter(other: Moment | string | number | Date | (number | string | Date)[]): boolean;
  // ...
}

This interface allows developers to use the Moment.js library in a consistent and predictable manner, without having to understand the underlying implementation.

Conclusion

Interfaces in TypeScript are a powerful tool for defining the shape of an object, and specifying the properties and methods that should be present in an object that implements this interface. They allow us to write more robust and maintainable code by enforcing a certain level of type safety. By implementing an interface, we can ensure that our classes conform to a certain shape, and by using an interface as a type, we can specify that a variable or function parameter should be of a certain type, based on an interface.

What are pre-commit hooks and How to use in flutter projects?

Shan — Sat, 11 Mar 2023 07:42:02 +0000

Version control systems (VCS) like Git are essential tools for software development, allowing developers to track changes to their code and collaborate with others. One important feature of Git is the ability to use pre-commit hooks, which are scripts or programs that are run automatically before a commit is made. Pre-commit hooks can be used to perform various checks and validations on the code changes being committed, ensuring that they meet certain standards or requirements.

In this article, we'll discuss what pre-commit hooks are, why they're useful, and how to configure them in a Flutter project. We'll also discuss some examples of pre-commit hooks you can use in your projects.

What is a Pre-Commit Hook?

A pre-commit hook is a script or program that is executed automatically before a commit is made to a VCS. A pre-commit hook aims to check the changes being committed to ensure they meet certain standards or requirements. For example, a pre-commit hook might be used to enforce code style guidelines, prevent certain files from being committed, or check for syntax errors and other issues.

Why use Pre-Commit Hooks?

Pre-commit hooks offer several benefits to software development teams:

Consistency: Pre-commit hooks can enforce consistent coding standards and practices across the entire team, ensuring that all code adheres to the same guidelines.
Error prevention: By running automated checks before commits are made, pre-commit hooks can catch errors and other issues early in the development process, preventing them from being introduced into the codebase.
Time savings: Pre-commit hooks can automate time-consuming tasks such as linting and code formatting, freeing up developers to focus on more important tasks.
Collaboration: Pre-commit hooks can help ensure that all team members are aware of code changes and are able to review them before they are committed.

Configuring Pre-Commit Hooks in a Flutter Project:

Configuring a pre-commit hook in a Flutter project involves creating a script that will be executed before a commit is made, and then configuring Git to run that script automatically. Here are the steps to configure a pre-commit hook in a Flutter project:

Step 1: Create a Pre-Commit Hook Script

The first step is to create a pre-commit hook script that will be run automatically before each commit. This script can be written in any scripting language, but in this article, we'll be using Bash.

Create a file named pre-commit (without any file extension since we are using bash) in the .git/hooks/ directory of your project. If the .git/hooks/ directory does not exist, create it.

Here's an example pre-commit hook script that runs flutter analyze and dart analyze to check for errors in the code:

#!/bin/bash

# Run Flutter analyze and check for errors
if ! output=$(flutter analyze); then
    echo "COMMIT REJECTED: Flutter analyze found the following errors:"
    echo "$output"
    exit 1
fi

# Run Dart analyze and check for errors
if ! output=$(dart analyze); then
    echo "COMMIT REJECTED: Dart analyze found the following errors:"
    echo "$output"
    exit 1
fi

# If we made it this far, the commit is allowed
exit 0

This script runs flutter analyze and dart analyze to check for errors in the code. If either command detects an error, the commit will be rejected.

Step 2: Make the Script Executable

Next, you'll need to make the script executable. To do this, open a terminal and navigate to your Flutter project directory. Then, run the following command:

chmod +x pre-commit

This command gives the pre-commit script executable permissions.

Step 3: Configure Git to Run the Script

The final step is to configure Git to run the pre-commit hook script automatically before each commit. To do this, navigate to your Flutter project directory in a terminal and run the following command:

cd .git/hooks
ln -s ../../pre-commit pre-commit

This command creates a symbolic link to the pre-commit script in the .git/hooks directory, which Git will use to run the script automatically before each commit.

If you have successfully configured a pre-commit hook in your Flutter project and if your codebase has analyzer problems, then you will get an error message indicating that the commit has been rejected.

That's it! You've now configured a pre-commit hook in your Flutter project.

Pre-commit hooks are a powerful tool for ensuring code quality and consistency in your Flutter projects. They can be used to enforce coding standards, catch errors and security vulnerabilities, and automate time-consuming tasks. By following the steps outlined in this article, you can easily configure pre-commit hooks in your own projects and improve your development workflow.

Bonus

You can find an easy to use pre-commit hook here.

What is e2e Testing?

Shan — Tue, 07 Mar 2023 20:46:41 +0000

End-to-end (e2e) testing is a type of software testing that assesses the functionality of a system from start to finish. This type of testing is particularly useful for identifying any issues or problems that may arise when a user interacts with a software application, website or service.

E2e testing can be an important part of the software development lifecycle, particularly for large and complex projects. In this article, we will explore what e2e testing is, why it is important, and some popular tools that can be used for e2e testing.

What is e2e testing?

E2e testing, also known as functional testing, tests the functionality of an application from the user’s perspective. It is designed to simulate real-world scenarios and workflows that a user would typically encounter while using an application. The testing process includes checking for any bugs or errors that may occur during normal usage and ensuring that the system works as expected.

The goal of e2e testing is to ensure that the software application functions correctly from start to finish, including any integrations with external systems or services. E2e testing aims to catch issues before they reach the end-user, reducing the likelihood of user complaints, negative reviews, and ultimately, loss of business.

Examples of e2e testing

To better understand e2e testing, let’s look at some examples of what e2e testing can involve:

Testing an eCommerce site

Imagine an eCommerce site where a customer needs to browse products, add them to their cart, enter their billing and shipping information, and finally make a payment. E2e testing in this scenario would involve simulating these actions and ensuring that the checkout process is smooth, with no issues or errors.

Testing a login page

A login page is a critical part of any web application. E2e testing for a login page would involve verifying that a user can successfully log in using their credentials and that the system handles incorrect login attempts appropriately.

Testing a mobile app

E2e testing for a mobile app would involve testing the app’s features and functionality on various devices and operating systems. The testing process would include scenarios such as logging in, navigating the app, and performing tasks such as making a purchase or booking a reservation.

Tools for e2e testing

There are many tools available for e2e testing, and the choice of tool will depend on several factors, including the programming language used, the type of application being tested, and the team’s experience with testing tools.

Here are some of the most popular e2e testing tools:

Selenium

Selenium is an open-source tool used for testing web applications. It supports various programming languages, including Java, Python, C#, and Ruby. Selenium allows testers to create automated tests that simulate user interactions with a web application, such as clicking on links, filling out forms, and navigating between pages.

Cypress

Cypress is a JavaScript-based testing tool used for testing web applications. It is designed to simplify the process of writing and debugging tests and offers real-time feedback during the testing process. Cypress also allows testers to write tests in an easy-to-understand syntax that closely resembles the syntax of the application being tested.

Appium

Appium is an open-source tool used for testing mobile applications. It supports both Android and iOS platforms and allows testers to write tests in various programming languages, including Java, Python, and Ruby. Appium can also test hybrid and native apps and supports simulators and emulators.

what are the tools used in flutter for e2e testing?

Flutter provides several tools for end-to-end (e2e) testing of mobile applications. These tools allow developers to test their Flutter applications across multiple platforms, including iOS and Android, to ensure that their apps work as expected. In this article, we will discuss some of the commonly used e2e testing tools in Flutter.

Flutter Driver

Flutter Driver is a testing framework provided by Flutter to test the behavior and performance of Flutter applications. It provides a set of APIs for interacting with the application at the widget level, such as tapping buttons, scrolling, entering text, and more. With Flutter Driver, developers can write tests in Dart language, which is the same language used for developing Flutter applications. Flutter Driver also provides support for automated e2e testing using real devices, simulators, or emulators.

Appium

Appium is an open-source testing framework that supports multiple platforms, including iOS, Android, and web. It uses the WebDriver protocol to automate the testing of mobile applications, allowing developers to write tests in a variety of programming languages, including Java, JavaScript, and Python. With Appium, developers can write automated tests that simulate user interactions with their Flutter application, such as tapping buttons, entering text, and scrolling. Appium supports real devices, simulators, and emulators, and it can run tests on multiple devices simultaneously.

DEV Community: Shan

🔧 Flutter Clean Architecture - Fast Feature-First Setup Guide

🧪 Step-by-Step Plan

1. Analyze the Figma Design

2. Define API Properties per Feature

3. Create the features/ Folder

4. Create Data Models (DTOs)

5. Define the Entity Object

6. Create the Data Source Layer

7. Create the Repository Layer

8. Create the Use Cases Layer

9. Create the Presentation Layer

10. Create Shared and Core Folders

🔁 Example Folder Structure

📚 References

Create Flavors for Flutter App - iOS

Environment set up

Creating flavors in iOS

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7

Step 8

Step 9

Step 10

The Art of Inferring with Large Language Models

Iterative Prompt Development: Iteratively analyse and refine your prompts

Principle 2 of Writing Effective Prompts for Large Language Models: Give Them Time to Think

Writing Effective Prompts for Large Language Models: Two Prompting Principles and Their Related Tactics

Prompting Principles

AI Industry Shakeup: Massive Announcements from Top Companies Signal a New Era of Innovation

Unlocking the Power of JSON Web Tokens: Real-World Applications and Examples

Boost Your Productivity: How to Create and Use Custom Snippets in VS Code

Interfaces in typescript

What are pre-commit hooks and How to use in flutter projects?

Bonus

What is e2e Testing?

3. Create the `features/` Folder