Bluecrew is an on-demand staffing platform for temporary workers

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

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

Web development without ready-to-use UI libraries wouldn't be as fast and efficient. You may argue that you're an HTML/CSS ninja, and I believe you because I am too. Nonetheless, it's still cool to use predefined stylish components, and that's why we are looking for some beautiful UI libraries. My name is Mikhail Isaev, and I'm the author of framework. Today, I'm going to tell you about the framework and how to use it with SwifWeb. Let's begin! SwifWeb MaterializeCSS What is it? MaterializeCSS is a modern responsive front-end framework based on which was created by Google to combine the classic principles of successful design along with innovation and technology. I enjoyed writing a wrapper for this framework because it is very easy to use! open-source Material Design How to install? If you are new to SwifWeb then you have to create new project using the Webber CLI tool. In the project open Package.swift and edit the section to make it look like this: dependencies dependencies: [
    // the rest of the other dependencies incuding swifweb/web
    .package(url: "https://github.com/swifweb/materialize", from: "1.0.0"),
] Next edit to make it look like this: executableTarget .executableTarget(name: "App", dependencies: [
    .product(name: "Web", package: "web"),
    .product(name: "Materialize", package: "materialize")
]), Then open and configure in method like this: App.swift Materialize didFinishLaunching Lifecycle.didFinishLaunching {
    Materialize.configure()
} You will face missing styles if you forget to configure it 🙃 Custom Theme: If you generated a custom Materialize style from SCSS then configure it this way: Lifecycle.didFinishLaunching { app in
    Materialize.configure(avoidStyles: true)
    app.addStylesheet("/css/custom-materialize.min.css")
} Add your custom style into /Sources/App/css/custom-materialize.min.css open and declare resources in as follows: Package.swift executableTarget .executableTarget(name: "App", dependencies: [
    .product(name: "Web", package: "web"),
    .product(name: "Materialize", package: "materialize")
], resources: [
    .copy("css/custom-materialize.min.css"),
    .copy("css")
]), Now you are ready to start building the UI! Components I have beautifully wrapped all the components into Swift, but the article would be too long if I were to describe all of them. Let me examine a few of them here, and you can refer to the for the rest. readme on GitHub Buttons You can make any element as material button just by calling method. .materialButton(...) element can be used for links, and or other elements can be used with handler. A Div onClick Div("My Button")
    .materialButton(type: .raised)
    .onClick {}
A("My Link")
    .href("https://google.com")
    .materialButton(type: .raised) Both elements will look same, the only difference is that is a link and will act like a link. A Method have few options: .materialButton can be type raised, floating, floatingHalfWay, flat can be size small, large can be or custom, by default waves light, red, yellow, orange, purple, green, teal light is just a flag to mark button disabled, pass @State value here to change it on the fly disabled Also you can add a material icon to it simply by calling .addMaterialIcon(...) .addMaterialIcon("announcement")
// or optionally
.addMaterialIcon("announcement".size(.tiny).side(.right)) Find more about the material icon below. Floating Action Button It is a fixed floating action button with multiple actions. Read more about it . in the official docs FloatingActionButton(icon: "add", color: .pink)
    .item(icon: "public", color: .red)
    .item(icon: "adb", color: .purple)
    .item(icon: "announcement", color: .blue) {
        Toast.show("Announcement!")
    } Optional arguments can be and , it is by default size large small large can be or custom, by default waves light, red, yellow, orange, purple, green, teal light can be , it is by default direction top, right, bottom, left top can be it is by default mode hover, click, toolbar hover Control it programmatically: lazy var fab = FloatingActionButton(...)
fab.open() // to show the menu/toolbar
fab.close() // to show the menu/toolbar
fab.isOpen // the check if it is open Icons You can add an icon anywhere by initializing the object. MaterialIcon This object accepts icon as the initializer argument. List of the icon types is available . type here MaterialIcon("announcement") You can change icon type on the fly later by calling method on it. .type(...) Optional methods accepts .size(...) tiny, small, medium, large accepts .side(...) left, right All the methods can accept reactive @State value, so you can change the icon and its properties on the fly. Colors All colors that are listed are available including their modifiers. in the official documentation Text Color Span("Hello").textColor(.red)          // just red color
Span("Hello").textColor(.red.lighten3) // red color with lighten-3 modifier
Span("Hello").textColor(.red.darken4)  // red color with darken-4 modifier Background Color Div().materialBackground(.red) // just red color
Div().textColor(.red.lighten3) // red color with lighten-3 modifier
Div().textColor(.red.darken4)  // red color with darken-4 modifier
// or
Div().red()
Div().red(.lighten3)
Div().red(.darken4) Grid The main thing in grid is which has its width and optional modifiers. Column offest, push, pull Container {
    Row {
        Column(.small(.one)) { "1" }  // <div class="col s1">1</div>
        Column(.small(.one)) { "2" }  // <div class="col s1">2</div>
        Column(.small(.one)) { "3" }  // <div class="col s1">3</div>
        Column(.small(.one)) { "4" }  // <div class="col s1">4</div>
        Column(.small(.one)) { "5" }  // <div class="col s1">5</div>
        Column(.small(.one)) { "6" }  // <div class="col s1">6</div>
        Column(.small(.one)) { "7" }  // <div class="col s1">7</div>
        Column(.small(.one)) { "8" }  // <div class="col s1">8</div>
        Column(.small(.one)) { "9" }  // <div class="col s1">9</div>
        Column(.small(.one)) { "10" } // <div class="col s1">10</div>
        Column(.small(.one)) { "11" } // <div class="col s1">11</div>
        Column(.small(.one)) { "12" } // <div class="col s1">12</div>
    }
    Divider()
    Row {
        Column(.small(.twelve)) { "screen-wide" }
        Column(.small(.six)) { "one-half" }
        Column(.small(.six)) { "one-half" }
    }
    Divider()
    Row {
        Column(.small(.twelve)) { "12-columns" }
        Column(.small(.six, offset: .six)) { "6-columns at the right" }
    }
    Divider()
    Row {
        Column(.small(.seven, push: .five)) { "7-columns pushed to the right" }
        Column(.small(.five, pull: .seven)) { "5-columns pulled to the left" }
    }
} The examples above are 1:1 like in the official documentation, so you can just compare. You can set more than one size class to a Column: Column(.extraLarge(.twelve), .large(.ten), .medium(.eight), .small(.six)) Alignment Vertical Align VAlignWrapper {
    H5("This should be vertically aligned")
} Text Align H5("This should be left aligned").leftAlign()
H5("This should be right aligned").rightAlign()
H5("This should be center aligned").centerAlign() Quick Floats Div().floatLeft()   // Quickly float things to left
Div().floatRight()  // Quickly float things to right
Div().floatCenter() // Quickly float things to center Hiding/Showing Content Div().hideOnSmallOnly()     // Hidden for Mobile Only
Div().hideOnMedOnly()       // Hidden for Tablet Only
Div().hideOnMedAndDown()    // Hidden for Tablet and Below
Div().hideOnMedAndUp()      // Hidden for Tablet and Above
Div().hideOnLargeOnly()     // Hidden for Desktop Only
Div().showOnSmall()         // Show for Mobile Only
Div().showOnMedium()        // Show for Tablet Only
Div().showOnLarge()         // Show for Desktop Only
Div().showOnMediumAndUp()   // Show for Tablet and Above
Div().showOnMediumAndDown() // Show for Tablet and Below
Div().pinned()              // Pins element Formatting Truncation H4("This is an extremely long title").truncate() // also with @State Hover This feature adds an animation for box shadow on hover. Card().hoverable() // also with @State Browser Defaults You can revert element styles to the original state. Ul().browserDefault() Images Responsive Images Img().src("cool_pic.jpg").responsive() // resizes responsively to page width Circular images Img().src("images/yuna.jpg").circle() // square image that appears circular Videos Responsive Embeds Div {
    IFrame(...)
}.videoContainer() Responsive Videos Video {
    Source().src("movie.mp4").type("video/mp4")
}.responsive() Navbar Navbar {
    A("Logo")
        .floatLeft()   // align left
        .floatRight()  // align right
        .floatCenter() // align center
}
.deepPurple(.lighten4) // background
.left()                // left aligned links
.right()               // right aligned links
.item("Sass", href: "/sass")
.item("Components", href: "/badges")
.item("JavaScript", active: true, href: "/collapsible") // as active
// dropdown menu
.dropdownItem("More", background: .white, hover: false) {
    DropdownItem("Dropdown 1", color: .red) { Toast.show("Hi") }
    DropdownItem("Dropdown 2", href: "")
} Cards Card("Card Title")
    .blueGrey(.darken1)
    .textColor(.white)
    .message("""I am a very simple card.
    I am good at containing small bits of information.
    I am convenient because I require little markup to use effectively.
    """)
    .action("THIS IS A BUTTON") {}
    .action("THIS IS A LINK", href: "#") Preloader Circular PreloaderCircular(colors: .blue, .red, .green, .yellow).active() Indeterminate PreloaderLinearIndeterminate() Determinate @State var value: Double = 20 // change it to update the progress
PreloaderLinearDeterminate($value) Pagination Pagination()
    .back(disabled: true, icon: "chevron_left") {}
    .item(1, href: "#1")
    .item(2, href: "#2")
    .item(3) { Toast.show("Going to 3!") }
    .forward() { Toast.show("Going forward!", rounded: true) } That’s It All right, I described about ~20% of the framework. If you are familiar with Materialize CSS you may notice that its representation is much easier to use! Swift Wanna learn more? Stay tuned for the upcoming articles! Don’t hesitate to ask any questions and feel free to contribute! in our Discord

SwifWeb Libraries: Materialize CSS

সুইফওয়েব লাইব্রেরি: CSS মেটেরিয়ালাইজ করুন

SwifWeb-Bibliotheken: CSS materialisieren

Bibliotecas SwifWeb: materializar CSS

Bibliothèques SwifWeb : matérialiser le CSS

SwifWeb लाइब्रेरीज़: CSS को मटेरियलाइज़ करें

SwifWeb ライブラリ: CSS のマテリアライズ

SwifWeb 라이브러리: CSS 구체화

Bibliotecas SwifWeb: Materializar CSS

SwifWeb Kütüphaneleri: CSS'yi Gerçekleştirin

Thư viện SwifWeb: Vật chất hóa CSS

SwifWeb 库：Materialize CSS

“A wise ninja does not seek out an enemy who he does not fully understand." - Splinter from Teenage Mutant Ninja Turtles As a technical writer passionate about science fiction, one of the most exciting parts of my job at Sonatype is when I have the opportunity to collaborate with the security research team. Ever since we found that correspond to what we call RAT mutants—novel malware that leverages the capabilities of remote access trojans and information stealers—our security researchers have had a nagging sense of déjà vu. a series of Python packages last month It’s not a rare occurrence: they constantly assess hundreds of suspicious packages from open-source registries to determine if they’re truly malicious. During this procedure, they identify familiar patterns between the packages, and sometimes, upon recognizing strong similarities, they conduct further research to track down the actor/campaign behind them. Between the last week of 2022 and the beginning of 2023, our AI system flagged suspicious packages uploaded to the PyPI registry including and . Our security researchers looked at them and confirmed they were indeed malicious. And after further analysis, they noticed these packages added a series of features not often seen in Python malware. pyrologin , easytimestamp , discorder , discord-dev , style.py , pythonstyles In what has become a de facto strategy, bad actors hide a payload in the file so developers only have to use a simple pip install to get infected. In this case, they’d be inadvertently launching a PowerShell script that downloads a ZIP file to install libraries that let the attacker control the victim’s mouse, the keyboard, take screenshots, and create hidden remote connections. And on top of that, these packages also exfiltrate sensitive information like passwords, cookies, and cryptocurrency wallet data, and even try to install a tool for remote access. Our findings were in line with of the very same packages. setup[.]py Phylum’s technical report Nevertheless, security researcher Carlos Fernandez was having a haunting sense of déjà vu. During the week after we disclosed the packages, memories of having seen earlier versions of this malware flashed through his mind. A threat actor might have been evolving their malware through time, but we needed to make sure, so I put my OSINT hat on to help him see if there was any truth to his intuition. The Origin Story Looking back on our database, on September 25, 2022, a package called was uploaded to the PyPI repository. Our AI flagged it as suspicious and our security researchers confirmed that it contained malware and that it bundled the sources of another package called . Both libraries were authored by , aka BillyTheGoat, aka BillyV3 (with contributions from loTus04 and BlueRed). This author from France (at least that’s what his location in GitHub and the language spoken through his Discord channels suggest) is credited as the person behind , a Python obfuscator that we’ve found often in recently uploaded malware, as well as one of the creators of , an information stealer that’s been active since July in an to open registries. pygradient pystyle billythegoat356 Hyperion W4SP stealer ongoing supply chain attack W4SP stealer boasts persistency (it gets reactivated every time users restart the PC), obfuscation (the author promises it’s fully undetectable), and steganography techniques to hide polymorphic and highly-obfuscated payloads within an image file. The malware sends all the victim’s Discord accounts, credit cards, passwords, and crypto-wallets back to the attacker through a hard-coded Discord webhook address. Bad actors interested in this malware have purchased it by paying about 20 USD in crypto. Originally, did not have a malicious nature—a harmless package to style and color console output to enhance readability and user experience. But according to Phylum research, once it became popular (the package is still active on PyPI and it accumulates more than 40,000 downloads every month), they decided to add W4SP malware in a couple of releases. pystyle Open-source packages like can act as sleeper agents for months only to be activated later by their own author for malicious purposes. A risky move, since their popular package can be discovered by security researchers like us who’ll report it as malicious and have it be taken down forever. That’s why they often create new packages instead where they include the source code of an innocuous library, add some type of malicious payload, and upload it under a new name: something generic, benign-sounding, innocent-looking. A name such as . pystyle pygradient After taking a closer look with Carlos, we found this proto-RAT mutant malware lacked some of the features of the December versions: even though it also launched a PowerShell script and exfiltrated sensitive data, it didn’t use base64 encoded payloads or an allowlist txt file to avoid self-infection. In a way, it was a milder, less sophisticated variant. But then we looked at early-November uploaded packages, including , , and , and after diving deeper, we found confirmation of our suspicion: the malware was truly evolving. paintpy devicespoof devicespoofer A Copycat Chasing Malware Even though BillyTheGoat hasn’t been active on GitHub since November, we’re still finding malware that’s based on his creations or stealing directly from them, mostly by a user that’s apparently based in Portugal called . zeeckt This user uploaded a recently removed package in PyPI called , falsely credited to BillyTheGoat in what looked like —a technique to increase the reputation of their new package by linking it to a popular GitHub library, thus getting associated with its hundreds of stars and forks. pystilez StartJacking Checkmarx this bad actor after finding a W4SP attack in a package called (along with similarly-named variations) that included a Discord server link within their malicious code. The administrator profile linked to a verified Steam account and the name “zeeckt” appeared as one of the attacker’s Steam aliases. has been tracking apicolor also reported that this threat actor was creating fake users by copying the profiles of popular GitHub accounts to increase legitimacy. And one of their victims decided to create warning people about this attack after falling for one of their fake profiles. Check Point a YouTube video A security researcher posted one of zeeckt’s payloads for educational purposes and he received an interesting reply from the co-author of W4SP stealer: How ironic for your stealer to be stolen. The same author, apparently a 17-year-old Python developer, reiterates his frustration in a README file on his GitHub profile: We don’t know exactly what malicious code zeeckt has stolen from other bad actors, but one thing is certain: that name continues to pop up in malware campaigns across open-source registries. Sneakier Variants Gnaw Away at Your Crypto Wealth Carlos recently found four more packages by : , and . After further investigation, he tagged them as malicious and reported them to PyPI to be taken down. The fastest case took about 20 minutes from publication to deletion. zeeckt forenitq forenith , forenity forenitz Looking at in Carlos found the following first-stage payload: setup[.]py forenitq , The attacker creates three temporary files that download and execute Windows binaries from specific URLs using the "start" command. Even though the slugs and are suggestive of malicious intent, we couldn’t confirm that assumption without looking under the hood. /rat /clip At the time of this writing, the page hosted at is still active and it only shows a link to a Discord invite that’s already expired or private. hxxp://20[.]226[.]18[.]203 Carlos noticed that the package was posing as the popular package, using their metadata for a possible StarJacking attempt. Colorama After deobfuscating the RAT file, he found a line that loads a possible clipboard hijacker, but the specifics of it were base64 encoded: Upon decoding, we get a Python code designed to hijack a victim's clipboard to replace the intended cryptocurrency wallet address with the attacker's address: It looks for specified patterns like (bc1), (0x), Monero (4), and l (L or M or 3), and when a pattern is found, it replaces the intended address with the attacker's cryptocurrency wallet address. bitcoin Ethereum itecoin The code uses the library to copy and paste clipboard data. It will install the library if it’s not already installed and then copy the cryptocurrency wallet address to the clipboard. The code is then set on a continuous loop to monitor the clipboard for wallet address patterns. pyperclip Additionally, we uncovered more techniques this RAT mutant uses to evade detection: a first-stage payload added to the file instead of and a second-stage polymorphic payload that changes every time you run the binary. forenitq/ansi[.]py setup[.]py The attacker also added a new command and control with a very complete help menu—and this time se fala português: As you can see, malicious actors are eager to steal your crypto funds and system credentials to further penetrate your infrastructure. Their RAT malware keeps mutating to be more evasive and damaging to developers. So, if you're not safeguarding your software supply chain today, consider taking action to do so as soon as possible. IOCs (Indicators of Compromise) hxxp://20[.]226[.]18[.]203/inject/tCxFLYLT6ViY9ZnP hxxp://20[.]226[.]18[.]203/clip hxxp://20[.]226[.]18[.]203/rat

How RAT Mutants, in Python, Steal Data and Evade Detection

কিভাবে RAT মিউট্যান্ট, পাইথনে, ডেটা চুরি করে এবং সনাক্তকরণ এড়িয়ে যায়

Wie RAT-Mutanten in Python Daten stehlen und sich der Erkennung entziehen

Cómo los mutantes RAT, en Python, roban datos y evaden la detección

Comment les mutants RAT, en Python, volent des données et évitent la détection

पायथन में आरएटी म्यूटेंट कैसे डेटा चोरी करते हैं और जांच से बचते हैं

RATミュータントがPythonでデータを盗み、検出を回避する方法

Python에서 RAT 돌연변이가 데이터를 훔치고 탐지를 회피하는 방법

Como os mutantes RAT, em Python, roubam dados e evitam a detecção

Python'da RAT Mutantları Verileri Nasıl Çalıyor ve Tespitten Nasıl Kaçıyor?

Cách RAT Mutants, trong Python, đánh cắp dữ liệu và trốn tránh sự phát hiện

RAT 突变体如何在 Python 中窃取数据并逃避检测

A Guide to Creating Fun User Polls and Surveys With QuickBlox in Your Flutter App

Inside Musk's Social Circle: Yes-men, Media Personalities, and (a lot of) right-wing VCs

Dentro del círculo social de Musk: sí-hombres, personalidades de los medios y (muchos) capitalistas de riesgo de derecha

À l'intérieur du cercle social de Musk : les hommes du oui, les personnalités des médias et (beaucoup) les VC de droite

मस्क के सोशल सर्कल के अंदर: हाँ-पुरुष, मीडिया हस्तियां, और (बहुत सारे) दक्षिणपंथी वीसी

Musk のソーシャル サークルの内部: イエスメン、メディアパーソナリティ、および (多くの) 右翼 VC

Dentro do Círculo Social de Musk: sim-men, personalidades da mídia e (muitos) VCs de direita

Bên trong vòng kết nối xã hội của Musk: Yes-men, Media Personalies, và (rất nhiều) nhà đầu tư mạo hiểm cánh hữu

马斯克的社交圈内幕：应声虫、媒体名人和（很多）右翼风投

Top Software Development Companies 2022 That Are Growing Fast

This story is a part of Hacker Noon's series of interviews. The series is intended for tech professionals contributing the most insightful Hacker Noon stories to share more about their writing habits, ideas, and professional background (and maybe a hobby or two). If you too would like to start contributing to Hacker Noon, you can do so . Meet the Writer here So let’s tell us a bit about yourself. For example, name, profession, and personal interests. Hello, dear Hackernoon readers. My name is kinda weird Slavic one. Ladislav. Weird in a sense that neither I nor any fellow Slavic has any idea what the hell short form of Ladislav is. As for interests. I love anything creative. My biggest success perhaps is my behavioral zero-day exploit blocker that protects hundreds of millions of computers as we speak ever since ESET nod antivirus v 5. I wrote the patent worked hard to implement and release it safely to the world on millions of computers without bluescreens. Yet my patent was stolen by the company while I was nearly dead in hospital after a paragliding accident. Yes… East Europe is definitely not a Silicon Valley. Yet. I don’t believe that there is such a thing as bad people. Just bad software. I.e way too many generations had been raised in an environment without moral examples.  But recently, luckily, Covid made me unemployed, and shackles of my creativity were (unfortunately for you, my dear readers ;D) finally released. Yay. In a sense, this Covid period opened my eyes. Now I finally understand why so much of math or philosophy was discovered in ancient Greece. Creative new ideas are now are swirling in my head pretty much every day. Ideas that I had never time to think about due to exhaustive daily jobs occupying my brain potential on boring and repetitive tasks. Don’t you ever wonder why is it that most of mathematics physics philosophy cornerstones were invented in this ancient but relatively short part of our history? Followed by pretty much just a few blips here and there?. I believe that the key to this was to allow extremely large population freedom to occupy their brain with other things than just delivering food and shelter. The majority of Ancient Greece was essentially a bunch of unemployed folks contemplating the universe’s inner workings and such since someone else did the boring repetitive work for them. Why I am mentioning this.? I feel like humanity’s second renaissance is coming. Why? Well, every time a major event like Covid or AI and automation taking the majority of repetitive boring jobs happens. The universe splits into many but usually just two major branches depending on how clear-cut the nearest probabilities for other outcomes were. I suppose in 50/50 like cases Kazimir effect tips the scales causing the butterfly effect. So. Let’s pretend that we will continue for a bit in this optimistic fork of this universe. A fork where we soon will have AI and robots doing most of our manual, repetitive work, with us being all on universal income finally using our brains in more creative ways like in ancient Greece. Covid, in a sense, accelerated this transition with another payment from the government coming soon.  And as for the less optimistic branch of this universe’s fork. Luckily we have Elon for scaring the doors from us. Interesting! What was your latest Hackernoon Top story about? My last story was a crazy idea that I got one night and was super excited about, and immediately messaged to like half of SpaceX and asked them what they think about it. As . (So now I have like 10 SpaceX connections that can’t talk to me due to either NSA orders or the idea being too stupid). With both being equally probable. you do But In short. It just baffled me why we still keep building thin 130m tall and unstable rockets and then wait for good weather or government approval. So I proposed a starship transformer. The ship has the same volume but height of just 10m during start or landing. It, therefore, does not require any special towers not is it any longer fixed to time(weather) or place. Essentially, It could transform to a tall falcon-heavy-like upright supersonic configuration on demand. Do you usually write on similar topics? If not, what do you usually write about? It’s hard to say since I am fascinated by so many things. Take, for example, our recent rapid advancements in the u of every living thing around us. And gene editing with Omega in particular. Did you know that 70% of mosquitos’ DNA is the same as yours and it is not a coincidence? Thing is. Life is pretty much a bunch of so far 3 types of programable (cells) with mostly the same code over and over. nderstanding of the genome nanobots So right now, I am writing a new story about how radically we can change the world by flipping a few homeobox-like gene bits in the DNA of Bamboo to control its size, shape, and direction. Why Bamboo? Well, Bamboo has strength and weight rivaling carbon fiber and, more importantly, can grow 1m a day even without tweaks. Unfortunately still has hardwired dimensions. ;D So with that little DNA tweak, you can essentially not build but grow green-sustainable, recyclable houses skyscrapers, and due to the parallel nature, even whole cities in a week. Branches solve traffic congestion by moving in the dense 3D mazes without the high energy cost of flying, and energy collection is already built-in in a pretty large surface of ever-present  leaves. Engineer nets will grow even thru the strongest granite via an unstoppable army of strong roots. And all of that with just a flip of a few bits. Great! What is your usual writing routine like (if you have one?) For me, I usually get super excited about something. Then it pretty much goes downhill with this weird drive of mine to share emotions and excitement and such. You know … Of the magic moment. And. If the is not at that particular moment at the wheel, then I start immediately to write everything down. I keep adding a lot of ideas in pure, unfiltered flow. You never know what branches lead where. Then I filter them thru good old google to see  how much of a wheel I am just reinventing. procrastination monkey In reality, a lot of these secondary ideas are usually either similar ideas with different wording or just way too much noise about nothing. So finally, my favorite Occam's razor jumps in, helping to distill just the best parts in the most succinct way possible since people rarely read past 3rd minute. And since English is not my first language In the final phase, I try to do my best to hide it ;) Being a writer in tech can be a challenge. It’s not often our main role, but an addition to another one. What is the biggest challenge you have when it comes to writing? According to famous Professor and Neuroscientist at Stanford University Andrew Huberman, . The creativity of our brains is essentially a bunch of hamsters on wheels. And they pretty much run on dopamine.  Rare stuff that is naturally produced when you are in an equally rare state of happiness. Especially rare if you are stuck in east Europe. Luckily there are a few other ways to get it. I don’t do drugs obviously. Then there is sex. But that is out of the question since I am butt ugly. Still, I wish to have children one day and watch them grow. I guess my next respawn in this simulation. It’s quite simple actually So what is left for me is pretty much dopamine cheap offshoot adrenaline. Stuff I get from motorcycles paragliding or being broke and not filing tax reports in time. Endorphins I get from exercise or running. Or if you are not spoiled, a jam or Nutella will do wonders too and lasts ages. Thankfully I am getting crazy new ideas once a week, which produces a day or two of excitement and endorphins too. What is the next thing you hope to achieve in your career? Exploring  crazy and fun ideas and hoping one day to implement them is fun and all. But what I really hope for right now. Is to find someone who will help finish the reusable particle-based ; Without filters or advice, I am stuck. Considering what I am trying to do and that so far, even a panel of respected judges and virologists didn’t find a major reason why it wouldn’t work; it still baffles me that nobody wishes to help. covid test I passed to the semifinals in XPrize It’s times like these when I am starting to believe I am in some kind of weird simulation. I mean, the cost of filters I need is out of my reach yet it is way less than someone pays for breakfast daily.  The optimist in me says that perhaps I am just struggling to get a word around. Why I am so focused on that covid test so much now over a year?. To be frank, considering the state we are in, not many things make more sense to me as having higher priority. Wow, that’s admirable. Now, something more casual: What is your guilty pleasure of choice? No Idea. I have always been poor. I always dreamed about traveling the world though. Or have money to start building my own variant of and fly. And by flying, I mean really fly. Like with moving powerful hydraulics copying every slightest move or even hint of your  arms or hands. So you can clearly see now that my biggest guilty pleasure is that with my brain being free again I started dreaming again ;) 12m wide foldable hydraulic wings Do you have a non-tech-related hobby? If yes, what is it? I am fanatically attracted to the ancient history of and life in general. I traveled a bit too. Then I am way too often attracted to new papers in fields I am not supposed to. I know. I know. Hereby dragons.  Not that I understand a thing. But curiosity knows no boundaries. Like the very recent fascinating new OMEGA gene editing advancements. And despite not being able to absorb or grasp all their content. There is still a lot of fancy pictures too. A lot of fun. DNA If I oversimplify it a bit. The scientists are, in a sense, writers too and are usually preparing their papers for the most efficient consumption. So the well-written paper usually has a very short but punctual condensed intro, and conclusion sections with plenty of fancy self-explanatory charts sparkled throughout. Yes, you need to possess at least a basic engineering decoding toolkit for something to stick. And something what Stanford psychology professor Carol Dweck calls a growth mindset--The belief that you can grow and develop skills and abilities you didn't have before. But in my humble opinion, in this age, where every major educational information is public and found in seconds. An engineer is perhaps no longer only defined by which prestigious school he had taken but by his mindset. I.e., how he searches, processes, filters, and absorbs and combines that information with what he already knows. Especially how often he seeks and absorbs new information. And there are so many fascinating things happening as we speak in biology, genetics, computer graphics, or info. neural networks covid related What can the Hacker Noon community expect to read from you next? I am in the middle of a Bamboo software hacking article. To search for this elusive homeobox gene location, I currently have a lot of fun with searching DNA on GPU via 10 lines of Webgpu. Why Webgpu? First. Webgpu is HOT. I mean common. WebGL is so yesterday. Second. So article readers who are on HN, mostly programmers, will be able to do it themself in a browser too. And let’s face it. Which programmer would resist being able to massively accelerate their code in the 10 lines? The world of biology and genetics (or the world of nanobots as I call it) is so exciting. So much fun. Thanks for taking the time to join our “Meet the writer” series. It was a pleasure. Do you have any closing words? Thanks for stopping by. And those of you who wish to with the reusable test, especially before spring starts. 80nm-120nm Filters and Filter sealing design advice would be helpful. I am also pretty sure my design has a lot of flaws. But that is not the point. Nothing exists in v 1.0. We need to keep working on hourly reusable decentralized cheap test iteration after iteration. Since vaccinating the whole world is currently financially, politically, and logistically pretty much impossible. The More brains and hands-on-deck, the faster the progress. Let’s find a way to stop Covid together. join forces and help with stopping this covid nightmare

Meet the Writer: Hacker Noon's Contributor Ladislav Nevery, Innovator

This tweeted published on twitter.com by a bluecheckmark-less has since been deleted. @Naval His other recent meta tweet about Twitter was as glowing as an Godaddy celebrity testimonial in a 1999 Super Bowl commercial. I mean I dig Twitter as much as the next cat, but it's not exactly like everyone is getting 9k RTs, including by the platform's CEO. Every single tweet costs something. Your time. And Twitter has created quite the place, millions spend time to reach people there. Other places on the internet can also do that. A decentralized publishing API may be a good place to start, so that users (aka publishers) can publish their thoughts (aka tweets) on many sites, apps, and whatever people read on next. And how does the Twitter verification system work? The company's official position is that it is not adding any more blue checkmarks, and by not verifying Naval they are adhering to that, but in the meantime the tweet's been deleted, and friends of the company can always add a bluecheck whenever they like. If you have to ask, you don't have the right friend. "Outside looking in" has always been essential to the rise of digital communities.  By "outside looking in," I mean social networks, especially young social networks, can grow by marketing manufactured exclusivity.  And at the sametime, they can market the ability to reach anyone in the world. Oh the internet! "Be so wrong that they have to verify you." I'm not wrong. I'm not right. I'm not Twitter famous. But can you just, tell a friend, to please verify Naval?

"Be so wrong that they have to verify you."

What is "Infrastructure as Code"? If someone checks a bunch of YAML files into a Git repository, do they suddenly become code? That seems more like "Infrastructure as Files" to me. I suppose that's better than infrastructure as a gaggle of shell scripts and some commands run by hand in the middle of the night in a coffee-fueled haze, but it is a far cry from code. How about a system to define infrastructure that really is like code? How about a system to define infrastructure that really is like code? Real code -- well-written code -- uses concepts that are largely absent from today's Infrastructure as Code technologies. These concepts are abstraction, modularity, composability, and reusability. In code, you can import a library (reusability) and use its functionality to build your own library (composability). Moreover, you don't need to know the implementation of the library to use it (abstraction). You can even divide up the coding effort among different teams by agreeing on an interface (modularity). If we really had Infrastructure as Code, we wouldn't see every deployment system rolling its own complex deployment implementations. But today, everyone rolls their own. Using ? Great! It has a mechanism built in. Want to use the same logic to blue-green something that isn't using Fargate? Too bad! AWS Fargate blue-green deployment With proper Infrastructure as Code, you should have an abstract, reusable, component that knows how to blue-green deploy anything that meets a certain interface. And you should then be able to instantiate that blue-green component, and specify what you want to blue-green ( , , etc.). Just like you do in real code. Kubernetes Pods AWS EC2 Instances We set out to address this problem head on by creating a open source system that lets you specify your entire application architecture with reusable library components, while still making it easy to stitch together custom components when you need them. You know, just like you do with actual code. We wanted these libraries to be modular, composable and reusable. We wanted everyone to be able to contribute components so that you can stitch the best ones together with your own to create your own unique architecture. And we wanted it to be easy to get started and easy to use, but still powerful enough for mission critical applications. We call this system , which is essentially , but for infrastructure. Adapt ReactJS Why use a web front-end technology? Because the requirements for a good Infrastructure as Code system look a lot like those for a good front-end framework: A declarative specification of what to instantiate. (React apps use a .) DOM A declarative syntax when possible. (React uses .) JSX Imperative code to stitch together declarative snippets. (React allows JavaScript to assemble JSX snippets.) Specification of state-based infrastructure updates like blue-green deploy or fail-over. (React was built to make this easy.) Components that can encapsulate these state-based updates. ( let components do exactly this.) React hooks Components that are easy to write, easy to use, and easy to compose. (The whole point of React components.) A robust module system for distributing and reusing components. (React is based on JavaScript which has a rich module ecosystem.) A single specification that can work from development through production. (Adapt has some new technology for this one.) Let's take a quick look at how all these things work in Adapt (or you can just , no React experience required). get started Adapt All infrastructure specifications in Adapt are JavaScript programs, just like React. (Or programs if you prefer.) This solves all kinds of otherwise complicated problems, like: TypeScript How do you define a module? How do you version the module? How do you distribute the module? Moreover, it provides all the power of a full programming language in your specifications, so you can do things like only creating infrastructure based on certain conditions, easily interacting with external APIs and services, or just about anything you can dream up. You have the full power of JavaScript and the entire library. NPM Execution of the JavaScript program results in a virtual DOM, where each element in the final DOM represents some piece of the overall infrastructure. For example, a basic application that connects to a database would look like this: Node.js Postgres Just like in React, the function App is a component. Its return value is a collection of elements that represent your infrastructure, which, in this example, is at a fairly high level of abstraction. Here, all the details of how the Node.js service is built and deployed are hidden in the component. Same for . <NodeService> <Postgres> This abstraction allows fairly simple, but powerful, specification of infrastructure and operational behavior. For example, the component could be very simple, like this: <NodeService> This component will locally build the Node.js application from source code into a local image (via the component) and run that image in a local container. Here, is a primitive element whose behavior is defined by a plugin. This is just like how the behavior of primitive elements or are determined by the browser. Because all primitive component behaviors are defined by plugins, Adapt can be extended to work with any infrastructure or application services that your code needs. Docker <LocalNodeImage> <docker.Container> <div> <p> Because all primitive component behaviors are defined by plugins, Adapt can be extended to work with any infrastructure or application services that your code needs. Fortunately, there is no need to actually write a component since the Adapt cloud library provides one, but as you can see, it isn't too difficult to build a custom version if you need to. <NodeService> State and Rebuilding If you're familiar with React, you know there is a lot more to React than just some clever HTML-like syntax to assemble a web page. In fact, the most powerful part of React is its state model and how it handles re-rendering a web page when state changes. Adapt has the same capability, allowing it to alter infrastructure in response to state changes, triggered by changes in the external environment, such as increased server load, a zone outage, or a push to a GitHub repository. For example, in the simple component above, we really want to wait for the component to be ready before deploying the <docker.Container>. To do this, we use some state to keep track of when the is ready, and only after it is ready, render the element. Just like with React, we can use the hook like this: <NodeService> <LocalNodeImage> <LocalNodeImage> <docker.Container> useState Of course, this is such a common operation, Adapt already provides a component to do this: <Sequence> The component even deals with the tricky case where we want the to keep running the old container until the new one is ready, along with a few other optimizations. The important thing here is how we can abstract away complex sequencing and roll out behavior using a component. Moreover, can deal with roll out and updates to any components that meet some basic interface requirements. This means that all the logic around sequenced deploys and updates are reusable. <Sequence> <docker.Container> <Sequence> As Adapt evolves, you will be able to update state based on long running observations. For example, you might be able to dynamically enable a backup availability zone if the main one has failed. You would also be able to build out components that encapsulate complex functionality, like blue-green deployment, by periodically updating the state that controls how much blue you have vs. green: You could even monitor data from other applications. For example, the component could wait for a manual approval from a code review application before continuing to roll out more than 5% of systems with new code. <BlueGreen> Of course, all this functionality and complexity would be available in a component from a library, much like Sequence in the example above, so you wouldn't have to implement complex features yourself. <BlueGreen> But wait, there's more... We think that combining simple, composable, declarative specifications, along with the ability for deployments to dynamically react to their environment is already enough to make Adapt exciting and substantially different than other solutions. But there are other deployment challenges that Adapt addresses too. Adapt allows you to create a single application architecture specification, then use style sheets to deploy that architecture using different underlying components for each of your environments. For example, in your dev style sheet, you can replace in the above example with a component that starts a Docker container and preloads some test data. Your prod style sheet replaces it with a component that points to a production database that is managed outside Adapt. In a more complex application, you could even style in a custom version of Adapt's component, which normally just deploys to a docker container, with one that builds the React application, pushes it to and uses as a . <Postgres> <TestPostgres> <PostgresProvider> <ReactApp> S3 AWS cloud front CDN In a more complex application, you could even style in a custom version of Adapt's <ReactApp> component that normally just deploys to a docker container, with one that builds the React application, pushes it to S3 and uses AWS cloud front as a CDN. Of course, Adapt also deals with all the typical issues you'd expect a deployment system to handle, like keeping track of each deployment's history and state, deployment logs, and as time goes on much more. Our goal is to take all the difficult, repetitive, and mundane parts of deployment and make them easy...maybe even fun. That way, you can focus on delivering your application, not managing infrastructure. Give it a try! If you want to try Adapt, head over to . Don't worry, you don't need to know React to get started. There are examples and a that will have you up and running with your first application in under 5 minutes. adaptjs.org getting started guide

Is React leading the Infrastructure As Code Movement?

In early 2003, Intel launched the new Pentium 4 “HT” processor. This processor was clocked at 3 GHz and had “Hyper-Threading” Technology. Over the following years, Intel and AMD battled to achieve the best desktop computer performance by increasing bus-speed, L2 cache size and reducing die size to minimize latency. The 3Ghz HT was superseded in 2004 by the “Prescott” model 580, which clocked up to 4 GHz. <a href="https://medium.com/media/15d7c1ad0647043347dd3fc0094e0db2/href">https://medium.com/media/15d7c1ad0647043347dd3fc0094e0db2/href</a> It seemed like the path forward for better performance was higher clock speed, but CPUs were plagued by high power consumption and earth-warming heat output. Do you have a 4Ghz CPU in your desktop? Unlikely, because the way forward for performance was higher-bus speed and multiple cores. The Intel Core 2 superseded the Pentium 4 in 2006, with clock speeds far lower. Aside from the release of consumer multicore CPUs, something else happened in 2006, Python 2.5 was released! Python 2.5 came bundled with a beta version of the with statement that you know and love. Python 2.5 had one major limitation when it came to utilizing Intel’s Core 2 or AMD’s Athlon X2. The GIL. What is the GIL? The GIL, or Global Interpreter Lock, is a boolean value in the Python interpreter, protected by a mutex. The lock is used by the core bytecode evaluation loop in CPython to set which thread is currently executing statements. CPython supports multiple threads within a single interpreter, but threads must request access to the GIL in order to execute Opcodes (low-level operations). This, in turn, means that Python developers can utilize async code, multi-threaded code and never have to worry about acquiring locks on any variables or having processes crash from deadlocks. The GIL makes multithreaded programming in Python simple. The GIL also means that whilst CPython can be multi-threaded, only 1 thread can be executing at any given time. This means that your quad-core CPU is doing this — (minus the bluescreen, hopefully) The current version of the GIL , to support async features and has survived relatively untouched even after many attempts to remove it or reduce the requirement for it. was written in 2009 The requirement for any proposal to remove the GIL is that it should not degrade the performance of any single-threaded code. Anyone who ever enabled Hyper-Threading back in 2003 will appreciate why . that is important Avoiding the GIL in CPython If you want truly concurrent code in CPython, you have to use multiple processes. In CPython 2.6 the was added to the standard library. Multiprocessing was a wrapper around the spawning of CPython processes (each with its own GIL) — multiprocessing module from multiprocessing import Process

def f(name):
    print 'hello', name

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join() Processes can be spawned, sent commands via compiled Python modules or functions and then rejoined into the master process. Multiprocessing also supports sharing of variables via a Queue or a Pipe. It also has a Lock object, for locking objects in the master process for writing from other processes. The multiprocessing has 1 major flaw. It has significant overhead, both in time and in memory usage. CPython startup times, even without no-site, are 100–200ms (see ). https://hackernoon.com/which-is-the-fastest-version-of-python-2ae7c61a6b2b So you can have concurrent code in CPython, but you have to carefully plan it’s application for that have little sharing of objects between them. long-running processes Another alternative is a third party package like Twisted. PEP554 and the death of the GIL? So to recap, multithreading in CPython is easy, but it’s not truly concurrent, and multiprocessing is concurrent but has a significant overhead. What if there was a better way? The clue in bypassing the GIL is in the name, the global lock is part of the global interpreter state. CPython processes can have multiple interpreters, and hence multiple locks, , this feature is rarely used because it is only exposed via the C-API. interpreter however One of the features proposed for CPython 3.8 is PEP554, the implementation of sub-interpreters and an API with a new interpreters module in the standard library. This enables creating multiple interpreters, from Python within a single process. Another change for Python 3.8 is that interpreters will all have individual GILs — Because Interpreter state contains the memory allocation arena, a collection of all pointers to Python objects (local and global), sub-interpreters in PEP 554 cannot access the global variables of other interpreters. Similar to multiprocessing, the way to share objects between interpreters would be to serialize them and use a form of IPC (network, disk or shared memory). There are many ways to serialize objects in Python, there’s the marshal module, the pickle module and more standardized methods like json and simplexml. Each of these has pro’s and con’s, have an overhead. all of them First prize would be to have a shared memory space that is mutable and controlled by the owning process. That way, objects could be sent from a master-interpreter and received by other interpreters. This would be a lookup managed-memory space of PyObject pointers that could be accessed by each interpreter, with the main process controlling the locks. The API for this is still being worked out, but it will probably look like this: <a href="https://medium.com/media/254485c113d719f0d8fba39291918664/href">https://medium.com/media/254485c113d719f0d8fba39291918664/href</a> This example uses numpy and sends a numpy array over a channel by serializing it with the marshal module, the sub-interpreter then processes the data (on a separate GIL) so this could be a CPU-bound concurrency problem perfect for sub-interpreters. That looks inefficient The marshal module is but not as fast as sharing objects directly from memory. fairly fast, protocol (v5) which has support for allowing memory buffers to be handled separately from the rest of the pickle stream. For large data objects, serializing them all in one go and deserializing from the sub-interpreter would add a lot of overhead. PEP 574 proposes a new pickle The new API could be interfaced ( , neither have been merged yet) like this — hypothetically <a href="https://medium.com/media/16985957af1574f02d2d6a18fe16e597/href">https://medium.com/media/16985957af1574f02d2d6a18fe16e597/href</a> That sure looks like a lot of boilerplate Ok, so this example is using the low-level sub-interpreters API. If you’ve used the multiprocessing library you’ll recognize some of the problems. It’s not as simple as threading , you can’t just say run this function with this list of inputs in separate interpreters (yet). Once this PEP is merged, I expect we’ll see some of the other APIs in PyPi adopt them. How much overhead does a sub-interpreter have? : More than a thread, less than a process. Short answer : The interpreter has its own state, so whilst PEP554 will make it easy to create sub-interpreters, it will need to clone and initialize the following: Long answer modules in the __main__ namespace and importlib the sys dictionary containing builtin functions ( print() , assert etc) threads core configuration The core configuration can be cloned easily from memory, but the imported modules are not so simple. Importing modules in Python is slow, so if creating a sub-interpreter means importing modules into another namespace each time, the benefits are diminished. What about asyncio? The existing implementation of the asyncio event loop in the standard library creates frames to be evaluated but shares state within the main interpreter (and therefore shares the GIL). After PEP554 has been merged, and likely in Python 3.9, an alternate event loop implementation be implemented (although nobody has done so yet) that runs async methods within sub interpreters, and hence, concurrently. could Sounds great, ship it! Well, not quite. Because CPython has been implemented with a single interpreter for so long, many parts of the code base use the “Runtime State” instead of the “Interpreter State”, so if PEP554 were to be merged in it’s current form there would still be many issues. For example, the Garbage Collector (in 3.7<) state belongs to the runtime. During the PyCon sprints to move the garbage collector state to the interpreter, so that each sub interpreter will have it’s own GC (as it should). changes have started Another issue is that there are some “global”, variables lingering around in the CPython codebase and many C extensions. So when people suddenly started writing properly concurrent code, we might start to see some problems. Another issue is that file handles belong to the process, so if you have a file open for writing in one interpreter, the sub interpreter won’t be able to access the file (without further changes to CPython). In short, there are many other things still to be worked out. Conclusion: Is the GIL dead? The GIL will still exist for single-threaded applications. So even when PEP554 is merged, if you have single-threaded code, it won’t suddenly be concurrent. If you want concurrent code in Python 3.8, you have CPU-bound concurrency problems then this could be the ticket! When? Pickle v5 and shared memory for multiprocessing will likely be Python 3.8 (October 2019) and sub-interpreters will be between 3.8 and 3.9. If you want to play with my examples now, I’ve built a custom branch with all of the code required https://github.com/tonybaloney/cpython/tree/subinterpreters

Has the Python GIL been slain?

Stories, News & Mentions about BLUECREW

Bluecrew’s Stories on HackerNoon