When Jara Helmes was a toddler walking with stiff, heavy leg braces, her father made her a lighter, softer pair 3D-printed in her favorite color, pink. When

New mix-and-match computer accessories give people with … – Microsoft

Denali provides software developers with AI-driven assistance and insights for surfacing the best and most applicable security features.

Digital.ai launches Denali to help enterprises automate secure software releases

iCad today announced it sold its Xoft Brachytherapy business line to Elekta for approximately $5.5 million.

iCad sells Xoft brachytherapy business to Elekta

Hey there, crafty peeps! Guess what? I got my hands on the Xtool M1, a desktop laser and blade-cutting machine that's been creating quite a … The post Xtool The Powerful Desktop Laser & Blade Cutting Machine appeared first on Kellys Thoughts On Things.

Xtool The Powerful Desktop Laser & Blade Cutting Machine

I got my hands on the Xtool M1, a desktop laser and blade-cutting machine that's been creating quite a buzz in the DIY world. I'm talking about a laser engraver that's got it all higher power, faster speed,

Personal computer (PC) makers are embracing sustainability as part of their growth strategies by using recyclable materials and packaging.Apart from design and packaging material, US PC manufacturer HP Inc wants to promote circularity to refurbish PCs,

PC makers go green with recyclable content

The machine supports a variety of file formats, including KML files. The control software is mature engraving software that's user-friendly, even for a newbie like me. From different materials like thick wood and acrylic plates to even thicker materials ...

Google reports that malicious actors linked to the Russian and Chinese governments have recently initiated cyberattack campaigns using a WinRAR vulnerability that was addressed in August.

If you haven't updated WinRAR in the past few weeks, do so now

Google says that several state-backed hacking groups have joined ongoing attacks exploiting a high-severity vulnerability in WinRAR, a compression software used by over 500 million users, aiming to gain arbitrary code execution on targets' systems.

Google links WinRAR exploitation to Russian, Chinese state hackers

Launches New Community Led Security Program Improving IT Device Security Posture SAN JOSE, Calif., Oct. -- Today, the Open

Open Compute Project Tackles Data Center Hardware and Firmware Security

Softura

softura

is a cross-platform framework that lets you create fast and beautiful app for mobile, web, and desktop. Flutter aims to provide 60 frames per second (fps) performance, or 120 fps performance on devices capable of 120Hz updates. However, sometimes your app might not run as smoothly as you expect, and you might encounter jank, stutter, or lag. Flutter Jank occurs when the UI doesn’t render smoothly, and animations appear frozen. Every once in a while, a frame takes 10 times longer to render, so it is dropped. Jank can ruin the user experience and make your app look unprofessional. How do you avoid jank and optimize your Flutter app’s performance? Where do you start? What tools can you use? In this article, we will explore some Hacks and best practices for Flutter performance optimization, based on the official documentation and other resources. Hack 1: Run in profile mode on a real device The first Hack for Flutter performance optimization is to run your app in profile mode on a real device. Profile mode is a special mode that runs your app with optimizations similar to release mode, but also enables some performance measurement tools. Profile mode helps you identify potential performance issues and measure the impact of your optimizations. To run your app in profile mode, use the command or select the profile option in your . You can also use the command to create a profile build for your app. flutter run --profile IDE flutter build --profile Running your app on an actual device is important because simulators and emulators don’t use the same hardware as real devices, which leads to differences in their performance. Compared to real devices, some simulator operations are faster, while others are slower. Also, debug mode enables additional checks (such as asserts) that don’t run in profile or release builds, and these checks can be expensive. You should consider checking performance on the slowest device that your users might reasonably use. This way, you can ensure that your app runs smoothly on all devices. Hack 2: Use the performance overlay and other tools The second Hack for Flutter performance optimization is to use the performance overlay and other tools to diagnose performance problems. The performance overlay is a widget that displays two graphs on top of your app’s UI. The graphs show how much time each frame takes to render on the UI thread (top graph) and the raster thread (bottom graph). The raster thread was previously known as the GPU thread. To enable the performance overlay, use the command or press while running your app in profile mode. You can also enable it programmatically using the widget or from the command line using the parameter. flutter run --profile --show-performance-overlay P PerformanceOverlay showPerformanceOverlay The performance overlay helps you identify janky frames by showing spikes in the graphs. Ideally, each frame should take less than 16 ms to render for 60 fps performance. If a frame takes longer than 16 ms, it means that it missed the deadline and caused a jank. You can also use other tools to analyze your app’s performance, such as: A suite of web-based tools that help you inspect, debug, and optimize your Flutter app. You can use DevTools to view various aspects of your app’s performance, such as CPU usage, memory usage, network traffic, widget rebuilds, rendering layers, and more. You can launch DevTools from your IDE or from the command line using the command. Flutter DevTools: flutter pub global run dev-tools : A suite of web-based tools that help you inspect, debug, and optimize your Dart code. You can use Dart DevTools to view various aspects of your code’s performance, such as CPU profiles, memory snapshots, allocation profiles, call trees, flame charts, and more. You can launch Dart DevTools from your IDE or from the command line using the command. Dart DevTools Dart dev-tools A tool that shows a detailed view of all the events that occur when your app renders a frame. You can use Timeline View to see how much time each event takes and how they relate to each other. You can access Timeline View from Flutter DevTools or Dart DevTools. Timeline View: A technique that allows you to add custom events to Timeline View to measure specific parts of your code. You can use tracing to see how long certain functions or operations take and how they affect the overall performance of your app. You can add tracing events using the Timeline class in Dart code or platform-specific APIs in native code. Tracing: Hack 3: Minimize expensive operations The third Hack for Flutter performance optimization is to minimize expensive operations in your code. Expensive operations are those that consume a lot of resources, such as CPU, memory, or network. Some examples of expensive operations are: Layout and rendering are the processes of calculating the size and position of each widget on the screen and drawing them to the display. Layout and rendering can be expensive if you have complex or nested widgets, large or dynamic widgets, or widgets that change frequently. To optimize layout and rendering, you should use simple and flat widgets, avoid unnecessary rebuilds, cache or reuse widgets, and avoid offscreen layers. Layout and rendering: Animation is the process of changing the appearance or position of a widget over time. Animation can be expensive if you have too many or too complex animations, or if you use non-optimized animation techniques. To optimize animation, you should use built-in animation widgets, avoid animating large or expensive widgets, use opacity and clipping sparingly, and use the TransitionBuilder pattern to avoid rebuilding descendants. Animation: Image loading is the process of fetching and decoding image files from the network or device storage. Image loading can be expensive if you have too many or too large images, or if you don’t cache or resize them properly. To optimize image loading, you should use compressed image formats, cache images in memory or disk, resize images to fit the display size, and use placeholders or precaching to improve perceived performance. Image loading: Intrinsic operations are those that depend on the intrinsic size of a widget, such as its natural width or height. Intrinsic operations can be expensive because they require an extra layout pass to calculate the size of the widget before rendering it. Some examples of intrinsic operations are using or widgets, using or widgets with , or using widgets with . To optimize intrinsic operations, you should avoid them whenever possible, use fixed sizes instead of intrinsic sizes, or use alternative widgets that don’t require intrinsic operations. Intrinsic operations: IntrinsicWidth IntrinsicHeight Row Column MainAxisSize.min Text softWrap: true Hack 4: Use lazy loading and pagination The fourth Hack for Flutter performance optimization is to use lazy loading and pagination for your data. Lazy loading is a technique that loads data only when it is needed, instead of loading it all at once. Pagination is a technique that divides data into smaller chunks or pages and loads them one by one as the user scrolls. Lazy loading and pagination can improve your app’s performance by reducing the amount of data that needs to be fetched from the network or the device storage, reducing the memory usage of your app, and reducing the UI complexity of your app. To implement lazy loading and pagination in Flutter, you can use various widgets and plugins, such as: A widget that displays a scrollable list of items. You can use ListView with the constructor to create items lazily as they are scrolled into view. You can also use ListView with the property to listen to scroll events and load more data when the user reaches the end of the list. ListView: builder controller A widget that displays a scrollable grid of items. You can use GridView with the same techniques as ListView to create items lazily and load more data on scroll. GridView: A widget that displays a table of data with pagination controls. You can use PaginatedDataTable with a custom property to fetch data from a remote or local source in pages. PaginatedDataTable: source A plugin that provides a widget and a controller for implementing infinite scrolling pagination with ListView or GridView. You can use Infinite Scroll Pagination with a custom property to fetch data from a remote or local source in pages. Infinite Scroll Pagination: pagingController Hack 5: Use tree shaking for your code The fifth Hack for Flutter performance optimization is to use tree shaking for your code. Tree shaking is a technique that removes unused code from your app’s binary file, reducing its size and improving its startup time. Tree shaking works by analyzing your code and determining which parts are reachable and which parts are not. Only the reachable parts are included in the final output, while the unreachable parts are discarded. This way, you can avoid shipping unnecessary code that never gets executed. Tree shaking can be useful when you have large or optional features in your app that are not needed by all users. For example, you can use tree shaking for: You can remove the language files irrelevant to the user’s locale, instead of including all the supported languages. Localization: You can remove the theme files that are not relevant to the user’s preference, instead of including all the available themes. Themes: You can remove the feature modules that are not relevant to the user’s action, instead of including all the possible features. Features: To enable tree shaking in Flutter, you don’t need to do anything special. Flutter automatically performs tree shaking when building your app in release mode. However, you can help tree shaking by following some best practices, such as: Avoid using dynamic imports because they prevent tree shaking from analyzing your code. (import 'package:foo/foo.dart' as foo;) Avoid using reflection because it prevents tree shaking from removing unused code. (dart:mirrors) Avoid using because it prevents tree shaking from removing platform-specific code. dart:io Use conditional imports to import different libraries based on the platform. (import 'package:foo/foo.dart' if (dart.library.io) 'package:foo/foo_io.dart';) Learn more about tree shaking in Flutter here. Hack 6: Use deferred loading for your code The sixth Hack for Flutter performance optimization is to use deferred loading for your code. Deferred loading (also called lazy loading) is a technique that allows you to load parts of your code on demand, instead of loading them all at once. This can reduce the initial download size and memory usage of your app, and improve its startup time. To use deferred loading in Flutter, you need to use the keyword after the import statement and specify an alias for the imported library. Then, you need to call the method on the alias to load the library when you need it. For example: deferred loadLibrary() // Import a library lazily import 'package:foo/foo.dart' deferred as foo; // Load the library when needed await foo.loadLibrary(); // Use the library foo.bar(); Deferred loading can be useful when you have large or optional features in your app that are not needed at startup or by all users. For example, you can use deferred loading for: You can load only the language files that are relevant to the user’s locale, instead of loading all the supported languages. Localization: You can load only the theme files that are relevant to the user’s preference, instead of loading all the available themes. Themes: You can load only the feature modules that are relevant to the user’s action, instead of loading all the possible features. Features: However, deferred loading also has some limitations and challenges, such as: Deferred loading is currently only supported on Android, using dynamic feature modules. Other platforms still load all the code at once. Platform support: Deferred loading requires you to manually split your code into separate libraries and import them lazily. This can be tedious and error-prone, especially if you have complex dependencies or circular imports. Code splitting: Deferred loading can make testing and debugging more difficult, as you need to ensure that the libraries are loaded correctly and handle any errors or exceptions. Testing and debugging: To learn more about deferred loading in Flutter, see in the official documentation. Deferred Components That’s it! I hope you enjoyed this article and learned something new. If you have any questions or feedback, feel free to leave a comment below.

Flutter Performance Optimization: 6 Hacks for a Faster App

Use , and to display real-time changes in an application. This is the main theme of today's blog. Streams Firebase Cloud Functions, FireStore Intro Hello and Welcome to the 12th of the Flutter App Development Tutorial Series. This is Nibesh from Khadka's Coding Lounge. We traveled a long way to be here. We created a , wrote a , made a made an , set up a connection with firebase , , and accessed s on firebase projects. splash screen theme custom app bar, authentication screen cloud and emulators authenticated users users’ location We'll pick right where we left off and toggle the favorite icon for temples. We'll use Firestore to store all the favorites list for each user's document in the " " collection. The Firebase Function will help us fetch the immediate list and update it. While Stream will provide the changes in real-time for users to see. You can find the source code so far . last time users here Firebase Cloud Functions To Update  Firestore In RealTime Now, we'll create a cloud function in our file. This function will take an "id" as input. This id is provided by Google Maps Places API. index.js place_id It'll search and fetch the current user's document. We've already created an array while registering with the onCreate trigger. favTempleList The function then will look through the list and toggle the value. // Add temple to my fav list:
exports.addToFavList = functions.runWith({
    timeoutSeconds: 120,
    memory: "128MB"
}).https.onCall(async (data, context) => {
    const templeId = data.templeId;
    try {
        // Get user doc
        let userDocRef = await db.collection('users').doc(context.auth.uid).get();

        // extract favTempleLis from the doc
       // #1
        let favTempleList = userDocRef._fieldsProto.favTempleList;

        // if fav list is empty 
        // #2
     //============================//
        if (favTempleList.arrayValue.values.length === 0) {
            // Put the id in the list 
            const templeList = [templeId];
            functions.logger.log("Fav list is empty");
            
            // Update the favTemple list
            await db.collection('users').doc(context.auth.uid).set({ favTempleList: templeList }, { merge: true });
//============#2 ends here=====================//
        } else {
            functions.logger.log("Fav Temple List is not empty");
   
            // Make list of available ids
            // firebase providers arrays values as such fileName.arrayValue.values array 
            // consisting dictionary with stringValue as key and its value is the item stored
            // #3
            functions.logger.log(favTempleList.arrayValue.values[0]);
            let tempArrayValList = favTempleList.arrayValue.values.map(item => item.stringValue);

            // if not empty Check if the temple id already exists
           // #4
            let hasId = tempArrayValList.includes(templeId);

            // if so remove the id if no just add the list 
           // #5
//============================//
            if (hasId === true) {

                // Usr filter to remove value if exists
                let newTemplesList = tempArrayValList.filter(id => id !== templeId);

                await db.collection('users').doc(context.auth.uid).set({ favTempleList: newTemplesList }, { merge: true });
//==============#5 ends here===========//
            }
            // If the id doesnot already exists
           // #6
//============================//

            else {
                // first create a fresh copy
                let idList = [...tempArrayValList];

                // add the new id to the fresh list
                idList.push(templeId);

                // update the fresh list to the firesotre
                await db.collection('users').doc(context.auth.uid).set({ favTempleList: idList }, { merge: true });
//==============#6 ends here===========//

            }

        }

    } catch (e) { functions.logger.log(e); }

    // Return the Strig done. 
    //#7
    return "Done";
}); A couple of lines of code here are on other functions and triggers we've already done. So, let's only go over a few important ones: We are extracting the firebase field named "favTempleList" from the user documentation. That field is an array. We're checking if that array is empty. If so, we can just add the new place_id we got from the function call to the array and then update the doc. One thing to notice here is that I am using the merge option for an empty array. That's because this set() method doesn't just set/update a field in a doc, it sets/updates the whole document itself. So, if the **{merge: true} **option is not provided it'll overwrite every field there, in our case username, email, location, and so on. Now, we enter the section where the temple list is not empty. Then first we need to extract the list of values(id's) that are already present there. Check if the new ID, we got from the method call, is already present in the list we got from Firestore. If the id is already there then we need to remove it. We'll combine and methods. After filtering the current place_id, we'll update the Firestore user doc with the fresh list of ids. filter() includes() If the place_id is not there then we need to add it. We'll push the current place_id into the list. And then update the doc like before. Remember we should permanently terminate Firebase functions in the end. We don't need any data from this so we'll just terminate it by returning a string. Provider Now, we'll need to add a method in our Provider class that'll call the HTTPS callable function we just created. In our TempleProvider class let's add another method . addToFavList void addToFavList(String templeId) async {
    // Instantiate callable from index.js
    HttpsCallable addToFav = functions.httpsCallable('addToFavList');
    try {
      // Run the callable with the passing the current temples ID
      await addToFav.call(<String, String>{
        'templeId': templeId,
      });
    } catch (e) {
      rethrow;
    }
  } We're not updating or returning anything here. That's because we can get data from snapshots from a stream, as you'll see later. BTW, you could add this method to AuthStateProvider because it deals with user collection. Use Stream & StreamBuilder To Output Changes In RealTime We can simply use the for this. So, we'll connect with Firesotre with streams and update the screen with StreamBuilder.  So, where exactly are we using this StreamBuilder? Good question, you see getting real-time updates, means reloading(re-reading) the same collections on every change. It is obviously memory expensive. But it can cost expensive as well since Firebase charges for several reads. So, we don't want to load the list of temples, again and again, to toggle a single favorite icon. So, let's wrap only our favorite icon with stream builder instead. streams On temple_item_widget.dart make these changes. Create a function that'll call the addToFavList method from the provider class. // function to call addToFavList from provider class
  // It'll take id and providerclass as input
  void toggleFavList(String placeId, TempleProvider templeProvider) {
    templeProvider.addToFavList(placeId);
  } Inside the build method of class before the return statement. // Fetch the user doc as a stream
//#1
 Stream<DocumentSnapshot> qSnapShot = FirebaseFirestore.instance
        .collection('users')
        .doc(FirebaseAuth.instance.currentUser!.uid)
        .snapshots();

// Instantiate provider method to pass as argument for tooggle FavList
//#2
    TempleProvider templeProvider =
        Provider.of<TempleProvider>(context, listen: false); As mentioned before we'll get the Stream from Firestore, a document using the current user's ID. Instantiate provider method to pass as an argument for toggleFavList function. But make sure to turn off the listener. Replace FavIcon Section With StreamBuilder StreamBuilder(
                      // Use latest update provided by stream
                      // #1
                      stream: qSnapShot,
                      builder: (context, snapshot) {
                        if (snapshot.connectionState ==
                                ConnectionState.waiting ||
                            snapshot.connectionState == ConnectionState.none) {
                          return const CircularProgressIndicator();
                        } else {
                          // Get documentsnaphot which is given from the stream
                         // #2
                          final docData = snapshot.data as DocumentSnapshot;

                          // Fetch favTempleList array from user doc
                         // # 3
                          final favList = docData['favTempleList'] as List;

                          // Check if the curent widget id is among the favTempLlist
                         // #4
                          final isFav = favList.contains(widget.itemId);

                          return Expanded(
                            child: IconButton(
                                // Call toggleFavlist method on tap
                               // #5
                                onPressed: () => toggleFavList(
                                    widget.itemId, templeProvider),
                                icon: Icon(
                                  Icons.favorite,
                                  // Show color by value of isFav
                                 // #6
                                  color: isFav ? Colors.red : Colors.grey,
                                )),
                          );
                        }
                      }) Here, in the StreamBuilder Class we: Used the stream we got from Firestore 'users' collection as a stream. That way the latest change is
reflected asap. When the ConnectionState is done, first we get the latest data from the snapshot, which will be the current user's doc. Get the latest updated favTempleList array as a List from the document. Check if the current ID exists in the favItemList, which is the field passed down from the temples screen. itemId On pressing the heart icon button call the toggleFavList method of the class. Change the color of the heart icon based on the presence or absence of itemId on favTempleList. And with that latest real-time changes will be reflected in the app. Final Code The file looks like this after the changes. temple_item_widget.dart import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:temple/screens/temples/providers/temple_provider.dart';

class TempleItemWidget extends StatefulWidget {
  // Fields that'll shape the Widget
  final String title;
  final String imageUrl;
  final String address;
  final double width;
  final String itemId;

  const TempleItemWidget(
      {required this.title,
      required this.imageUrl,
      required this.address,
      required this.width,
      required this.itemId,

      // required this.establishedDate,
      Key? key})
      : super(key: key);

  @override
  State<TempleItemWidget> createState() => _TempleItemWidgetState();
}

class _TempleItemWidgetState extends State<TempleItemWidget> {
  // function to call addToFavList from provider class
  // It'll take id and providerclass as input
  void toggleFavList(String placeId, TempleProvider templeProvider) {
    templeProvider.addToFavList(placeId);
  }

  @override
  Widget build(BuildContext context) {
    // Fetch the user doc as stream
    Stream<DocumentSnapshot> qSnapShot = FirebaseFirestore.instance
        .collection('users')
        .doc(FirebaseAuth.instance.currentUser!.uid)
        .snapshots();

// Instantiate provider method to pass as argument for tooggle FavList
    TempleProvider templeProvider =
        Provider.of<TempleProvider>(context, listen: false);

    return SizedBox(
      // Card will have height of 260
      height: 260,
      width: widget.width,
      child: Card(
        key: ValueKey<String>(widget.itemId),
        elevation: 4,
        shape: RoundedRectangleBorder(
          borderRadius: BorderRadius.circular(10),
        ),
        margin: const EdgeInsets.all(10),
        child: Column(
          // Column will have two children stack and a row
          children: [
            // Stack will have two children image and title text
            Stack(
              children: [
                ClipRRect(
                  borderRadius: const BorderRadius.only(
                    topLeft: Radius.circular(10),
                    topRight: Radius.circular(10),
                  ),
                  child: Image.network(
                    widget.imageUrl,
                    fit: BoxFit.cover,
                    width: widget.width,
                    height: 190,
                  ),
                ),
                Positioned(
                  bottom: 1,
                  child: Container(
                    color: Colors.black54,
                    width: widget.width,
                    height: 30,
                    child: Text(
                      widget.title,
                      style: Theme.of(context)
                          .textTheme
                          .headline2!
                          .copyWith(color: Colors.white),
                      // softWrap: true,
                      overflow: TextOverflow.fade,
                      textAlign: TextAlign.center,
                    ),
                  ),
                ),
              ],
            ),
            Row(
                // Rows will have two icons as children

                crossAxisAlignment: CrossAxisAlignment.center,
                mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                children: [
                  Expanded(
                    child: IconButton(
                      onPressed: () {
                        print("Donate Button Pressed");
                      },
                      icon: const Icon(
                        Icons.attach_money,
                        color: Colors.amber,
                      ),
                    ),
                  ),
                  StreamBuilder(
                      // User the ealier stream
                      stream: qSnapShot,
                      builder: (context, snapshot) {
                        if (snapshot.connectionState ==
                                ConnectionState.waiting ||
                            snapshot.connectionState == ConnectionState.none) {
                          return const CircularProgressIndicator();
                        } else {
                          // Get documentsnaphot which is given from the stream
                          final docData = snapshot.data as DocumentSnapshot;
                          // Fetch favTempleList array from user doc
                          final favList = docData['favTempleList'] as List;
                          // Check if the curent widget id is among the favTempLlist
                          final isFav = favList.contains(widget.itemId);
                          return Expanded(
                            child: IconButton(
                                // Call toggleFavlist method on tap
                                onPressed: () => toggleFavList(
                                    widget.itemId, templeProvider),
                                icon: Icon(
                                  Icons.favorite,
                                  // Show color by value of isFav
                                  color: isFav ? Colors.red : Colors.grey,
                                )),
                          );
                        }
                      })
                ]),
          ],
        ),
      ),
    );
  }
} Summary In this exciting blog we: Created a Firebase HTTP Callable function to update a document in Firestore. We also wrote a simple instruction in the provider class to handle the callable. Lastly using stream and stream builder we displayed real-time changes on our screen. Show Support Alright, this is it for this time. The next part will be the last one for this series. We won't be doing anything new there. I'll give you some tasks to do on your own to continue this app and practice what you've learned so far. I'll also enlist some courses, blogs, and books that have helped me a lot to learn flutter. Please like, comment, and share the article with your friends. Thank you for your time and for those who are subscribing to the blog's newsletter, we appreciate it. Keep on supporting us.  This is Nibesh from Khadka's Coding Lounge, a freelancing agency that makes websites and mobile applications. Also Published here

How to Stream Real-time Changes With Firebase, Firestore and Flutter

How to Design Screens & Widgets In Flutter

Before jumping on to the topic let me tell professional story. I’ve worked as frontend dev and as a Product Manager. I'm fairly new to backend dev & have a decent knowledge on how to build frontend apps using Swift. When I chose to become Indie, I wanted to have a clear idea of what Indie implies in terms of product development. For me Indie 101 is: Product 20% Design 20% Coding 20% Mkt 20% Others 20% As an Indie, you're pretty much doing everything on your own & have less time to do it. Before moving to lowcode, I've tried building things from scratch & failed to do it on backend, I've spent like 4-6 weeks on backend, then I've felt like it is not worth to build everything from scratch since you don't know if the product is actually going to work or not. I've decided to look for leanest solutions, at the same time not compromising the user experience. I had fair knowledge on no-code & low-code market because of my past experience where we've adopted several tools for marketing initiatives. What did I build? As most of you know, the search feature on Twitter is a goldmine tool to find any content on Twitter, be it Hashtags, Keywords, Conversations b/w two users, location/worldwide, People you follow, Lists n many more… While the feature is great, I've found out that the feature has poor adoption among users who are not part of the tech world. This is due to not knowing the feature exists and also hard to memorize the exact search filters to find tweets. So, I've prioritized these problems Build a solution that focuses more on "what" to search instead of "how" to. Unlock several search filters (these search filters are currently not visible on default twitter advanced search) Library to store all the search phrases. Introduce the "Discover" section to educate users on how to find the best content. Integrate tightly to the Apple ecosystem. Ex: Siri, Spotlight search, notifications. Despite the app's support on macOS, iOS & iPadOS, I have launched it as an iOS app first because the advanced feature doesn't even exist unless you know how to directly input the search filters. Bird search — Your advanced search app for Twitter App link (iOS/iPadOS/macOS) https://apps.apple.com/us/app/bird-search/id1593852437 What is it? Many new ways to search compared to the default Twitter advanced search. https://photos.google.com/share/AF1QipPLwZ28BXGJEMmKU22NZCLFg7qaHrokYLSb7SN_7ogZ7y_8zPG0W-xepQK0ZJnH6g/photo/AF1QipMe-0KLrc7mmoGZO8OW3BixXG_lQfyLm7TX-2Bw?key=MTJSUFc5Tl80dmVjWWhYRVRWR3RWTTdSMnd1NlV3 Focuses more on “what” to search instead of “how”. Fills the gap for iOS where Twitter advanced search feature doesn’t exist, unlike the website. Discover curated content on Twitter from other user accounts. Supports Siri Ex: “Top tweets from Elon” https://twitter.com/pradeepb28/status/1476866971853492226?s=20&t=ST1LdYrRGHm2DZ-IWeWu0A Supports spotlight search many more… https://photos.google.com/share/AF1QipNHGGMod8-8VbPqCQeltDEtlRLuGp196cIk3KkVsmEy89s7WXftmb9MVpBczM5rfw/photo/AF1QipPzY_0sVuxexgovq1P5THe4dH0N99EolQ5tXVts?key=WWltcy00REVNclRjYlFfa2RCVTRFT2xfQllrbHl3 How I find potential customers for the very same app? After the launch, I have gained around 20+ paid users in 10 days which is not a good number for Indies. I have decided to use my product on an everyday basis to see if and how can I use my own app to find potential customers. I was glad enough that I could find a way to search for my potential customers. Once I found it, I reached out to them through cold DMs and tweet them about how can they use the app to find signaled content on Twitter. Over time, I’ve seen creators, marketers, journalists are signing up for the app and using it. Since the app is indexing on top of Twitter search, I found my potential customers by building a search query who’s talking about “Twitter search” or “Twitter advanced search” on twtr platform and reaching out to them through cold DMs or comments under their tweet. I found this is a perfect acquisition loop or dogfooding for my app to grow(with some manual effort) Here is a quick video: https://photos.google.com/share/AF1QipMh7k5BdHxInIV_iPP3Pr4x69tNjpCGj19bmF7OZNYcXEWGD4NrzegV6Pry8sFCxg/photo/AF1QipN-9choQKoB_JGoS00ikPH-cL4tCULW2GCf4XoR?key=SG0ta2g1elE3VXhMUzZ0eGMtUUViUTBRd1pONXVn The app is available here to download (iOS/iPadOS/macOS) https://apps.apple.com/us/app/bird-search/id1593852437 For folks who are interested to know my tech stack I stuck to low code tools. I wanted to have control on my frontend so I went with a code tool and on backend, there is nothing much to innovate or do from scratch so I’ve decided to use iCloud and Xano for data storage and processing. Frontend: Swift using UIKit & SwiftUI frameworks. Backend: iCloud to store user-generated content and Xano for public data and to collect feedback. My next update on marketing is to scale this process and automate it if possible. More info: https://birdsearch.softr.app/ I hope this post inspires others to dog food their own app first, then find ways to introduce acquisition or growth loops from inside out of your own product.

Stories, News & Mentions about SOFTURA

Softura’s Stories on HackerNoon

Softura's News & Mentions