Bluecrew

bluecrew

As a product manager, have you ever had to say no to improving your app’s notifications because of how complex the project seemed? If yes, you’re not alone. At Courier, we frequently see product teams deciding not to work on notifications. And PMs aren’t making that decision because a good notification experience is not important for their SaaS product or service — quite the opposite. The reason is that changing notifications, in their experience, requires a lot of work between engineering and product due to how closely the notifications are tied to the rest of the application. If PMs are tasked with adding a new email campaign that all new users of the app will receive, that can usually be done outside of the core app. But sending more unique notifications, like alerting a Slack channel when someone @-mentions their colleague in a shared file, can be complex and require significant engineering work. And still, more work is needed when the text or the design of such notification needs to be updated. We believe that changing notifications doesn’t have to be so difficult. In this article, we explain how decoupling notifications from your application’s codebase can help make notification projects less complex and less risky for product teams. Why PMs believe notification projects are hard Usually, the task of improving an app’s notification experience — like adding or changing notifications, or connecting additional notification channels — falls to the engineering team that’s responsible for the main product. Such teams have lots on their plate, which makes it necessary to prioritize some tasks over others. Notification projects tend to be high-value for product managers, as a bad notification experience can have a negative impact on a SaaS app’s customer base, while, conversely, can drive growth metrics and delight customers. a good notification experience However, notification projects also score high on complexity and risk at most companies. That’s because different notification channels, which are quite different by nature (think email versus mobile push), require a lot of individual engineering. With so much complexity involved, product managers have to make a tough call: is it really worth taking on notification work when there are easier projects to work on with more tangible benefits? Because task backlogs frequently have other items in them that don’t carry as much complexity or risk, it’s logical for product managers to postpone rather complex notification projects. And so notification projects get moved down the priority list, again and again. The limits of common engineering solutions to notification problems To try and make notification changes less difficult to implement, engineering teams use open-source tools that are well supported within their framework or programming language of choice. For example, those working with Ruby on Rails applications often use Rails’ built-in email sending module, , which includes functionality for sending plain-text and HTML emails. Action Mailer While tools like Action Mailer are convenient to use and well-maintained, they can’t handle more complex tasks like expanding beyond the standard notification channels. If you want to add Slack or SMS notifications, for example, choices like Action Mailer can become a limiting factor, rather than an enabler of new product functionality. The next logical option for a software team running into tooling limitations is to go with a fully customized notification system — but such a system brings its own challenges. Even a custom notification system is a bottleneck for notification improvements It may seem that the solution to the limitations of open-source tools is to simply build your own custom notification system. But a custom notification system is still code that implements notification logic, supported channels, and templates for specific notifications, and this code lives inside the application codebase in a version control system like Git. Any changes to this part of the codebase have to follow the steps of the software development process, which becomes cumbersome when making many small changes, as is the case with notifications. (Not to mention that engineering time needs to be allocated to the maintenance of such systems in the long run.) For example, if the task is to update the wording or the design of a notification across all channels, the engineering team tasked with the work might have to: Change the HTML email template. Change the Slack notification template. Change the Microsoft Teams notification template. Test all three changes. Wait for code review on the changes. Once the code is reviewed, deploy all three changes to production. Handoff to the PM for final confirmation. And every time a PM wants more changes implemented for notifications, the process has to start over again, even for trivial content changes. The standard development process, which is totally reasonable for code changes, is too much overhead when working on notifications, and the additional overhead takes the engineers’ time away from working on more valuable things. The result: notifications rarely get updated Because of the additional delays introduced by the development process, the friction for implementing notification changes ends up being so high that PMs often choose to not implement notification changes at all. Instead of focusing on building the best possible notification experience, they settle for the default notifications that are built into their application already, because anything else becomes too difficult to do. They might think “If it took two weeks to change the simple design on my notifications, we're just not going to change things anymore.” And so notification experiences stall out indefinitely. There is a better way: enable PMs to work with notifications without involving the engineering team Courier’s point of view is that the way notifications are handled in most SaaS apps today — templates stored in code, notification functionality changes requiring code deployments, etc. — is outdated and, as we have seen in the examples above, ineffective. Instead of having to go through the development process for each notification change, we need to give PMs and other non-technical stakeholders the right tools to work with notifications directly. Here are the core practices that act as enablers for non-technical audiences. Notification templates in the form of text, HTML, or programming-language-specific template files need to be located outside of the application code, and PMs as well as other non-technical teams need to have access and be able to make changes. Making templates accessible to non-engineers. . The logic involved in deciding which notifications to send when should not be located in the application code, but rather sit next to it and be configurable without needing to deploy the application. The configuration can live in a text file, a web interface, or another config format. PMs should ideally be able to change the configuration themselves. Making notification logic configurable without needing to re-deploy the app Besides notification functionality, PMs need to be able to track how their changes are doing — and be able to follow the statistics without the need to ask engineering or data teams for the numbers. Analytics can be presented as a custom dashboard, but can also be an export of a business intelligence report, or even a dump of application logs that show which messages were sent, depending on which option is easier. Enabling self-serve analytics. What are the results of PM enablement? To show that PM enablement works as a way to make notification projects easier, we want to share two examples from Courier customers that have experienced this change. Bluecrew, a marketplace for hourly jobs, after decoupling notifications from application code. The company was able to improve the onboarding experience for new users in part by taking advantage of notification templates and making them accessible to non-technical stakeholders. has seen its business grow Within Bluecrew’s notification system, “anyone can add a content block and insert a custom attribute like ‘shift start time’ or ‘cancelation reason.’ We also have the flexibility to add custom code anywhere in the notification,” says Cooper Newby, the Chief Product Officer at Bluecrew. Another company that’s been taking advantage of the enablement approach is , a provider of security services. The Expel team has enabled its UX designers to use the template designer UI directly and make changes to the product in real time. Expel “We can get our UX designers working directly on the templates and we can make updates and have them live in seconds,” says Yousuf Ashparie, Principal Software Engineer at Expel. Does enabling PMs to make notification changes sound appealing at this point? We hope it does — as we believe it’s a significant improvement over the current practices at most companies. Let’s look at how you can enable PMs to work with notifications in your own team. So, how can you enable PMs to work with notifications? Looking to enable PMs to do more notification work, but not sure where to start? Here are our top recommendations for companies looking to get started on the PM enablement journey. Having analytics for notifications is a key tool for PMs to measure any notification changes. While metrics can be difficult to come by for some notification channels, it is usually possible to have at least some numbers in place. Once the PMs get the data, they can use it to avoid accidentally making the notification experience worse, and to make sure the rest of the organization can see the benefits for larger changes to notifications. Get analytics in place. While it’s ideal to make all notification channels and notification types configurable by PMs, it’s not always realistic. Instead, at least make it so that PMs can change existing notifications without much involvement from the engineering team. Even if that’s all you allow, you will still need to add functionality to adjust notification designs to fit the updated content, and likely implement internationalization and translation workflows if you’re interested in supporting multiple languages. Make it easier to change notification templates. Ideally, all notification functionality should be covered with automated and, possibly, manual tests so that the organization can be confident in the product’s notification experience at all times. The areas to check include: notification text fitting within the display area; possible internationalization glitches; technical issues like app crashes resulting from changes in notification text size; handling of unexpected characters if notifications include user input. Build guardrails to prevent notification issues from escaping to production. Courier can help Instead of building everything yourself, use Courier — and get our recommended steps 1–3 done almost instantly after some brief initial implementation work. Using Courier frees up your team to focus on other valuable things in their backlog. For PMs, UX designers, and other non-technical stakeholders, Courier helps by: providing a drag and drop designer, including a staging environment, with the ability to make changes live without deploying the app offering a UI that allows users to add new notification channels without needing to update code including an Automation UI that allows users to build out notification workflows visually (no application code) Implementing the guardrails in point 3 above, so that you can reduce the effort involved in changing notifications without increasing the risk. Also Published here

Free-up Engineering Time by Empowering Product Managers to Build Push Notifications

Product notifications are a mission-critical component of your product that can’t be left to chance. However, notification channels are ever-evolving, and you need to keep up in order to reach users when, where, and how they prefer to be reached. A future-proof multichannel notifications strategy helps you stay in touch with your users without coming off as intrusive, non-responsive, or antiquated. What Is a Multichannel Notifications System? A multichannel notifications system is designed to seamlessly route and deliver messages about product-related events to users across multiple channels and providers. For companies that require a detailed and wide-ranging strategy to reach customers and potential users, a multichannel notifications system can help your company reach out to users in the way they prefer to be contacted. One of our clients, Bluecrew, a W-2 staffing platform that connects hourly workers with employers, recorded a in job application rates after scaling their notifications infrastructure with Courier. 55% improvement With multiple communication options, businesses need to think about how they’ll communicate different events to their users, including: Transactions: notifications that provide a summary of transactional updates Alerts: notifications that require high assurances of deliverability and visibility User activities: notifications that update users about key activities within their accounts or profiles Required actions: notifications that proactively let users know when action is needed Digests: notifications that deliver a dynamic summary of events To do notifications well, a company/product requires a multichannel notifications strategy that can adjust with the times. Traditional Approaches to Multichannel Notifications Systems Fall Short There are two traditional approaches to managing the notifications strategy for your apps: limited channel notifications and custom channel support. 1. Static and non-customizable approach This is a notifications strategy that supports a handful of channels that are the only means of communicating with users, irrespective of the user’s needs or preferences. A strategy that supports a limited number of channels is common in legacy solutions with ancient codebases that are best left undisturbed. However, many newer products and services might unwittingly end up with a limited number of channels after a few years. Sometimes, product managers don’t consider how they’ll support notifications until the last minute. Then you are forced to choose whatever notification channel seems to work best at that time. The challenge with this approach is that you may never quite get around to introducing new channels, and it becomes impractical to make changes as your codebase grows. In contrast, a multichannel product notifications strategy that begins during product development allows you to bake agility into your plans to add new channels over time. 2. Customizable, yet unscalable Approach This is a notifications strategy in which the company actively works to support new channels as needs arise. This custom-channel notifications strategy is especially common with startups because they tend to move fast. Many startups, for instance, adopt the approach that prioritizes speed over efficiency. In this case, you’d probably lean toward writing code to support new channels as the need arises instead of thinking strategically about how to manage notifications in the future. blitzscaling product development In the early days, the development team might power through the night or weekend to update your code so it can support a new notification channel, and it’s common to do this every time there’s an additional notification channel that needs support. While this ad-hoc approach might work in the short term, it eventually becomes unsustainable as your business grows. As your product development process matures, decision-making requires input across cross-functional teams. It’s not as easy to adapt on a whim. A Future-Proof Notifications System Adapts to Changing Communication Preferences A notifications strategy that takes into consideration that we live in a multichannel world is future-proof. It is designed to adapt to the dynamic needs of modern communication without being slow, expensive, or outdated for your stakeholders. A future-proof multichannel notifications strategy should let you notify users across channels, integrate with your existing tech, and reroute messages to different channels, all while being easy to use and scaling with your company. Enable Notifications Across Multiple Channels Today A multichannel notifications strategy lets you switch across channels to meet the needs of your users. For instance, SMS is a popular notification channel in the United States, but there’s a strong in emerging markets. For example, 96.4% of Brazil’s digital population, 95.4% of South Africa’s digital population, and 95.2% of the digital population in Argentina actively use WhatsApp monthly. preference for WhatsApp Similarly, is the leading communication channel in Asia with 1.26 billion monthly active users, and emails seem to be the channel in Europe with 72% of respondents preferring emails over WhatsApp, SMS, or other communication channels. Your product notifications system must be robust enough to deliver notifications across all these channels. WeChat preferred communication Deliver Notifications Across Multiple Providers on the Same Channels You also need to be able to pivot the delivery of notifications through different providers within a channel as providers compete on features, pricing, and other metrics. The benefits of being able to integrate with multiple providers accross a notifications channel include having a fallback option to ensure delivery of one provider has a downtime. Another benefit is that you might be able to shop around for the best price per message based on the price offering of different providers in different countries. Therefore, you may want to be able to integrate with the following providers (and potentially more) across all the communication channels. : SendGrid, Mailgun, Amazon SES, SparkPost For emails : Twilio, MessageBird, Plivo, Telnyx For SMS For chat: WhatsApp, , , FB Messenger Microsoft Teams Slack : Firebase, OneSignal, Airship, Expo For push Route Notifications Across Channels and Providers The preferences and needs of users are dynamic; therefore, users who only want email notifications today might later decide they want push notifications. The challenge with changing user preferences is that notification formats differ across channels. For instance, a notification requiring a user action sent by email needs a button, whereas the same notification sent as an SMS needs a hyperlink. Make It Easier to Expand to Future Channels Your product notifications strategy should enable forward compatibility to integrate with new channels and providers as they emerge. Right now, Zoom and Microsoft Teams are the , but that could change in five years; after all, Skype some 10 years ago. When developing your product notifications strategy, you should insist on simple, elegant, and potentially modular code that can be easily updated to support new channels. leading business communication tools used to be the standard Scale Effortlessly for More Users and Messages As your business grows, your notifications strategy should accommodate your company’s size, from startup to enterprise and beyond. For instance, Gojek, a transport and logistics company in Southeast Asia, says it delivers more than . 1 million push notifications per hour While your products may not need to send 1 million notifications per hour, you need to think about how the architecture of your product notifications system is designed to initiate, send, and deliver (and, where necessary, store) thousands of notifications as easily as it handles hundreds of notifications per day. Enhance the Agility of Your Product Notifications Strategy with Courier Building a custom multichannel strategy that adapts to a multichannel and fast-changing communication infrastructure is slow, expensive, and frustrating. Courier is on a mission to improve software-to-human communications with APIs. Courier helps you handle the notifications experience in your products, so you can focus on building your business. Courier empowers you to future-proof your multichannel product notifications strategy with shortened development time, dynamic templates, and analytics. APIs Shorten the Development Time and Costs Courier shortens the time it takes to build a multichannel notifications strategy by providing you with APIs and SDKs, so you don’t have to start writing code from scratch. Our APIs can be integrated into all communication channels, from push to emails, and you can get support for more than 60 providers in a single API. Courier’s APIs also handle user data, templates, preferences, and message orchestration for a seamless product notification experience. Additionally, we provide SDKs for all major languages to enable you to implement geographical-based localization in the delivery of your notifications. Templates Make It Easier to Add More Channels If you develop your templates manually, it might be difficult to manage the different variations of the templates as you add new channels and providers. Courier’s templating system has an omnichannel architecture. Courier Studio supports drag-and-drop designs, and you can use JSON-based templates to produce templates efficiently. Courier automatically generates notification templates that fit the format of each delivery channel before routing the messages through the right provider(s). Analytics Improves the Notification Experience for Your Users Courier is also outfitted with analytics that help you understand the notification experience of your users. Visibility into the quality of their experience also provides you with insights on how to optimize the notification experience across all the channels and providers you support. Scale Your Notifications System Across Channels Effortlessly Courier’s modular model enables you to add new channels, replace providers, and route messages across channels in a unified system. Courier also functions as a low-code solution. So anybody on your team with minimal technical skills can add channels in minutes without a developer or knowing how to write code. Are you a PM who needs to establish or improve their app’s notification system? Check out our about what it takes to build a great notification system or just learn more about Courier by . ebook scheduling a demo

Why a Future-Proofed Multichannel Notification System is Important

Por qué es importante un sistema de notificación multicanal preparado para el futuro

These are the 100+ Companies Hiring Data Scientists Now

Authors:
(1) Taha Laroussi, Laboratoire d’Hydrodynamique (LadHyX), CNRS, Ecole Polytechnique, Institut Polytechnique de Paris, 91120 Palaiseau, France;
(2) Mojtaba Jarrahi, Universit´e Paris-Saclay, CNRS, FAST, 91405 Orsay, France;
(3) Gabriel Amselem, Laboratoire d’Hydrodynamique (LadHyX), CNRS, Ecole Polytechnique, Institut Polytechnique de Paris, 91120 Palaiseau, France. Table of Links Abstract and Introduction Methods Results Model Discussion, Acknowledgements and References Supplementary Material Abstract Phototaxis, the directed motion in response to a light stimulus, is crucial for motile microorganisms that rely on photosynthesis, such as the unicellular microalga Chlamydomonas reinhardtii. It is well known that microalgae adapt to ambient light stimuli. On time scales of several dozen minutes, when stimulated long enough, the response of the microalga evolves as if the light intensity were decreasing [Mayer, Nature (1968)]. Here, we show experimentally that microalgae also have a shortterm memory, on the time scale of a couple of minutes, which is the opposite of adaptation. At these short time scales, when stimulated consecutively, the response of C. reinhardtii evolves as if the light intensity were increasing. Our experimental results are rationalized by the introduction of a simplified model of phototaxis. Memory comes from the interplay between an internal biochemical time scale and the time scale of the stimulus; as such, these memory effects are likely to be widespread in phototactic microorganisms. I. INTRODUCTION Phototaxis, the directed motion of organisms in response to a light stimulus, is widespread both in prokaryotes and single-cell eukaryotes [1]. One of the cellular models for eukaryotic phototaxis is the microalga Chlamydomonas reinhardtii, which responds to bluegreen light [2, 3]. When light hits the eyespot of the microalga, it induces photocurrents, whose amplitude depend on the light intensity. These photocurrents then induce flagellar currents which change the beating pattern of the flagella, leading to reorientation and eventually phototaxis [3, 4]. At low light intensities, wild-type C. reinhardtii cells swim towards the light, while they swim away from the light at high light intensities. This corresponds to positive and negative phototaxis, respectively [5]. What sets the change in phototactic behavior? The answer to this question is not fully settled [3]. Several biochemical parameters were found to affect the sign of phototaxis of C. reinhardtii, such as the amount of calcium ions in the surrounding medium [6–8], photosynthetic activity of the microalgae [9], the amount of intracellular reactive oxygen species [10], or the phosphorylation of channelrhodopsin-1, one of the photoreceptors of C. reinhardtii [11]. It is also known that the history of the alga plays a role in its phototactic response: like many unicellular organisms [12–14], C. reinhardtii adapt to their environment. A naive cell population, kept in the dark, exhibits negative phototaxis in response to an intense light stimulus; the same cell population, exposed to the same intense light stimulus, undergoes positive phototaxis when it has been previously exposed to light for a couple dozens minutes [15]. This change in phototactic behavior of a population depending on the history of irradiation is consistent with results obtained at the single-cell level by R¨uffer and Nultsch [4], who monitored the change in beating of the two flagella of C. reinhardtii in response to increasing and decreasing light-stimuli. Such a history-dependent change in the phototactic response occurs on long time scales, of the order of a couple dozen minutes. Here, we show experimentally that the change in phototactic behavior also depends on the recent history of the cell, where the time scale is of the order of a couple minutes. At these short time scales, the algae exhibit a behavior that is the exact opposite of the long-term adaptation: they integrate consecutive signals over time. When subjected to two consecutive, closely spaced identical stimuli, an alga essentially adds up the second stimulus to the first one, and acts as if the second stimulus were of higher intensity than the first one. Such a signal integration has, to the best of our knowledge, never been observed in the phototactic response of microalgae. Our results are rationalized by the introduction of a simplified model of phototaxis. The memory emerges in the model from the interplay between two time scales, the time between successive stimuli and the relaxation time of an inner biochemical process. Since the model is generic, similar short-term memory effects are likely to be widespread in other organisms that experience phototaxis. This paper is available on arxiv under CC 4.0 license. Authors: (1) Taha Laroussi, Laboratoire d’Hydrodynamique (LadHyX), CNRS, Ecole Polytechnique, Institut Polytechnique de Paris, 91120 Palaiseau, France; (2) Mojtaba Jarrahi, Universit´e Paris-Saclay, CNRS, FAST, 91405 Orsay, France; (3) Gabriel Amselem, Laboratoire d’Hydrodynamique (LadHyX), CNRS, Ecole Polytechnique, Institut Polytechnique de Paris, 91120 Palaiseau, France. Authors: Authors: (1) Taha Laroussi, Laboratoire d’Hydrodynamique (LadHyX), CNRS, Ecole Polytechnique, Institut Polytechnique de Paris, 91120 Palaiseau, France; (2) Mojtaba Jarrahi, Universit´e Paris-Saclay, CNRS, FAST, 91405 Orsay, France; (3) Gabriel Amselem, Laboratoire d’Hydrodynamique (LadHyX), CNRS, Ecole Polytechnique, Institut Polytechnique de Paris, 91120 Palaiseau, France. Table of Links Abstract and Introduction Abstract and Introduction Methods Methods Results Results Model Model Discussion, Acknowledgements and References Discussion, Acknowledgements and References Supplementary Material Supplementary Material Abstract Phototaxis, the directed motion in response to a light stimulus, is crucial for motile microorganisms that rely on photosynthesis, such as the unicellular microalga Chlamydomonas reinhardtii. It is well known that microalgae adapt to ambient light stimuli. On time scales of several dozen minutes, when stimulated long enough, the response of the microalga evolves as if the light intensity were decreasing [Mayer, Nature (1968)]. Here, we show experimentally that microalgae also have a shortterm memory, on the time scale of a couple of minutes, which is the opposite of adaptation. At these short time scales, when stimulated consecutively, the response of C. reinhardtii evolves as if the light intensity were increasing. Our experimental results are rationalized by the introduction of a simplified model of phototaxis. Memory comes from the interplay between an internal biochemical time scale and the time scale of the stimulus; as such, these memory effects are likely to be widespread in phototactic microorganisms. I. INTRODUCTION Phototaxis, the directed motion of organisms in response to a light stimulus, is widespread both in prokaryotes and single-cell eukaryotes [1]. One of the cellular models for eukaryotic phototaxis is the microalga Chlamydomonas reinhardtii, which responds to bluegreen light [2, 3]. When light hits the eyespot of the microalga, it induces photocurrents, whose amplitude depend on the light intensity. These photocurrents then induce flagellar currents which change the beating pattern of the flagella, leading to reorientation and eventually phototaxis [3, 4]. At low light intensities, wild-type C. reinhardtii cells swim towards the light, while they swim away from the light at high light intensities. This corresponds to positive and negative phototaxis, respectively [5]. What sets the change in phototactic behavior? The answer to this question is not fully settled [3]. Several biochemical parameters were found to affect the sign of phototaxis of C. reinhardtii, such as the amount of calcium ions in the surrounding medium [6–8], photosynthetic activity of the microalgae [9], the amount of intracellular reactive oxygen species [10], or the phosphorylation of channelrhodopsin-1, one of the photoreceptors of C. reinhardtii [11]. It is also known that the history of the alga plays a role in its phototactic response: like many unicellular organisms [12–14], C. reinhardtii adapt to their environment. A naive cell population, kept in the dark, exhibits negative phototaxis in response to an intense light stimulus; the same cell population, exposed to the same intense light stimulus, undergoes positive phototaxis when it has been previously exposed to light for a couple dozens minutes [15]. This change in phototactic behavior of a population depending on the history of irradiation is consistent with results obtained at the single-cell level by R¨uffer and Nultsch [4], who monitored the change in beating of the two flagella of C. reinhardtii in response to increasing and decreasing light-stimuli. Such a history-dependent change in the phototactic response occurs on long time scales, of the order of a couple dozen minutes. Here, we show experimentally that the change in phototactic behavior also depends on the recent history of the cell, where the time scale is of the order of a couple minutes. At these short time scales, the algae exhibit a behavior that is the exact opposite of the long-term adaptation: they integrate consecutive signals over time. When subjected to two consecutive, closely spaced identical stimuli, an alga essentially adds up the second stimulus to the first one, and acts as if the second stimulus were of higher intensity than the first one. Such a signal integration has, to the best of our knowledge, never been observed in the phototactic response of microalgae. Our results are rationalized by the introduction of a simplified model of phototaxis. The memory emerges in the model from the interplay between two time scales, the time between successive stimuli and the relaxation time of an inner biochemical process. Since the model is generic, similar short-term memory effects are likely to be widespread in other organisms that experience phototaxis. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Short-term Memory Effects in the Phototactic Behavior of Microalgae: Abstract and Introduction

Neural networks are at the forefront of Machine Learning (ML) today, and Python is undoubtedly the go-to programming language for any ML task, regardless of whether one intends to use Neural Networks to solve it or not. There is a vast array of Python libraries available that cover the entire spectrum of ML tasks, such as NumPy, Pandas, Keras, TensorFlow, PyTorch, and so on. These libraries usually rely on C or C++ implementations of ML algorithms and approaches under the hood because Python is too slow for them. However, Python is not the only programming language in existence, and it is not the one I use in my daily work. This article is not a guide on how to write something in Swift; rather, it is more like a thought piece about the current mindset of many developers who view Python as a bridge to the ultimate solution for ML libraries that will resolve any problem or task they encounter, regardless of the language they are using. I would wager that most developers prefer to invest their time in finding ways to integrate Python libraries into their language/environment rather than considering alternative solutions without them. While this is not inherently bad – reuse has been a significant driver of progress in IT over the past few decades – I have started to sense that many developers no longer even consider alternative solutions. This mindset becomes even more entrenched with the current state and advancements in Large Language Models. The balance is lacking; we are rushing towards asking LLMs to resolve our issues, obtaining some Python code, copying it, and enjoying our productivity with potentially significant overhead from unnecessary dependencies. Let's explore alternative approach for solving the task at hand using only Swift, mathematics, and no other tools. When people start learning Neural Networks, there are two classic Hello World examples that you can find in most tutorials and introductory materials for it. The first one is a handwritten digits recognition. The second is a data classification. I will focus on the second one in this article, but the solution I will go through will work for the first one as well. The very good visual example for it can be found in TensorFlow Playground, where you can play around with different neural network structures and visually observe how well the resulting model solves the task. You might ask what the practical meaning of these dots on an image with different colors is? The thing is that it's a visual representation of some data sets. You can present many different types of data in exactly the same or similar way, such as social groups of people who buy specific products or music preferences. Since I primarily focus on mobile iOS development, I will also give an example of a real task I was solving that can be visually represented in a similar manner: finding electric wires inside walls using a gyroscope and magnetometer on a mobile phone. In this particular example, we have a set of parameters related to the wire found and another set of parameters for nothing is inside the wall. Let's take a look at the data we'll be using. We have two types of data here: red dots and blue dots. As I described above, it may be a visual representation of any kind of classified data. For example, let's take the red area as the one where we have a signal from the magnetometer and gyroscope in cases when we have an electric wire in the wall, and the blue area in case we don't. We can see that these dots are grouped together somehow and form some sort of red and blue shapes. The way these dots were generated is by taking random points from the following image: We will use this picture as a random model for our train process by taking random points for training the model and other random points for testing our trained model. The original picture is 300 x 300 pixels, containing 90,000 dots (points). For training purposes, we will use only 0.2% of these dots, which is less than 100 points. To gain a better understanding of the model's performance, we will randomly select 3000 points and draw circles around them on the picture. This visual representation will provide us with a more comprehensive idea of the results. We can also measure the percentage of accuracy to verify the model's efficiency. How we gonna make a model? If we take a look at these two images together and try to simplify our task, we will find out that the task, in fact, is to recreate the Origin picture from the data we have (batch of red and blue dots). And as closer the picture we get from our model to the original one will be as more accurate our model works. We can also consider our test data as some sort of extremely compressed version of our original image and have a goal of decompressing it back. What we are going to do is to transform our dots into mathematical functions that will be represented in code as arrays or vectors (I will use vector term here in the text just because it's between function from math world and array from software development). Then, we will use these vectors to challenge every test point and identify to which vector it belongs more. To transform our data, I will try a Discrete Cosine Transform (DCT). I won't go into any mathematical explanations about what it is and how it works, as you can easily find that information if you wish. However, I can explain in simple terms how it can help us and why it's useful. The DCT is used in many areas, including image compression (such as JPEG format). It transforms the data into a more compact format by keeping only the important parts of the image while removing the unimportant details. If we apply the DCT to our 300x300 image containing only red dots, we will get a 300x300 matrix of values that can be transformed into an array (or vector) by taking each row separately. Let's finally write some code for it. First, we need to create a simple object that will represent our point (dot). enum Category {
    case red
    case blue
    case none
}

struct Point: Hashable {
    let x: Int
    let y: Int
    let category: Category
} You may notice that we have an additional category called . We will actually create three vectors in the end: one for points, second for points, and the third one for anything else that is represented by . While we could just have two of them, having a trained vector for not red and not blue will make things a bit simpler. none red blue none We have `Point` conforms to the protocol to use a to avoid having points with the same coordinates in our test vector. Hashable Set func randomPoints(from points: [Point], percentage: Double) -> [Point] {
    let count = Int(Double(points.count) * percentage)
    var result = Set<Point>()
    while result.count < count {
        let index = Int.random(in: 0 ..< points.count)
        result.insert(points[index])
    }
    return Array<Point>(result)
} Now we can use it to take random points from our original image for red, blue, and none points. 0.2% redTrainPoints = randomPoints(from: redPoints, percentage: 0.002)
blueTrainPoints = randomPoints(from: bluePoints, percentage: 0.002)
noneTrainPoints = randomPoints(from: nonePoints, percentage: 0.002) We are ready to transform these training data using DCT. Here's an implementation of it: final class CosTransform {

    private var sqrtWidthFactorForZero: Double = 0
    private var sqrtWidthFactorForNotZero: Double = 0
    private var sqrtHeightFactorForZero: Double = 0
    private var sqrtHeightFactorForNotZero: Double = 0

    private let cosLimit: Int

    init(cosLimit: Int) {
        self.cosLimit = cosLimit
    }

    func discreteCosTransform(for points: [Point], width: Int, height: Int) -> [[Double]] {
        if sqrtWidthFactorForZero == 0 {
            prepareSupportData(width: width, height: height)
        }

        var result = Array(repeating: Array(repeating: Double(0), count: width), count: height)

        for y in 0..<height {
            for x in 0..<width {
                let cos = cosSum(
                    points: points,
                    width: width,
                    height: height,
                    x: x,
                    y: y
                )
                result[y][x] = cFactorHeight(index: y) * cFactorWidth(index: x) * cos
            }
        }

        return result
    }

    func shortArray(matrix: [[Double]]) -> [Double] {
        let height = matrix.count
        guard let width = matrix.first?.count else { return [] }

        var array: [Double] = []
        for y in 0..<height {
            for x in 0..<width {
                if y + x <= cosLimit {
                    array.append(matrix[y][x])
                }
            }
        }
        return array
    }

    private func prepareSupportData(width: Int, height: Int) {
        sqrtWidthFactorForZero = Double(sqrt(1 / CGFloat(width)))
        sqrtWidthFactorForNotZero = Double(sqrt(2 / CGFloat(width)))
        sqrtHeightFactorForZero = Double(sqrt(1 / CGFloat(height)))
        sqrtHeightFactorForNotZero = Double(sqrt(2 / CGFloat(height)))
    }

    private func cFactorWidth(index: Int) -> Double {
        return index == 0 ? sqrtWidthFactorForZero : sqrtWidthFactorForNotZero
    }

    private func cFactorHeight(index: Int) -> Double {
        return index == 0 ? sqrtHeightFactorForZero : sqrtHeightFactorForNotZero
    }

    private func cosSum(
        points: [Point],
        width: Int,
        height: Int,
        x: Int,
        y: Int
    ) -> Double {
        var result: Double = 0
        for point in points {
            result += cosItem(point.x, x, height) * cosItem(point.y, y, width)
        }
        return result
    }

    private func cosItem(
        _ firstParam: Int,
        _ secondParam: Int,
        _ lenght: Int
    ) -> Double {
        return cos((Double(2 * firstParam + 1) * Double(secondParam) * Double.pi) / Double(2 * lenght))
    }
} Let's create an instance of object and test it. CosTransform let math = CosTransform(cosLimit: Int.max)
...
redCosArray = cosFunction(points: redTrainPoints)
blueCosArray = cosFunction(points: blueTrainPoints)
noneCosArray = cosFunction(points: noneTrainPoints) We use some simple helper functions here: func cosFunction(points: [Point]) -> [Double] {
    return math.shortArray(
        matrix: math.discreteCosTransform(
            for: points,
            width: 300,
            height: 300
        )
    )
} There is a parameter in that is used inside shortArray function, I will explain the purpose of it later, for now let's ignore it and check the result of 3000 random points from original image against our created Vectors , and . To make it work, we need to create another DCT vector from a single point taken from the original image. This we do exactly the same way and using the same functions we already did for our , and cos Vectors. But how can we find which one this new vector belongs to? There is a very simple math approach for it: . Since we have a task of comparing two Vectors and finding the most similar pair, Dot Product will give us exactly this. If you apply a Dot Product operation for two identical Vectors, it will give you some positive value that will be greater than any other Dot Product result applying to the same Vector and any other Vector that has different values. And if you apply a Dot Product to the orthogonal Vectors (Vectors that don't have anything common between each other), you will get a 0 as a result. Taking this into consideration, we can come up with a simple algorithm: cosLimit CosTransform redCosArray blueCosArray noneCosArray Red Blue None Dot Product Go through all our 3000 random points one by one. Create a vector from a 300x300 matrix with only one single point using DCT (Discrete Cosine Transform). Apply a dot product for this vector with , then with , and then with . redCosArray blueCosArray noneCosArray The greatest result out of the previous step will point us to the right answer: , , . Red Blue None The only missing functionality here is a Dot Product, let's write a simple function for it: func dotProduct(_ first: [Double], _ second: [Double]) -> Double {
    guard first.count == second.count else { return 0 }
    var result: Double = 0
    for i in 0..<first.count {
        result += first[i] * second[i]
    }
    return result
} And here is an implementation of the algorithm: var count = 0
while count < 3000 {
    let index = Int.random(in: 0 ..< allPoints.count)
    let point = allPoints[index]
    count += 1

    let testArray = math.shortArray(
        matrix: math.discreteCosTransform(
            for: [point],
            width: 300,
            height: 300
        )
    )

    let redResult = dotProduct(redCosArray, testArray)
    let blueResult = dotProduct(blueCosArray, testArray)
    let noneResult = dotProduct(noneCosArray, testArray)

    var maxValue = redResult
    var result: Category = .red
    if blueResult > maxValue {
        maxValue = blueResult
        result = .blue
    }
    if noneResult > maxValue {
        maxValue = noneResult
        result = .none
    }
    fillPoints.append(Point(x: point.x, y: point.y, category: result))
} All we need to do now is to draw an image from . Let's take a look at the train points we've used, DCT vectors we've created from our train data, and the end result we've got: fillPoints Well, looks like random noise. But let's take a look at the visual representation of vectors. You can see some spikes there, that's exactly the information we need to focus on and remove most of the noise from our DCT result. If we take a look at the simple visual representation of the DCT matrix, we will find that the most useful information (the one that describes the unique features of the image) is concentrated at the top left corner: Now let's take a step back and check the function once again. We use a parameter here exactly for the reason of taking the top left corner of the DCT matrix and using just the most active parameters that make our vector unique. shortArray cosLimit func shortArray(matrix: [[Double]]) -> [Double] {
    let height = matrix.count
    guard let width = matrix.first?.count else { return [] }

    var array: [Double] = []
    for y in 0..<height {
        for x in 0..<width {
            if y + x <= cosLimit {
                array.append(matrix[y][x])
            }
        }
    }
    return array
} Let's create our object with different : math cosLimit let math = CosTransform(cosLimit: 30) Now instead of using all 90,000 values, we will use just of them from the top left corner of the DCT matrix. Let's take a look at the result we've obtained: 30 x 30 / 2 = 450 As you can see, it's already better. We can also observe that most of the spikes that make Vectors unique are still located in the front part (as selected with green in the picture), let's try to use which means we will use just values out of 90,000 and check the result: CosTransform(cosLimit: 6) 6 x 6 / 2 = 18 It's much better now, very close to the original image. However, there is only one little problem - this implementation is slow. You wouldn't need to be an expert in algorithm complexity to realise that DCT is a time-consuming operation, but even the dot product, which has a linear time complexity, is not fast enough when working with large vectors using Swift arrays. The good news is that we can do it much faster and simpler in implementation by using from Apple's framework, which we already have as a standard library. You can read about , but in simple words, it's a set of methods for digital signal processing tasks execution in a very fast way. It has a lot of low-level optimisations under the hood that work perfect with large data sets. Let's implement our dot product and DCT using : vDSP Accelerate vDSP here vDSP infix operator •
public func •(left: [Double], right: [Double]) -> Double {
    return vDSP.dot(left, right)
}

prefix operator ->>
public prefix func ->>(value: [Double]) -> [Double] {
    let setup = vDSP.DCT(count: value.count, transformType: .II)
    return setup!.transform(value.compactMap { Float($0) }).compactMap { Double($0) }
} To make it less tedious, I've used some operators to make it more readable. Now you can use these functions in the following way: let cosRedArray = ->> redValues
let redResult = redCosArray • testArray There is a problem with the new DCT implementation regarding our current matrix size. It wouldn't work with our 300 x 300 image as it's optimised to work with specific sizes that are powers of 2. Therefore, we will need to put in some effort to scale the image before giving it to the new method. Summary Thanks to anyone who managed to read this text until now or was lazy enough to scroll through without reading. The purpose of this article was to show that many tasks that people don't consider solving with some native instruments can be solved with minimal effort. It's enjoyable to look for alternative solutions, and don't limit your mind to Python library integration as the only option for solving such tasks.

ML Tasks on Swift Without Python, Neural Networks and Libraries

পাইথন, নিউরাল নেটওয়ার্ক এবং লাইব্রেরি ছাড়া সুইফটে এমএল টাস্ক

ML-Aufgaben auf Swift ohne Python, neuronale Netze und Bibliotheken

Tareas de aprendizaje automático en Swift sin Python, redes neuronales y bibliotecas

Tâches ML sur Swift sans Python, réseaux de neurones et bibliothèques

पायथन, न्यूरल नेटवर्क और लाइब्रेरीज़ के बिना स्विफ्ट पर एमएल कार्य

Python、ニューラルネットワーク、ライブラリを使用しない Swift 上の ML タスク

Python, 신경망 및 라이브러리 없이 Swift에서 ML 작업

Tarefas de ML em Swift sem Python, redes neurais e bibliotecas

Задачи ML на Swift без Python, нейронных сетей и библиотек

Python, Sinir Ağları ve Kütüphaneler Olmadan Swift'de ML Görevleri

Nhiệm vụ ML trên Swift không có Python, mạng thần kinh và thư viện

无需 Python、神经网络和库的 Swift 上的 ML 任务

215 Stories To Learn About Twitter

Automated Vehicles or AVs are the buzz lately and so is artificial intelligence. What happens when you put those two together? We might have our very own ‘Kit’ the talking car from the 1980s show soon. Knight Rider Last week, Continental, the German automotive supplier, and the fourth-largest tire manufacturer tied up with Google Cloud to equip cars with generative (AI). With this, drivers can interact with their car in a natural dialogue. For example, if drivers need help finding the right tire pressure when the car is fully loaded or want to know more about local places of interest on their destination or along their route when they are on vacation, the generative AI can compile the required information and answer the drivers’ questions. Artificial Intelligence “Together with Google, we are bringing artificial intelligence to the vehicle cockpit and are creating an intuitive experience for drivers. Based on our Smart Cockpit High-Performance Computer, we expect our solution to be ready for production within just 18 months of development time. This is how our vision of software-defined vehicles starts to become a reality,” said Philipp von Hirschheydt, member of Continental’s Executive Board and head of the Automotive group sector, at the company’s IAA MOBILITY press conference. Together with Google, we are bringing artificial intelligence to the vehicle cockpit and are creating an intuitive experience for drivers Philipp von Hirschheydt, member of Continental’s Executive Board and head of the Automotive group sector , the globa in automotive market size was valued at US$312.46 million in 2022 and it is projected to be worth around US$2,691.92 million by 2032, poised to grow at a CAGR of 24.03% during the forecast period 2023 to 2032. According to Precedence Research l generative AI How Good is This AI? Google Cloud’s AI-powered system lets drivers actually talk with their cars. They can ask about hotels or tourist attractions along their route, and much more. The driver may want to know more about a specific historical building nearby. In this case, the system compiles detailed information in real-time and plays it back to the driver like an audio guide in a museum. The driver can also ask follow-up questions without repeating the whole context, Google Cloud’s conversational generative AI interprets the context correctly. Continental ensures that the system has access to specific vehicle information, such as the operating manual. This means it can even tell the driver where the USB port is or what the required tire pressure is when the car is fully loaded. Google Cloud’s generative artificial intelligence allows the system to constantly learn, create new content and adapt to the user’s preferences. What About Safety? Impressive, but will cracks appear in the system after the cars hit the road? In August, , was defending itself at a trial against allegations that the failure of its Autopilot driver assistant feature led to death. according to Reuters Tesla Recently, Founder Bill Gates expressed excitement for autonomous vehicles. “AVs will change transportation as dramatically as the PC changed office work,” . Microsoft he said in his blog post People might have their doubts about stepping into an AV, but if Bill Gates says so, we must be getting there. Other AV Tie Ups This year, up with Mercedes-Benz on plans to offer “super computer-like performance” in every car with automated driving sensors as it seeks to compete with Tesla. The German carmaker also wants to share revenue with semiconductor maker Nvidia to decrease the cost of purchasing expensive high-powered semiconductors. Google also teamed Other players have been walking onto the field too. Ford has been revamping its autonomous vehicle segment through its , with preliminary attention to a hands-free, eyes-off driver assist system for next-generation Ford vehicles. new venture Latitude AI The car manufacturer wants to invest more in Level 2/3 driver-assist tech, than a Level-4 robotaxi technology. Its L3 BlueCruise system, called the Active Driving Assistance (ADA) system, is “the simultaneous use of a car’s (ACC) to control speed and (LCA) to control steering”. adaptive cruise control lane centering assistance We are likely to see a lot more happening in this space as algorithms improve. This article was originally published by on Navanwita Bora Sachdev The Tech Panda.

From Knight Rider to Reality: Talking Cars are Here

নাইট রাইডার থেকে বাস্তবে: কথা বলা গাড়ি এখানে

Vom Knight Rider zur Realität: Sprechende Autos sind da

De Knight Rider a la realidad: los coches parlantes están aquí

De Knight Rider à la réalité : les voitures parlantes sont là

नाइट राइडर से हकीकत तक: बोलती कारें यहां हैं

ナイトライダーから現実へ: 話す車が登場

Knight Rider에서 현실로: 말하는 자동차가 여기 있습니다

Do cavaleiro à realidade: os carros falantes estão aqui

От «Рыцаря дорог» к реальности: говорящие машины уже здесь

Knight Rider'dan Gerçeğe: Konuşan Arabalar Burada

Từ hiệp sĩ kỵ sĩ đến hiện thực: Xe biết nói đang ở đây

从霹雳游侠到现实：会说话的汽车来了

267 Stories To Learn About Internet

Building .NET Document API Layouts Using Flat Element Hierarchy

In the rapidly evolving world of mobile application development, developers need to keep themselves updated with the latest tools and frameworks. is one such framework that has gained immense popularity among developers due to its ease of use and flexibility. In a previous article and , I shared a sample application that I created to showcase the “Experimental feature on Flutter,” which enables the creation of multi-entry Android application using the Flutter framework. However, with the , the framework has undergone significant changes since the initial version. In the current stable version 3.7.9, my sample app’s code looks significantly different. In this article, we will revisit the sample app, incorporating the fresher look and updated codebase, and provide an overview of the changes in the latest version of Flutter. Flutter its updated version continuous evolution of Flutter Problem Statement During my work on another Flutter project, I encountered an intriguing and somewhat unusual task. The project was required to function as a POS terminal on Android OS and other mobile devices but with a simplified version of the app that served as a regular application with a single-entry point on standard iOS and Android devices, without payments and bill printing. On the other hand, the extended fully functional POS-terminal version required a custom launcher, and the application was built and installed in such a way that it had multiple entry points leading to separated chunks of functionality, with no access from one point to another (for example, from catalogs to reports). While this is a specific case that currently only applies to Android, I found the Flutter GitHub Repository’s to be helpful at the beginning of my work. However, for some reason, it did not work correctly and caused problems with my project. wiki Although it is an experimental feature and an edge case in development, I decided to create a test application to make any future attempts easier. In the following pages, I will explain this test application and how it can be used to simplify the process of building multi-entry Android applications with Flutter. Test Application The test application that I created to simplify building multi-entry Android applications with Flutter consists of three pages, each with its own unique color, title, and buttons for navigation. These pages are named Amber, Blue, and Purple, and can be found on the AppBar. The application has three separate entry points while maintaining the same package name. The “1 Amber” entry point leads to the limited functionality with the Amber page only. The “1 Blue”  entry point leads to the limited functionality with the Blue page only. The “1 Purple” entry point leads to the Purple page only. The “All 3 colors” is a fully functional application with 3 screens and interaction in between This structure allows for a clear separation of functionality, with each entry point leading to a different set of features. The View Steps To Reproduce Creating a simple Flutter application with multiple entries is a straightforward process that can be accomplished by following a few simple steps. To get started, you can follow the guide provided in this article. Alternatively, you can clone my sample application, which is referenced in the footer of this article, to see an example of how it can be done. Lets dive into the to define the flavors we build: Android code To implement multi-entry functionality in our Flutter application, we need to define two or more build flavors in the file. For the purposes of this article, I have created two build flavors: “single” and “multiple”: app/build.gradle productFlavors {

    multiple {
        dimension "app"
        versionCode 1
        versionName "1.0.0"
    }

    single {
        dimension "app"
        versionCode 1
        versionName "1.0.0"
    }
} For each build flavour, we need to create a dedicated directory within the project structure. The directory structure will look something like this: The “main” directory in Android codebase will contain general resources and a simple entry point, but it will not be used for the build process. On the other hand, the “multiple” directory will contain multiple implementations of the BaseActivity, which is responsible for defining the entry point name for the Flutter application: abstract class BaseActivity : FlutterActivity() {

    abstract var entryPoint: String

    override fun getDartEntrypointFunctionName() = entryPoint

    override fun configureFlutterEngine(@NonNull flutterEngine: FlutterEngine) =
            GeneratedPluginRegistrant.registerWith(flutterEngine)
} In the “single” directory there is only one AllColorsActivity, which is a fairly generic implementation: class AllColorsActivity : FlutterActivity() {} The final step on the Android side of our multi-entry Flutter application is to declare the activities in the AndroidManifest file, with a separate title for each entry point: <activity
    android:name=".AllColorsActivity"
    android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
    android:exported="true"
    android:hardwareAccelerated="true"
    android:label="All 3 colors"
    android:launchMode="singleTop"
    android:theme="@style/LaunchTheme"
    android:windowSoftInputMode="adjustResize">
    <meta-data
        android:name="io.flutter.app.android.SplashScreenUntilFirstFrame"
        android:resource="@drawable/launch_background" />

    <meta-data
        android:name="io.flutter.embedding.android.NormalTheme"
        android:resource="@style/NormalTheme" />
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity> As you develop your application in Android Studio, it’s crucial to create distinct build configurations for situations involving single and multiple entries. Remember, the last step in this process is just as vital as the first: is simple and very intuitive, while some code is just created for better feature showcasing. The Flutter part In the main.dart file, create the main entry point along with a few alternative entry points, as demonstrated in the code. To prevent TreeShaking in release mode, make sure to mark the alternative entry points with the annotation. @pragma(‘vm:entry-point’) void main() => runApp(
      MultiEntryApp(
        initialRoute: defaultRoute,
        primaryColor: Colors.blueGrey,
      ),
    );

@pragma('vm:entry-point')
void amber() => runApp(
  MultiEntryApp(
    initialRoute: amberRoute,
    primaryColor: Colors.pink,
  ),
); In our multi-entry Flutter application, each entry point starts with its own route name, making route generation much simpler. The key to this functionality lies in the routes generation, which limits accessibility to some screens for each specific entry point. By defining routes in this way, we can ensure that users are only able to access the screens that are relevant to their entry point, providing a clear and intuitive user experience: const String defaultRoute = "/";
const String amberRoute = "/amber";
const String blueRoute = "/blue";
const String purpleRoute = "/purple"; The code for route generation may not be the most elegant or sophisticated, but it is simple and easy to understand: Route<dynamic> generateRoute(RouteSettings settings, String initial) {
  switch (initial) {
    case blueRoute:
      return CupertinoPageRoute(builder: (context) => BluePage(false));
    case purpleRoute:
      return CupertinoPageRoute(builder: (context) => PurplePage(false));
    case amberRoute:
      return CupertinoPageRoute(builder: (context) => AmberPage(false));
    default:
      return _allRoutes(settings);
  }
} And with that, we have covered all of the key components of building a multi-entry Flutter application. Important Notes To prevent entry points in our Flutter application from being removed during the tree-shaking process, it is important to annotate them with the annotation. This tells the compiler to keep the entry points in the final executable, ensuring that they are available for use by the application. @pragma(‘vm:entry-point’) To ensure that our multi-entry Flutter application routes correctly and avoid any confusion, it is recommended to use initialRoute: “/”’ in the MaterialApp. In earlier versions of Flutter, using Experimental feature could potentially cause issues with the SplashScreen. However, and future versions, this is no longer a problem, as the Splash screen is now defined in the activity meta-data by using ‘io.flutter.app.android.SplashScreenUntilFirstFrame’. starting from Flutter v1.12 Summary In summary, while the techniques and approaches discussed in this article may not work for every situation or project, they provide valuable insights into the process of building a multi-entry Flutter application. It is important for developers to remain flexible and adapt to the needs of the project and the users. By sharing our experiences and insights, we can encourage others to explore the possibilities of Flutter and push the boundaries of mobile application development. https://github.com/VadymPinchuk/multiple_entry?embedable=true Also published here

Developing Multiple-Entry Android Apps With Flutter's Experimental Feature

Stories, News & Mentions about BLUECREW

Bluecrew’s Stories on HackerNoon