FileDrop is a free Google Sheets and Docs file manager add-on that allows you to drag and drop files into a spreadsheet cell with automatic linking and save them to Google Drive. You can extract text and tables from pdf files, extract text from images from translate it in 50+ languages.

FileDrop

filedrop

With Internet data becoming more affordable, online spam is also increasing. The online space is fraught with scams and fraudsters. To protect yourself from scams, you should track the sender's IP address every time you get an email. Especially emails which prompt a transaction or further communication. The question which arises is how to track an IP address from an email? Today we will share multiple ways to do so. Even if you are on your tablet or smartphone, you can easily track the IP address as it doesn’t require much . Before that, however, you need to understand why tracking an IP address from any email is important. data #Why is tracking an IP address from an email important? There are essentially 3 reasons why you need to track an IP address from email. These are: 1. To protect yourself from phishing scams The 1st reason is to protect yourself from phishing scams. When you know the sender's IP, you can determine to a certain extent whether the sender is trustworthy or not. Depending on this, you can decide whether you should reply or click on the sender's links. Not only that, once you get the IP address, you can easily check it against various spam lists. It is easy to know thereafter whether it is an IP address that is trustworthy or not. 2. To block a persistent spammer: Many times, a spammer might use different email addresses to spam you. Having a cluttered inbox is never a good idea. Since the spammer might use multiple email ids, blocking a single ID will not solve the problem. However, if you get the IP address of the spammer, you can block the IP. Once you do so, no matter which email ID the spammer uses, you can eliminate the spam. No need to deal with unnecessary emails. 3. To verify the sender: These days, many scammers hack the email accounts of your known contacts. After that, they spam everyone in their contact book. In this case, the email will come from a known sender. That is why it is common to fall for such emails. However, once you retrieve the sender's IP address, you can check it for geographic location. Only when you're sure that the sender is genuine can you interact with the sender of the email. This will further protect you from any scams. These are the 3 reasons why you need to track an IP address from any email. Now, we will help you understand how to track an IP address from any mail, whether you're using Gmail, Outlook, or Apple Mail. #How to Track an IP Address from an Email for Gmail? When you want to track an IP address from Gmail, you must look at its full email header. The email header consists of information like the sending ID, sending IP, and the other metadata. Therefore by looking at the email header, you can track the IP. To do so for Gmail, you have to follow the steps below: You have to 1st open your Gmail account. After that, you have to open the email for which you want to track the IP. There will be a button in the top right corner that will lead to a drop-down menu when you click it. The drop-down menu will have the option to show original. Once you click on it, you can view the full email header and the sending IP. In these four simple steps, you can easily track the IP address from Gmail. #How to Track an IP Address from an Email for outlook? The process is equally simple for outlook. You have to open the email client and double click on the email for which you want to get the IP. After that, click on the File drop-down menu and then properties. Once you click on properties, the entire email header will appear, and you can view the IP. #How to Track an IP Address from an Email for Apple mail? Similarly, Apple mail also has a simple procedure to get the IP address. You have to open the email whose IP you want to get. After that, you have to click on the View drop-down menu and then the message option, and after that, Raw Source. In the raw source, you will get the entire email header data, including the IP address. Getting the IP address is only half the task. You have to track that IP address to determine the genuineness of the sender. Wondering how to do so? We will cover that below. #How to trace the IP address of the sender? In the full email header, there will be a field by the name of the sender IP or X-Originating IP or Original IP. Once you get that IP, you have to visit the MX toolbox site. You will get a field to enter the IP address and click on the reverse lookup option. The reverse lookup option is in the drop-down menu beside the field to enter the IP. Once you click it, you can know the IP location as well as the other sender details. That will certainly help you track the same. MX Toolbox is not the only option you have when you want to track an IP address from an email. There are numerous other tools as well, which we will highlight below. Three alternate tools to extract an IP address The other tools which you can utilise  include: 1. GSuite Toolbox MessageHeader: The advantage of this tool is that it allows you to paste the entire email header. If you're unable to decipher the IP from the mail header, you paste the whole thing there, and it will detect the IP address on its own. 2. MX toolbox Email Header Analyzer: This tool allows you to paste the email header and then analyze it to provide the IP. 3. IP-Address Email Header Trace: Want a tool that does both? If so, this is the perfect option for you. It not only analyses the email header but also traces the IP from the email header. That way, you won't have to worry about using any other tool when you're using this one. Thus, if you're not able to decipher the IP address from the mail header, these are the 3 tools you can use. If you're struggling to track an IP address from any mail, these are the tools that can come to your rescue. With the help of our detailed guide above, you can know right away who is the sender of the email and whether the IP is a spammer or genuine person. After that, you can easily take appropriate action to protect yourself from scams and other frauds.

How to Track an IP Address from an Email: Gmail, Outlook, Apple Mail?

Web Application implementation based on React.js, Complete Example

(IBW), the country’s flagship series of blockchain and Web3 events held in Bangalore from Dec.4-10, is delighted to announce that the attendees are going to have unparalleled opportunities for networking, collaboration, and discussion at the weeklong festival. BANGALORE, India, November 29th, 2023/Chainwire/-- India Blockchain Week There will be over 60 conferences, hackathons, networking events, workshops, a demo day and more. The IBW will be a platform where blockchain builders, investors, TradFi executives, policymakers, and crypto-curious newcomers from India and around the world come together to discover the future of DeFi, crypto, dApps, and explore the impact of Web3 on finance and culture. IBW presents an unparalleled gateway for participants to engage with their most-admired thought leaders, experts and influencers in the blockchain ecosystem. For Web3 companies, this is a unique opportunity to engage with emerging talent, participate in the IBW Demo Day and Hackathon, attract new developers to the blockchain arena, and expand the ecosystem in India. Besides the IBW VIP Dinner, IBW After Party, and Hashed Founders Night organized by IBW and Hashed Emergent, here are some of the key highlights of the industry gathering: : Hosted on Dec.6-7, 2023 at the Sheraton Grand Whitefield, it features keynote speeches and panel discussions on the latest developments and opportunities in the web3 space, and examining the policy landscape. The headline conference also includes a demo day and a hackathon. IBW’23 Conference : The Demo-Day will be held on 7th December from 2-6 PM to spotlight 12 notable Indian Web3 startups at the IBW'23 Conference venue. This 4-hour demo day will cater to the broad audience  including investors, founders, builders and others. It is organized in partnership with elite companies, VC funds and accelerators including Aelf Ventures, Hashed Emergent, Graviton, Coinswitch, and Google Cloud. Demo Day Hackathon: The virtual hackathon on Dec.6 is expected to see the participation of over 2,500  enthusiastic individuals. Organized by IBW and HackerEarth, the hackathon will conclude on a 250-member stage at the IBW'23 Conference venue. : Organized by Devfolio and ETHGlobal from Dec.8-10, it is one of the world's largest Ethereum hackathons, hosting over 1,500 builders and 25+ workshops. ETHIndia : Set for Dec.7, Polygon Connect India is the celebration of this region’s leg of DevX Global Tour, a global gathering of tech builders and innovators. Polygon Connect : Another prominent side-event on Dec.7. It's a one-day conference filled with Polkadot innovations, thought-provoking conversations, and community gathering. Polkadot Pulse : ​The Indian edition of Filecoin’s global event series. Spanning across Dec.3-4, it focuses on providing developers the tools, resources and guidance to build for the decentralized future. FILBangalore : Organized by ETHGlobal, Pragma is a one-day, single-track summit with intimate, high-quality talks by industry leaders for a global audience. Pragma India : Powered by STAN, it’s an exclusive journey into the thrilling realm of Web3 Gaming! This event unites industry leaders, developers, and passionate Web3 enthusiasts to discuss groundbreaking ways of forging connections and creating value in Web3 Gaming. Confirmed speakers are Sebastian Borget from The Sandbox, Vinayak Rao from Aptos, Neeraj Khandelwal from Okto, Parth Chadha from STAN and more. IBW Gaming Mixer Here’s the . With over 60 registered side events, attendees can expect a week brimming with engagement and insight. IBW has also onboarded the popular NFT artist Punk6529 as the official NFT Art Partner. Artworks from the Memes by 6529 and the 6529 Museum collections will be displayed at the event. full list of side events The IBW organizers would like to thank the sponsors for their help in making it the most important event in the country for conversations about crypto, blockchain, and Web3. Avalanche is IBW’s top-flight title sponsor while the roster of gold sponsors includes Polkadot, Internet Computer, Glip, Ledger, Aptos and Hunch. The silver sponsors are Bharatbox, Saber, FireDrops, dYdX, Supra, Orbs, Zoth, Persona, Berachain, and Shemaroo. About India Blockchain Week (IBW) India Blockchain Week (IBW) is a series of blockchain and web3 events, spanning from 4-10 December 2023 across Bangalore, India. IBW is a week-long array of 60+ web3 events, including flagship events such as the headline IBW Conference, ETHIndia, Polygon Connect, Polkadot Pulse, FILBangalore and many other side-events, networking events, workshops, parties etc hosted by Indian & global blockchain industry stakeholders. The IBW Conference is the two-day headline event anchoring India Blockchain Week (IBW) on 6-7 December 2023 at the Sheraton Grand, Bangalore and hosted by Hashed Emergent - a team and brand dedicated to accelerating the mass adoption of Web3 in India. Buy Tickets Discover Sponsors Check out FAQ For more information about IBW, visit: | | | Website Twitter LinkedIn Telegram Contact Irshad Ahmed gm@indiablockchainweek.com This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program . here

India Blockchain Week Gears Up For The Country’s Biggest Web3 Gathering With Over 60 Side Events

Here are some of the best web designing and development trends for the year 2019. These top web design trends are based on various stats. Are you planning to launch your website this year? Have you analyzed the market in which you are going to enter? There are around 1.5 billion websites working on world wide web. Here are the number of websites from the year 2009 to 2019, as announced by internet live stats. The increasing number of websites have created a cutthroat competition among online businesses. It is quite easy and cheap to construct a website in current times. The challenge begins at the latter stage when you want to reach the goal because of which you started the website. (The goal of reaching and gaining customers). Let me tell you that it is one of the most strenuous tasks to do! The thing which stresses the website owners the most is the bounce rate. Website bouncing is when a user leaves your website without interacting further. No business person likes when their bounce rate goes up. It is a nightmare for most of the web or too because it shows their lack of skills. Do you know the average bounce rate industry-wise? app designers & developers According to an infographic on the blog of the bounce rate metrics of various industries is given below: Niel Patel , This data is not meant to scare you but its motive is to gear you up for the heavy competition in every business niche. To outshine in this growing dynamic market it is vital to formulate a website which compels the visitors to interact with it. It is not easy to design an efficient website. When you , you have to make sure that they know about the trends of website designing which will rule the market in 2019. hire web developers Website designing trends are constantly evolving according to the needs and preferences of internet users. Proficient website designers keep an eye on these trends and incorporate them into their projects. Here are some of the top website designing trends in 2019: 1. Responsive design (Obviously) 2. AI, deep learning and Machine learning 3. Minimalism 4. Chatbots 5. Design systems Web Design Trend 1: Responsive design: In the era where every other person has a mobile in their hand, do you think it is smartness to ignore this platform? According to research, the number of mobile users will reach to 4.68 billion in 2019. Here is the graphical representation of their findings: Statista This is why the mobile version of websites are given more priority by website designers. With SEO friendly web design you can reach social media as well. A strong presence over social media platforms can enhance your overall website performance. It was announced by Google that it is changing algorithms to prioritize mobile-first-indexing. It is to encourage designs to choose mobile as the first platform for responsive design. It will enhance the experience of mobile users. Now a days, businesses are choosing those which provide Mobile-First web designing solutions. web designing companies Web Design Trend 2: AI, deep learning and Machine learning: Machine learning is a sub-field of artificial intelligence where a computer is trained to make predictions using per-determined algorithms. It is a data-driven task that makes predictions based on past data samples. Some of the applications utilized in web designing are: machine learning services Wix artificial design intelligence is an builder. It gathers information from social media about related contents which help in making a website beautiful. It helps in creating awesome website designs using machine learning algorithms. WiX ADI: AI-based website It helps in creating customized workflow and applications. It identifies related backgrounds, illustrations, and images. This automates the repeated task which in turn speed up the process of web designing. Adobe Sensei: It is an AI-based website builder that uses machine learning to formulate mobile responsive website. It assists in skipping the web development process and builds the website at minimal cost. Thegrid: It is used by a number of web designers all over the world. It utilizes machine learning to construct a website in a fraction of seconds. Its AI based chatbot Sacha helps you in making tailor-made website designs. Firedrop: Web Design Trend 3: Minimalism: Minimalism design makes the website to load faster and makes their appearance hassle-free. This web design is based on the principle of simplicity. The fewer the elements will be, the more convenient it will be for visitors to grasp the information. A well-designed website with proper white-space, contrast, and soothing typography make the delivery of information accurate and simple. Moreover, it ends up making the navigation easy and providing an excellent user experience. Minimalism will continue to shine in 2019 by giving enough place on web pages for distracting elements. This will make scrolling a fun part and help the visitors to find the information they are looking for easily. Most of the are focusing on this trends to make advanced web & UI/UX designs for their customers. software development companies Web Design Trend 4: Chatbots Artificial intelligence has taken the website design to its peak by making it more independent of human support. With more efficiency and intelligence, chatbots are expected to rule websites in this year. It is expected that they will be seen in the higher customized form on websites. Friendly mascots representing brands are also predicted to be a part of future web designs. They might be seen in bright colors to add prominence to their presence. This, in turn, will result in asking attention towards chat-bots from every visitor. That’s why are high in demand these days. chatbot development services Web Design Trend 5: Design systems: As every smart business person is looking for better website designs, various design tools of web designing are being introduced. These design tools are evolving constantly with new features and versions being introduced at timely intervals. Some of the tools that will be ruling in 2019 are: Mockplus (rapid prototyping tool), FrontMap (front end tool), Sketch (UI interface tool), WebGradients (gradient tool), etc. Wrapping up: There are plenty of innovations introduced in the market to improve the technical support in website designing process. These technologies which are introduced in web designing are reshaping the whole process continuously in brilliant ways. To make a website survive in the market it is essential to meet the pace of these evolving trends. This is the only way to make your website an awesome tool to avail new business opportunities! If you are a business owner, you need to first take help from a . It can provide you advises on how you can save your time and cost in your next web designing project. software consulting company <a href="https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href">https://medium.com/media/3c851dac986ab6dbb2d1aaa91205a8eb/href</a>

5 Top Web Designing Trends in 2019

OS1 rendition of artificial intelligence from Her Artificial Intelligence and has made some considerable progress over the last couple of years. Most of this current progress that is usable has been developed for industry and business purposes, as you’ll see in coming posts. Research institutes and dedicated, specialised companies are working toward the ultimate goal of AI (cracking artificial general intelligence), developing open platforms and the looking into the ethics that follow suit. There are also a good handful of companies working on AI products for consumers, which is what we’ll be kicking this series of posts off with. the fourth industrial revolution Artificial intelligence is like climbing a tree to try and reach the moon; one can report steady progress, all the way to the top of the tree. This is in a series of posts that looks at the landscape of the artificial intelligence industry and the companies and institutes developing products that are moving the needle of knowledge of machine intelligence and consciousness forward for humanity. Part 1 of 3 A break down of the series I’ve trawled through literally thousands of websites (6,000+ links) over a few of weeks to bring you a comprehensive list of the best AI products and most promising companies in the field. PS. my Macbook track pad is now dying from too many clicks. a list of AI companies and products (B2C) a list of AI companies (B2B) a list of AI companies (because there are so damn many!) and a few added extra Part 1 — for personal use Part 2 — for business and industr y Part 3 — for business and industry extended As a note: a few of the products haven’t launched yet, and may be still in Beta, though are exciting ideas, well backed or look promising. Most you can use now. Let me know your feedback (including any edits, adds and removals) Let me know if you think I’ve put a company under the wrong category or if I’ve totally got the description wrong about a company / it just needs a little alteration then . Also feel free tell me about any companies you think I’ve missed that need to added to the list — comment below and I’ll put them on. holla at me (on Twitter) I’ve highlighted some of my favourites, enjoy —! Artificial Intelligence for personal use:🏠 Personal / In-Home — kitchen assistant for turn-by-turn directions in the kitchen — verify your identity by the way you walk, type and sit Bridge Kitchen UnifyID 👔 Work — helps you manage phone calls — helps you write better resumes — helps you find a dream job — helps with email overload, organisation and communication — a better and smarter calendar — scans for jobs and helps manage your application process — helps you make smarter decision for your career Carly Mosaic Newton Notion Robby Stella Woo 👯 Social — helps you find meaningful professional connections — dating app with Face Search — let Eezy take care of your evening so you can take care of having fun — ironic hashtag and comment generator for your photos — can tell you how hot you are — introduces you to people you should really meet (work and play) Brightcrowd Dating.ai Eezy Hashley Hotness.ai Rey 🎓 Education — helps children to learn maths Thirdleap 🏥 Health / Medical — your virtual health assistant — can help if you’re feeling unwell — personal health coach — helps you care for loved ones with Alzheimer’s — food recognition from meal photos to help count calories — makes lab results easy to understand — mental healthcare in your pocket — diagnose snoring and tooth grinding Abi Ada Airi Alz.ai Bitesnap doc.ai Tess by x2 Sleep.ai 🕵️ Agents — Personal — everyday personal assistant for in-home — everyday personal assistant on iPhone and Mac — everyday personal assistant on PC and Windows devices — competitors to Siri, Now and Cortana — a holographic anime assistant in an espresso machine — everyday personal assistant — similar to Amazon Echo — is the world’s first open source voice assistant — like Siri with an interface — virtual assistant with an interface — like Siri but 10x better Amazon Echo / Alexa Apple Siri Cortana Facebook M Gatebox Google Assistant Ling Mycroft Remi Spoken Viv 📅 Agents — Professional — meeting scheduling assistant — meeting scheduling assistant (aimed at C-Suite) — meeting scheduling assistant — meeting scheduling assistant — handles meeting scheduling and manages calendar — automatically discover and organise your work — meeting scheduling assistant — personal assistant to help you at work Clara Julie Desk Kono Mimetic My Ally SkipFlag x.ai Zoom.ai 🙍 Agent — Fun — your AI girlfriend — your AI friend that you raise through text conversations Fembot Replika 📝 Agents — Chatbot — helps you make smarter business decisions — create a Facebook chatbot in 7 minutes — chatbot to help you throughout your daily life — monitor analyse your carbon emissions Brin Chatfuel myWave Lyra 🗞️ Entertainment / News — content and news app that learns what you like and don’t like — learns what you enjoy and finds stories you’ll like Jottr News360 ✈️ Travel — automatically calculates and adds meeting travel time — helps you manage travel itineraries and meetings —helps with booking flights, hotels, restaurant reservations and more — traffic forecaster and travel time prediction Emma **ETA** Mezi Ready 🚗 Vehicle — turns any car into a smart car Vinli 🏃‍ Fitness — smarter running app Mara 🎵 Music — composes emotional soundtrack music — finds music you might like Aiva Pandora 🏛️ Insurance / Legal — can advise you on legal issues — tracks and rewards safe drivers Docubot Driveway 🛒 Shopping — helps identify if clothing and accessory items are authentic Entrupy 💰 Finance — fast answers about your finances — a personal Tax Accountant — helps you achieve your financial goals — helps you do your banking — rounds up purchases and invests the spare change — helps you manage your finances — institutional-grade active portfolio management — helps you pay bills easily — AI for your daily finance decisions Abe Andy Bond Finn.ai Mylo Olivia Responsive Roger Wallet 📱 Social media / Website management — websites designed automatically, just add content and publish — ironic hashtag and comment generator for your photos — build elegant landing pages using your social media content Firedrop Hashley Signature 💡 IoT / IIoT — home activity, movement and identity sensor — smart-home platform focused on speech and sound — one place to connect your smart home devices — grow room controller and monitoring system — helps you monitor and improve your sleep — whole house voice control — is the world’s first open source voice assistant — the baby monitor reinvented — a range of in-home devices such as Thermostat, security and alarms Aerial Bridge.ai Cubic Grojo Hello Josh Mycroft Nanit Nest ⌚ Wearables — helps you learn a new language from conversations through your day — wearable for martial arts to help analyse kicks and fights Eli **Kick.ai** 🌐 Language / Translation — transcribe conversations in English and Hindi — language translator powered by neural networks Liv Microsoft Translator 🤖 Robots — a humanoid robot aimed to be as capable as a human — a robot (I couldn’t work out its purpose, but it sounded cool!) Roboy Spoon 💌 Useful + Fun + Random — helps you find and buy cannabis (with recommendations) — universal field guide that suggests possible matches — is a collaborative storytelling experiment using AI, machine learning, robotics, bio-engineering and IoT — laughs visualised in a digital format, that may be sent to space — beer brewed by artificial intelligence Elevator Fieldguide Frankenstain.ai #Laugh IntelligentX Brewing Co. 📚 Research — breaks down articles and PDF’s into quick, readable dot points — helps you research and visualise concepts in research papers Apollo Iris 🎫 Events, Conferences and Communities — an annual event where leading AI researchers and top industry practitioners meet and collaborate — Bootstrap Labs Venture firm — the one stop shop for AI/ML/DL events and conferences — strong name game! The AI Conference **Applied Artificial Intelligence Conference** **Events.ai** oh.hai.ai — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI communities and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events — applied AI community and events Amsterdam Bangalore Berlin Bucharest Budapest City.ai Hamburg Hongkong London Madrid Krakow Oslo Tallinn Tirana Singapore Sofia Stockholm Valletta 📰 News and blogs — a weekly collection news and resources on AI and ML — AI and Machine Learning blog — AI newsletter delivered every 2 weeks — AI commentators — dedicated to making the power of deep learning accessible to all — dedicated news and updates for ML and AI — a hand-curated newsletter ML and DL — f0rum for AI, ML and Robotics AI Weekly Approximately Correct Axiomzen Concerning.ai Fast.ai Machinelearning.ai Machine Learning Weekly PRAI That’s a wrap! I’ll be bringing out , which will be arriving shortly! Part 2 + 3 Original post at https://www.liamiscool.com/a-list-of-artificial-intelligence-tools-for-personal-use I also (good stuff) sometimes. Tweet

A list of artificial intelligence tools you can use today — for personal use (1/3)

The facade is one of my favorites. Out of , I have found that it’s the one I turn to repeatedly across different applications. In this article, I’ll be exploring the facade design pattern in C# — because all of the code examples will be in C#! We’ll be looking at 4 different examples of the facade pattern in C# and how each of them is used to simplify things for the caller of our API. design pattern all of the design patterns that are out there What is the Facade Design Pattern? The Facade pattern is a software design pattern that falls under the category of structural design patterns. It provides a simplified interface for a complex subsystem, making it easier to use and understand. The main purpose of the Facade pattern is to hide the complexities of the subsystem and provide a unified interface to the clients, shielding them from the details of how the subsystem works. The Facade pattern is particularly useful when working with large and complex systems, where there are multiple classes and interactions involved. By using the Facade , you can encapsulate the underlying complexities into a single high-level interface, making it easier to interact with the system. design pattern The key characteristics of the Facade pattern include: : The Facade class encapsulates the interactions and complexities of the underlying subsystem, providing a simplified interface for clients to interact with. Encapsulation : The Facade design pattern simplifies the overall usage of the system by providing a concise and easy-to-understand interface, reducing the cognitive load for developers. Simplification : The Facade class abstracts the complexities of the subsystem, allowing clients to interact with the system without needing to know the internal details. Abstraction By utilizing the Facade pattern, you can create a well-defined boundary between the client code and the complex subsystem, leading to improved maintainability, flexibility, and reusability of the codebase. A Generic Example of the Facade Design Pattern in C#: Here is an example of how the Facade pattern can be implemented in C#: // Complex subsystem classes
class SubsystemA
{
    public void MethodA()
    {
        Console.WriteLine("Subsystem A - Method A");
    }
}

class SubsystemB
{
    public void MethodB()
    {
        Console.WriteLine("Subsystem B - Method B");
    }
}

class SubsystemC
{
    public void MethodC()
    {
        Console.WriteLine("Subsystem C - Method C");
    }
}

// Facade class
class Facade
{
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;
    private SubsystemC subsystemC;

    public Facade()
    {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
        subsystemC = new SubsystemC();
    }

    public void Operation()
    {
        Console.WriteLine("Facade - Operation");
        subsystemA.MethodA();
        subsystemB.MethodB();
        subsystemC.MethodC();
    }
}

// Client code
class Client
{
    static void Main(string[] args)
    {
        Facade facade = new Facade();
        facade.Operation();
    }
} In this code example, we have a complex subsystem consisting of three classes: , , and . These classes represent different functionalities or components of the subsystem. The class acts as a simplified interface that encapsulates the complexities of the subsystem. The method in the class provides a unified interface for the clients to interact with the subsystem. SubsystemA SubsystemB SubsystemC Facade Operation Facade By calling the method on the object, the client code can perform the desired actions without needing to directly interact with the complex subsystem classes. The class internally communicates with the individual subsystem classes, hiding the intricate details from the client. Operation Facade Facade Plugin Architectures in C# with the Facade Pattern In a plugin-style architecture, the Facade design pattern can be particularly useful for abstracting the complexities of dynamically selecting and interacting with various plugins based on runtime conditions or configurations. Let’s consider a document processing system where the system needs to support different formats (e.g., PDF, DOCX, ODT) and operations (e.g., parsing, rendering) through plugins. Each format is handled by a different plugin, but clients interact with a unified interface provided by the facade. Complex Subsystems – Plugins! We have plugins for handling various document formats: : Handles PDF document operations. PdfPlugin : Handles DOCX document operations. DocxPlugin : Handles ODT document operations. OdtPlugin Each plugin implements a common interface, , which defines methods for whether or not the document is supported and rendering documents. We’ll be using an imaginary interface that would support interactions for being able to render the document content to some virtual canvas — outside of the scope of this example 🙂 IDocumentPlugin IRenderContext The IDocumentPlugin Interface Let’s check out the example code for a plugin interface that each of our implementations will have: public interface IDocumentPlugin
{
    bool SupportsFormat(string filePath);

    void RenderDocument(Stream stream, IRenderContext renderContext);
} And some dummy classes for now to meet the three plugins we’re required to support: public class PdfPlugin : IDocumentPlugin
{
    public bool SupportsFormat(string filePath) => filePath.EndsWith(
        "pdf",
        StringComparison.OrdinalIgnoreCase);

    public void RenderDocument(
        Stream stream,
        IRenderContext renderContext) => Console.WriteLine("Rendering PDF document...");
}

public class DocxPlugin : IDocumentPlugin
{
    public bool SupportsFormat(string filePath) => filePath.EndsWith(
        "docx",
        StringComparison.OrdinalIgnoreCase);

    public void RenderDocument(
        Stream stream,
        IRenderContext renderContext) => Console.WriteLine("Rendering DOCX document...");
}

public class OdtPlugin : IDocumentPlugin
{
    public bool SupportsFormat(string filePath) => filePath.EndsWith(
        "odt",
        StringComparison.OrdinalIgnoreCase);

    public void RenderDocument(
        Stream stream,
        IRenderContext renderContext) => Console.WriteLine("Rendering ODT document...");
} The Document Processing Facade Class The class provides a simplified interface to interact with the appropriate plugin based on the document format, hiding the complexity of plugin selection and operation execution: DocumentProcessorFacade public class DocumentProcessorFacade
{
    private readonly List<IDocumentPlugin> _plugins;

    public DocumentProcessorFacade()
    {
        // NOTE: I would probably use dependency injection to
        // pass in viable plugins, but this is just to
        // demonstrate the example
        _plugins = new List<IDocumentPlugin>
        {
            new PdfPlugin(),
            new DocxPlugin(),
            new OdtPlugin()
        };
    }

    public void ProcessDocument(
        string filePath,
        IRenderContext renderContext)
    {
        var plugin = GetSupportedPlugin(format);
        if (plugin == null)
        {

            throw new NotSupportedException(
                $"No plugin found to support format for file '{filePath}'.");
        }

        using var fileStream = File.OpenRead(filePath);
        plugin.RenderDocument(stream, renderContext);
    }

    private IDocumentPlugin GetPluginForFormat(string filePath)
    {
        return _plugins.FirstOrDefault(p => p.SupportsFormat(filePath));
    }
 } This example demonstrates how the Facade pattern simplifies interactions within a plugin-style architecture by providing a unified interface ( ) to various document processing plugins. The facade handles the complexity of selecting the appropriate plugin based on the document format and executing operations, allowing client code to remain simple and clean. This approach enhances modularity, scalability, and maintainability of the software system. DocumentProcessorFacade Streamlining API Calls using the Facade Design Pattern Managing multiple API calls in an application can be a complex task. As a software engineer, it is important to find ways to simplify and streamline this process. One effective approach is to utilize the Facade design pattern, which provides a convenient interface to a set of interfaces in a subsystem. In this section, we’ll explore how the Facade pattern can be utilized to streamline and centralize API call management in C#. When working with multiple APIs, it is common to encounter challenges such as handling authentication, managing request/response formats, and dealing with rate limiting. These tasks can become time-consuming and error-prone if not properly managed. The Facade pattern can help alleviate these challenges by providing a unified and simplified interface for interacting with the APIs. By implementing a facade class, we can encapsulate the complexity of making API calls behind a simple and easy-to-use interface. This allows other parts of the codebase to interact with the APIs without having to worry about the details of authentication, request/response formats, or rate limiting. Let’s take a look at an example to see how this can be achieved: public class ApiFacade
{
    private readonly ApiAuthenticationService _authenticationService;
    private readonly ApiRequestFormatter _requestFormatter;
    private readonly ApiRateLimiter _rateLimiter;

    public ApiFacade()
    {
        _authenticationService = new ApiAuthenticationService();
        _requestFormatter = new ApiRequestFormatter();
        _rateLimiter = new ApiRateLimiter();
    }

    public ApiResponse MakeApiCall(ApiRequest request)
    {
        _authenticationService.Authenticate();
        var formattedRequest = _requestFormatter.Format(request);
        _rateLimiter.WaitIfNeeded();

        // Make the actual API call and retrieve the response
        var response = ApiClient.MakeCall(formattedRequest);

        return response;
    }
} In the code example above, we have created an class that encapsulates the complexity of authentication, request formatting, and rate limiting. It utilizes three separate services: , , and . By utilizing the facade pattern, we can centralize the management of these services and expose a single method ( ) that takes care of all the necessary steps to make an API call. ApiFacade ApiAuthenticationService ApiRequestFormatter ApiRateLimiter MakeApiCall To use the class, other parts of the codebase can simply create an instance and call the method, passing in the required . The facade class will handle the authentication, request formatting, rate limiting, and the actual API call, simplifying the overall process and reducing the complexity of managing multiple API calls. ApiFacade MakeApiCall ApiRequest Enhancing UIs with the Facade Design Pattern in C# User interface interactions can often become complex and involve a series of intricate steps. The Facade pattern provides an elegant solution to simplify and optimize these interactions, making them more manageable and efficient. Let’s explore how the Facade pattern can enhance user interface interactions in C# with a code example. Consider a scenario where a user needs to perform various actions on a customer management system, such as creating a new customer, updating their information, and retrieving customer details. Each of these actions involves interacting with multiple components and performing a series of steps. By utilizing the Facade design pattern, we can create a unified interface that encapsulates the complexity of these interactions. The Facade class acts as a simplified entry point, shielding the client from the underlying system’s complexities and providing a more straightforward API for interacting with the user interface. public class CustomerManagementFacade
{
    private readonly CustomerService _customerService;
    private readonly CustomerValidationService _validationService;
    private readonly CustomerCacheService _cacheService;

    public CustomerManagementFacade()
    {
        _customerService = new CustomerService();
        _validationService = new CustomerValidationService();
        _cacheService = new CustomerCacheService();
    }

    public void CreateNewCustomer(string name, string email)
    {
        if (_validationService.ValidateCustomerData(name, email))
        {
            _customerService.CreateCustomer(name, email);
            _cacheService.CacheCustomer(name, email);
        }
    }

    public void UpdateCustomerInformation(string name, string email)
    {
        if (_validationService.ValidateCustomerData(name, email))
        {
            _customerService.UpdateCustomer(name, email);
            _cacheService.UpdateCachedCustomer(name, email);
        }
    }

    public Customer GetCustomerDetails(string name)
    {
        var customer = _cacheService.GetCachedCustomer(name);

        if (customer == null)
        {
            customer = _customerService.GetCustomer(name);
            _cacheService.CacheCustomer(customer.Name, customer.Email);
        }

        return customer;
    }
} In the above code example, we have a class that acts as the façade for managing customer interactions. It encapsulates the creation, updating, and retrieval of customer information. The façade orchestrates the interaction between the , , and to provide simpler methods for the client to use. CustomerManagementFacade CustomerService CustomerValidationService CustomerCacheService With the façade pattern, the client code only needs to interact with the façade class and doesn’t need to worry about the detailed interactions with each individual component. This simplifies the codebase, reduces complexity, and allows for easier maintenance and extensibility. [Paid Product] If you want more ! information on design patterns, get your E-Book today Wrapping Up The Facade Design Pattern in C# In conclusion, we have explored the Facade design pattern in C# and discussed 4 interesting use cases along with code examples. The Facade pattern provides a simplified interface to a complex subsystem, making it easier to understand and use. Each of these examples hopefully helped to illustrate different scenarios where leveraging a facade can make things much simpler for the calling code. Understanding and utilizing design patterns, such as the Facade pattern, is important for software engineers. These patterns provide proven solutions to common software engineering problems and offer a structured approach to designing robust and scalable applications. By incorporating design patterns into our development practices, we can create software solutions that are more efficient, flexible, and easier to maintain — but understanding which design patterns best fit where takes some practice! Try out the Facade pattern further and consider implementing it in your C# projects — it’s truly one of my favorite design patterns to work with. If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published . here

Simplify Complex Subsystems With The Facade Design Pattern in C#

Software Engineering for OpenHarmony—A Research Roadmap: Conclusion & References

Software Engineering for OpenHarmony: The Research Roadmap

Microsoft's Azure provides many services via a single cloud, which lets them offer one solution for multiple corporate infrastructures. Development teams often use Azure because they value the opportunity to run SQL databases in the cloud and complete simple operations via the Azure portal. But you'll need to have a way to back up your data, as it's crucial to ensure the functionality of the production site and the stability of everyday workflows. So creating Azure SQL backups can help you and your team avoid data loss emergencies and have the shortest possible downtime while maintaining control over the infrastructure. Another reason to have a current Azure database backup is Microsoft’s policy. uses the shared responsibility model, which makes the user responsible for data integrity and recovery while Microsoft only ensures the availability of its services. Microsoft directly recommends using third-party solutions to create database backups. Microsoft In case you run a local SQL Server, you'll need to prepare for the possibility of hardware failures that may result in data loss and downtime. An SQL database on Azure helps mitigate that risk, although it's still prone to human errors or cloud-specific threats like malware. These and other threats make enabling Azure SQL database backups necessary for any organization using Microsoft’s service to manage and process data. In this tutorial, you'll learn about backing up Azure databases and restoring your data on demand with native instruments provided by Microsoft, including methods like: Built-in Azure database backup functionality Cloud archiving Secondary database and table management Linked server Stretch Database Why Backup Your SQL Azure Database? Although I covered this briefly in the intro, there are many reasons to back up your SQL Azure database data. Disaster Recovery Data centers can be damaged or destroyed by planned cyberattacks, random malware infiltration ( to discover more on ransomware protection), and natural disasters like floods or hurricanes, among others. Backups can be used to swiftly recover data and restore operations after various disaster cases. check out this article Data Loss Prevention Data corruption, hardware failure, and accidental or malicious deletion lead to data loss and can threaten an organization. Backup workflows set up to run regularly mean you can quickly recover the data that was lost or corrupted. Compliance and Regulations Compliance requirements and legislative regulations can be severe regardless of your organization’s industry. Mostly, laws require you to keep up with security and perform regular backups for compliance. Testing and Development You can use backups to create Azure database copies for development, troubleshooting, or testing. Thus, you can fix, develop, or improve your organization’s workflows without involving the production environment. How to Back Up Your Azure SQL Database Backing up your Azure SQL database can be challenging if you go through the process without preparation. So that's why I wrote this guide – to help you be prepared. Here's what we'll cover in the following sections: Requirements for SQL Azure database backup How to configure database backups in Azure with native tools Cloud archiving Backup verification and data restoration SQL Azure Database Backup Requirements Before backing up your SQL Azure databases, you need to create and configure Azure storage. Before you do that, you'll need to go through the following steps: First, open the Azure management portal and find . Then, go to > . Provide the information, including the location and names of a storage account and resource group according to your preferences. After you enter the information, hit . Create a Resource Storage Storage account Next Then go to the advanced section for additional settings. The optimal choice is to set _"_Secure transfer required" as and "Allow access" from networks. For more resilience in case of human error, you can set "Blob soft delete" as . With that setting, you can quickly correct accidental deletions in the storage account. Enabled All Enabled After that, specify the tags you need to simplify navigating through your infrastructure. Check the settings once more. If everything is configured correctly, hit . Your new storage account is now created. Create Once the storage volume is created, it's time to configure a backup data storage container. Go to the storage account, find , then hit the tab there. After that, specify a name for the new container and switch Public access level to . Containers + Container Private (no anonymous access) You can then use the container as a backup storage (.bak files will be stored there in that case). Azure Database Backup Configuration Now, everything is set up for you to back up your SQL Azure database. Do the following to create a database backup: First, go to , and establish a connection with the SQL server. After that, right-click the database that should be backed up. The context menu appears, so go to there. SQL Management Studio Tasks Then hit . Back Up… Then find the Destination tab, and set there. After that, hit . Back up to line to URL New container Next, sign in to Azure. Pick the container you created before. Provide your credentials, then hit . OK You’ll see a message asking you to sign in to Azure subscription. Then, choose the container and hit . OK Now, you'll see the configured backup destination URL listed. To start the workflow to back up your Azure data, hit once again. OK When your SQL Azure database backup is completed, the message shows up: " ." The backup of database ‘your database name’ completed successfully The backup file in the target container should now be visible from the Azure portal. Keep in mind that, when uploading backups to any cloud storage, you may face issues if your network connection is not fast enough. In case that’s true for you, you can reorganize your backup workflows: send backup data to a physical storage drive first, and then send another copy to the cloud. Thus, you can prevent operational challenges that might appear due to network bandwidth deficiency. Cloud Archiving for Azure Database Backups Databases tend to grow in volume as the organization grows. This means that the storage space required to fit the data and that the data's backup increases significantly. Also, the original data volume prolongs the duration of full backup workflows, posing another challenge. Of course, the first way to get more storage space is to revise your data regularly and erase records that are irrelevant, outdated, or unnecessary otherwise. Still, it's sometimes difficult to determine if data will be or become unnecessary or irrelevant, especially when dealing with issues of compliance. To keep your organization compliant in any case, data archiving can help you solve two problems at once: you can ensure data accessibility on one hand, and save storage space on the other hand. To archive your SQL database in the cloud, you should first save that database copy to an Azure blob container. Then, to move a newly created blob to the archive tier in the Azure portal, do the following: Go to the required container where the SQL database is stored. Choose the blob that you need to move. Hit . Change tier 4. In the dropdown menu, choose . Access tier Archive 5. Hit . Save Additionally, the Archive storage tier is the most affordable one in Azure, meaning that you can reduce your database data TCO with it. Secondary Database and Table Management There exist several workflows that can help you set up Azure database backup archiving for your organization. When you need the data to stay in the initial database, for instance, creating a separate table and moving that data there can be your choice. However, the filegroup of that table should stay apart from the main database and be moved to a separate disk whenever possible. Most probably, you’ll want to let users access the data you send to a separate table. To make that happen, you can create a view merging the relevant tables and redirect the requests to that view, not to the original table. Doing things that way, you can keep the data accessible while dealing with maintenance faster. SQL Server Linking If you can’t move the data to another database for internal reasons such as special Azure backup policies, you can consider maintaining your primary database accordingly. Here, the outcome is likely to be that of the previous case, but you need to link the SQL servers or configure apps so they can send direct requests to your second server. The downside here is that your SQL database, which was supposed to be a backup one, becomes a production database and gains appropriate importance for an organization. There are two ways to create linked servers via SQL Server Management Studio (SSMS): (Transact-SQL) system stored procedure that creates a linked server sp_addlinkedserver SSMS GUI After you've ensured that you have appropriate access rights on both server instances you need to link, the network is configured appropriately to access them. SSMS is installed, you'll need to go through the following steps: First, open SSMS. Connect to the instance where you need to establish a linked server. Then find , then right-click . Object Explorer > Server Objects Linked Servers Pick from the dropdown: New Linked Server Then configure the server properties, including name, server type, provider, and product name: Then you'll just need to complete the security configuration, set up the server options, and complete connection testing. Original Data Deletion When you don’t need 24/7 data availability but need the data stored due to internal policies or compliance requirements, you can choose what's probably the simplest solution to increase storage space efficiency. Just back up the data that can stay unavailable and then delete the originals from the main database. Accessing any records you may need will still be possible via the backup. Stretch Database Aiming to make data management of organizations’ databases simpler, Microsoft implemented a Stretch Database feature in SQL Server 2016. With this feature, you can get an SQL backup to Azure after you send the data from the hosted database to an Azure SQL database. The method enables you to increase overall infrastructure cost-efficiency by simplifying backup workflows. To enable this workflow in your environment, develop the policy specifying the data on a hosted server to send to Azure. You don’t need to introduce any changes in applications that use the production database: SQL Server can independently get the records from the Azure SQL Database. Azure Database Backups Verification and Restoration During an SQL Azure database backup, you can choose to create such backups or without them. When the workflow is complete, I recommend you use the following command: . This command enables you to check the recoverability of backup files. WITH CHECKSUMS RESTORE VERIFYONLY To access the data, you can restore records from a backup to a different database. With Azure Automation scripts on backups, you can accelerate the restoration process, thus minimizing downtime and increasing the overall resilience of your Azure infrastructure. You need to follow only a few steps to restore an Azure SQL database to a required recovery point from a backup. Still, keep in mind that your subscription can define the available retention period which can vary from 7 to 35 days. A native tool for backup restoration to SQL servers is Server Management Studio. To Conclude The critical nature of Azure SQL database data makes Azure SQL backups obligatory for any organization that uses this Microsoft solution. In this guide, we reviewed the process of creating SQL Azure database backup using native Microsoft tools. These tools provide data backup, backup verification, and recovery functionality along with some automation. You can also implement a specialized all-in-one data protection solution, such as NAKIVO, the company where I work. It can help you make your data backup workflows more efficient.

A Comprehensive Guide for Backing Up and Restoring Azure SQL Databases

Craig Wright And The Bitcoin Supercomputer Fraud

About a year ago, I tried Next.js for the first time and was so impressed by their file-based routing that I decided to implement a similar system on the backend. I couldn't find anything suitable, so I took it upon myself to create my own solution. It turned out to be technology-agnostic and works with both pure and the popular Express.js. Node.js In this brief guide, we will attempt to partially implement a shop's API. This tutorial uses JavaScript and CommonJS module types to keep things simple and quick to get started. 1. Installation 💿 Install : node-file-router npm install node-file-router 2. Initialization Create a file and do the following: server.js If you use pure Node.js: // 1. Import default http module and node-file-router
const http = require('node:http');
const { initFileRouter } = require('node-file-router');

// 2. Create an entry-point function
async function run() {
  // 3. Initialize node-file-router and the handler function
  const useFileRouter = await initFileRouter();

  const server = http.createServer((req, res) => {
    // 4. Create a server and invoke created function on each request
    useFileRouter(req, res);
  });

  // 5. Start listening a server on 4000 port
  const port = 4000;
  server.listen(port, () =>
    console.log(`Server running at http://localhost:${port}/`)
  );
}

// 6. Run entry-point function
run(); If you use Express.js: const { initFileRouter } = require('node-file-router');
const express = require('express');

async function run() {
  const fileRouter = await initFileRouter();

  const app = express();

  app.listen(4000);
  app.use(fileRouter);
}

run(); 2. A first route 🏡 We will create a home route that displays welcome content. 1. Create an folder at the root of your project. api ├── api/ <-
├── server.js
└── package.json 2. Create a file named inside this folder: index.js ├── api/
│  └── index.js <-
├── server.js
└── package.json module.exports = function index(req, res) {
  res.end("Welcome to our shop!");
} 3. Run a server using: command 4. Open a browser and navigate to http://localhost:4000. You should see the message displayed. node server.js Welcome to our shop! Congratulations! 🎉 You've created a first file route 3. Add HTTP methods 1. Before we start, we need a small utility function that will parse JSON from a request. Create a folder and put the file inside. utils http.utils.js ├── api/
├── ...
├── utils/
│  └── http.utils.js <-
... module.exports = {
  parseJson(request) {
    return new Promise((resolve, reject) => {
      let data = '';

      request.on('data', (chunk) => {
        data += chunk;
      });

      request.on('end', () => {
        try {
          const parsedData = JSON.parse(data);
          resolve(parsedData);
        } catch (e) {
          reject(e);
        }
      });
    });
  }
} 2. Create a folder called and an file inside it. products index.js ├── api/
│  ├── products/ <-
│  │  └── index.js <-
│  └── ...
... 3. Implement and methods: get post const { parseJson } = require('../../utils/http.utils');

module.exports = {
  get: (req, res) => {
    res.end('list of products');
  },
  post: async (req, res) => {
    const newProduct = await parseJson(req);
    res.end(`a product will be created: ${JSON.stringify(newProduct)}`);
  }
} 3. Open a browser and go to . You should see a message displayed. http://localhost:4000/products list of products 4. Make a POST request using , or any tool you like on . The response should display along with your content. curl Postman http://localhost:4000/products a product will be created Perfect! 🎉 Let's move on 4. Dynamic routes 1. Create a new file with the name inside the folder. [id] product ├── api/
│  ├── products/
│  │  ├── ...
│  │  └── [id].js <-
│  └── index.js
... 2. Fill it the same way as you did before: module.exports = {
  // Add the `routeParams` argument as the final argument to the function. This argument will contain
  // all the taken route parameters.
  get: (req, res, routeParams) => {
    const { id } = routeParams;
    res.end(`product ${id} info`);
  }
}; 3. Open a browser and go to . <br/>
The page should display a message: . http://localhost:4000/products/123 product 123 Alright, let's make it more sophisticated. Say, we want to address the following case: /catalog/tag-1/tag-2/tag-n 4. Create a folder with inside. catalog [[...categories]].js ├── api/
│  ├── catalog/
│  │  ├── ...
│  │  └── [[...categories]].js <-
│  ├── index.js
... And add a single method: get module.exports = {
  get: (req, res, routeParams) => {
    const { categories } = routeParams;

    // This type of route also covers just "/catalog"
    if (!categories) {
      return res.end('all products');
    }

    res.end(`get products that have such tags: ${categories}`);
  },
}; 5. Open a browser and go to . The page should display a list of categories: men, sneakers, Nike. http://localhost:4000/catalog/men/sneakers/nike 🥁 That's it! What's next? Discover more capabilities of the routing system Configuration and More Details Examples with Express, WebSockets, ECMAScript, and more How to create your own custom adapter and use it with your favorite framework

File-Based Routing in Node.js: A Brief Guide

A Comprehensive Guide to UAV Digital Forensics With DJI Drones

SwiftLint is the best tool to enforce coding standards and best practices. It comes with pre-defined rules that can be customized to suit individual project needs. However, sometimes the built-in rules fall short of project requirements. In such cases, we write regular expressions to fill the gap. While regex is a powerful tool, creating complex rules can be difficult or even impossible. This is where native SwiftLint rules come in. They're just like the rules that come with SwiftLint - they're written in Swift, efficient, and can catch more violations compared to regex. https://twitter.com/simjp/status/1558168307756318720?s=20&embedable=true The final project can be found at https://github.com/jpsim/swiftlint-bazel-example Setting Up the Project Install Bazel if not installed. brew list --formula | grep -q "bazel" || brew install bazel Start by creating a new directory. mkdir MySwiftLintRules && cd MySwiftLintRules Next, set up a new Bazel workspace. This involves creating several files and enabling bzlmod: touch .bazelrc WORKSPACE MODULE.bazel BUILD && echo "common --enable_bzlmod" > .bazelrc Add the boilerplate code to the MODULE.bazel module(
    name = "swiftlint-bazel-example",
    version = "0.0.0",
    compatibility_level = 1
)

bazel_dep(name = "swiftlint", version = "0.51.0", repo_name = "SwiftLint")
extra_rules = use_extension("@SwiftLint//bazel:extensions.bzl", "extra_rules")
extra_rules.setup(srcs = "@swiftlint-bazel-example//swiftlint_extra_rules:extra_rules")

bazel_dep(name = "rules_xcodeproj", version = "1.4.0") Add the boilerplate code to the file. This will add Xcode support for our Bazel project. BUILD load("@rules_xcodeproj//xcodeproj:defs.bzl", "xcodeproj")

xcodeproj(
    name = "swiftlint_xcodeproj",
    project_name = "SwiftLint",
    tags = ["manual"],
    top_level_targets = [
        "@SwiftLint//:swiftlint",
        "@SwiftLint//Tests:ExtraRulesTests",
    ],
) Create a directory to store the source code for your rules. mkdir swiftlint_extra_rules && touch swiftlint_extra_rules/Rules.swift && touch swiftlint_extra_rules/BUILD And for the last time, paste the boilerplate code to the file swiftlint_extra_rules/BUILD filegroup(
    name = "extra_rules",
    srcs = glob(["**/*.swift"]),
    visibility = ["//visibility:public"],
) At this point, you should be able to build SwiftLint using the command. bazel build Developing Rules With Xcode We’ve added dependency to our project to make developing your custom rules easier. So, let’s generate our project: rules_xcodeproj bazel run swiftlint_xcodeproj && open SwiftLint.xcodeproj -a Xcode Now, we can build and debug the scheme. You can use this app as usual with swiftlint binary installed from the homebrew. swiftlint Try running it on your project: Click the scheme name in the , click “Edit Scheme…“, and set the "Working Directory" in the "Options" tab to the path where you would like to execute SwiftLint. toolbar of your project window For more information on developing native SwiftLint rules, check out SwiftLint’s CONTRIBUTING.md Adding a Custom Rule In this example, we are creating the "forbidden var rule," as shown in the video tutorial at . https://vimeo.com/819268038 Copy and paste this code into the file, then run the scheme in Xcode. Rules.swift swiftlint import SwiftSyntax

// This function should return an array containing all of your custom rules
func extraRules() -> [Rule.Type] {
	[ForbiddenVarRule.self]
}

struct ForbiddenVarRule: ConfigurationProviderRule, SwiftSyntaxRule {
	var configuration = SeverityConfiguration(.error)

	init() {}

	static let description = RuleDescription(
		identifier: "forbidden_var",
		name: "Forbidden Var",
		description: "Variables should not be called 'forbidden'",
		kind: .idiomatic,
		nonTriggeringExamples: [
			Example("let notForbidden = 0")
		],
		triggeringExamples: [
			Example("let ↓forbidden = 0")
		]
	)

	func makeVisitor(file: SwiftLintFile) -> ViolationsSyntaxVisitor {
		Visitor(viewMode: .sourceAccurate)
	}
}

private extension ForbiddenVarRule {
	final class Visitor: ViolationsSyntaxVisitor {
		override func visitPost(_ node: IdentifierPatternSyntax) {
			if node.identifier.text == "forbidden" {
				violations.append(node.identifier.positionAfterSkippingLeadingTrivia)
			}
		}
	}
} And that's it! You've created a custom SwiftLint rule and integrated it into your Swift project using Bazel. With this setup, you can create and test as many custom rules as you need, helping to ensure that your code stays consistent and conforms to your team's coding standards. Happy linting!

Embrace the Power of Custom SwiftLint Rules and Say Goodbye to Regex

কাস্টম সুইফ্টলিন্ট নিয়মের ক্ষমতা আলিঙ্গন করুন এবং Regex কে বিদায় বলুন

Nutzen Sie die Leistungsfähigkeit benutzerdefinierter SwiftLint-Regeln und verabschieden Sie sich von Regex

Adopte el poder de las reglas personalizadas de SwiftLint y diga adiós a Regex

Adoptez la puissance des règles SwiftLint personnalisées et dites adieu à Regex

कस्टम स्विफ्टलिंट नियमों की शक्ति को अपनाएं और रेगेक्स को अलविदा कहें

カスタム SwiftLint ルールのパワーを活用し、正規表現に別れを告げましょう

사용자 정의 SwiftLint 규칙의 강력한 기능을 활용하고 Regex에 작별을 고하세요.

Abrace o poder das regras personalizadas do SwiftLint e diga adeus ao Regex

Özel SwiftLint Kurallarının Gücünü Kucaklayın ve Regex'e Elveda Deyin

Nắm bắt sức mạnh của các quy tắc SwiftLint tùy chỉnh và nói lời tạm biệt với Regex

拥抱自定义 SwiftLint 规则的力量并告别正则表达式

https://www.youtube.com/watch?v=az-va7ofef8&embedable=true Introduction For those not familiar with Ambient TVs, it’s a way to soften the jump from the edge of the TV screen and its immediate surroundings to provide a more immersive experience. I had some LED lights lying around and decided to see if it was possible to control the lights through code and, in turn, make my computer screen an ambient monitor. Whilst I wanted to use it for my monitor, it can be used anywhere and with whatever colors you can send it, including other features your lights may have, such as audio reactions or random patterns. I’ve been meaning to write this post for a while as I’ve been using it on an earlier monitor, but I never got around to adding it to my new monitor, so I documented it as I went along for anyone who might find it useful. So let’s get to it! (Please note, LED lights are likely to be Bluetooth Low Energy (BLE), so your computer will need to support BLE in order to interact with them). The full code is on . GitHub High Level Steps Find out what commands the LED light’s Bluetooth receiver accepts Send commands to the LED lights via my computer’s Bluetooth Obtain the dominant color of the current screen Send the dominant color to the LED lights Prerequisites Bluetooth-supported RGB LED lights and accompanying app (I’m using Android, iOS would likely require an alternative approach than the one described here, but it should be possible to use Wireshark directly to monitor Bluetooth traffic). I've attached these lights to the back of my monitor Wireshark (specifically adb.exe) Android’s SDK tools Developer tools (I’ll be using Python 3.10, though any 3.x versions should work, but the principles should be the same whatever for language you prefer) A device to send BLE commands from (e.g. a laptop that supports BLE) Getting Bluetooth data The first step we need to do is to ensure that the app that comes with the lights is working as expected. This can easily be tested by running the light’s original app and making sure that the lights react accordingly depending on the on/off/lighting buttons you’re pressing on your app. We do this because we will shortly be pressing and detecting the specific codes sent to the Bluetooth receiver on the lights. There are two approaches that I could take. One was to decompile the app’s JAR file and find the codes that were being sent, but I wanted to learn more about the Bluetooth protocol, so I opted to log all Bluetooth activity on my Android and extract it from there. Here’s how: Enable on your Android device. Developer Options Enable Bluetooth HCI snoop log (HCI stands for Host-Controller Interface). You can find this option in or search for it in settings as in the image below. Settings > System > Developer We now need to perform specific actions so we can identify what each action sends to the light’s Bluetooth receiver. I’m going to keep it simple to On/Red/Green/Blue/Off, in that order, but if your lights support other features, you can toy around with those too. Run the app and press On, Red, Green, Blue, and Off. It may also be useful to keep an eye on the approximate time to make it easier to filter if you have a lot of Bluetooth activity on your device. Turn Bluetooth off so we don’t get any more noise. In the following steps, we’ll analyze the Bluetooth commands and, as we know the order of what we pressed, we can find out which values correspond to which button press. We now need to access the Bluetooth logs on the phone. There are several ways to do this, but I will generate and export a bug report. To do this, enable USB Debugging in the phone’s Settings, connect the phone to the computer, and use the adb.exe command line tool. adb bugreport led_bluetooth_report This will generate a zip file on your computer’s local directory with the filename “ ”. You can specify a path if you prefer (e.g. C:\MyPath\led_bluetooth_report”) led_bluetooth_report.zip Within this zip are the logs that we need. This may vary from device to device (please comment if you found it elsewhere on your device). On my Google Pixel phone, it was in FS\data\misc\bluetooth\logs\btsnoop_hci.log Now we have the log files, let’s analyze them! To do this, I decided to use Wireshark so start Wireshark and go to File...Open... and select the btsnoop_hci log file. Whilst it may look daunting, let’s make it easy for ourselves to find what we’re looking for by filtering the on which is the Attribute Protocol in the . The attribute protocol defines the way two BLE devices talk to each other, so this is what we need to help find how the app talks to the lights. You can filter the logs in Wireshark by typing in the “ ” bar near the top and press Enter BTL2CAP 0x0004, Wireshark source code btl2cap.cid == 0x0004 Apply a display filter Now we have filtered the log; it should make looking for the commands easier. We can look at the timestamps (Go to View…Time Display Format…Time of Day to convert the time if it’s the wrong format). We want to look at the Sent Write Command logs as those are the ones where we sent a value to the lights. Assuming your most recent time is at the bottom, scroll down to the last five events. These should be On, Red, Green, Blue, and Off in that order, with Off being last. Take note of the Destination BD_ADDR, as we'll need that shortly, and put on your Sherlock Holmes hat, as this is where we need to unlock the pattern of how the colors and on/off commands are encoded within the message. This will vary depending on the light manufacturer but here’s the list of values I got for my device: On: 7e0404f00001ff00ef Red: 7e070503ff000010ef Green: 7e07050300ff0010ef Blue: 7e0705030000ff10ef Off: 7e0404000000ff00ef These are clearly hexadecimal values and if you look carefully, you’ll see there are some fixed patterns. Let’s split the patterns out as this should make things much clearer. On: 7e0404 ff00ef f00001 Red: 7e070503 10ef ff0000 Green: 7e070503 10ef 00ff00 Blue: 7e070503 10ef 0000ff Off: 7e0404 ff00ef 000000 For those familiar with hexadecimal values of pure red, green, and blue, you’ll know that the values are #FF000, #00FF00, and #0000FF, respectively, which is exactly what we can see above. This means we now know the format to change the colors to whatever we want! (or at least to what the lights themselves are capable of). We can also see that On and Off have a different format from the colors and are similar to each other, with On having f00001 and Off having 00000. That’s it! We now have enough information to start coding and interacting with the lights. Connecting to LED lights There are three key things we need: The address of the device (this is the Destination BD_ADDR from above) The values to send to the device (the hexadecimal values obtained above) The characteristic we want to change. A Bluetooth LE characteristic is a data structure that essentially defines data that can be sent between a host and client Bluetooth devices. We need to find the characteristic (a 16-bit or 128-bit UUID) that refers to the lights. There are some commonly used assigned numbers that can be found here but unless the device conforms to those, they could be using a custom UUID. As my lights aren’t in the assigned numbers list, let’s find it via code. I’m using Python 3.10 and . Ensure Bluetooth on your computer is turned on (no need to pair with the device, we’ll connect to it through code). Bleak 0.20.1 # Function to create a BleakClient and connect it to the address of the light's Bluetooth reciever
async def init_client(address: str) -> BleakClient:
    client =  BleakClient(address)  
    print("Connecting")
    await client.connect()
    print(f"Connected to {address}")
    return client

# Function we can call to make sure we disconnect properly otherwise there could be caching and other issues if you disconnect and reconnect quickly
async def disconnect_client(client: Optional[BleakClient] = None) -> None:
    if client is not None :
        print("Disconnecting")
        if characteristic_uuid is not None:
            print(f"charUUID: {characteristic_uuid}")
            await toggle_off(client, characteristic_uuid)
        await client.disconnect()
        print("Client Disconnected")
    print("Exited")

# Get the characteristic UUID of the lights. You don't need to run this every time
async def get_characteristics(client: BleakClient) -> None:
    # Get all the services the device (lights in this case) 
    services = await client.get_services() 
    # Iterate the services. Each service will have characteristics
    for service in services: 
        # Iterate and subsequently print the characteristic UUID
        for characteristic in service.characteristics: 
            print(f"Characteristic: {characteristic.uuid}") 
    print("Please test these characteristics to identify the correct one")
    await disconnect_client(client) I’ve commented on the code, so it should be self-explanatory but essentially, we connect to the lights and find all the characteristics it exposes. My output was: Characteristic: 00002a00-0000-1000-8000-00805f9b34fb
Characteristic: 00002a01-0000-1000-8000-00805f9b34fb
Characteristic: 0000fff3-0000-1000-8000-00805f9b34fb
Characteristic: 0000fff4-0000-1000-8000-00805f9b34fb A quick Google of the first two UUIDs shows this refers to the name and appearance of the service, which is irrelevant for us. However, the third and fourth seem the most suitable with the third ( ) being the write characteristic according to . Excellent, we now have the characteristic we need for this particular device to write to with a value (the color hexadecimal). 0000fff3-0000-1000-8000-00805f9b34fb this page Controlling LED lights We finally have all the pieces this we need. At this stage, you can get creative with what color input you’d like to use. You could, for example, connect the lights to a trading market API to change colors according to how your portfolio is doing. In this case, we want to make our monitors ambient aware, so we need to obtain the dominant color of the screen and send that through. There are many ways to do this, so feel free to experiment with whatever algorithms you would like. One of the simplest approaches would be to iterate every X number of pixels across the screen and take an average while more complicated solutions would look for colors human eyes perceive to be more dominant. Feel free to comment on any findings you’d like to share! For the sake of this blog post, I’m going to keep it simple by using the library’s get_dominant_color method. fast_colorthief '''
Instead of taking the whole screensize into account, I'm going to take a 640x480 resolution from the middle. 
This should make it faster but you can toy around depending on what works for you. You may, for example, want
to take the outer edge colours instead so it the ambience blends to the outer edges and not the main screen colour 
'''
screen_width, screen_height = ImageGrab.grab().size #get the overall resolution size 
region_width = 640
region_height = 480
region_left = (screen_width - region_width) // 2
region_top = (screen_height - region_height) // 2
screen_region = (region_left, region_top, region_left + region_width, region_top + region_height)

screenshot_memory = io.BytesIO(b"")

# Method to get the dominant colour on screen. You can change this method to return whatever colour you like
def get_dominant_colour() -> str:
    # Take a screenshot of the region specified earlier
    screenshot = ImageGrab.grab(screen_region)
    '''
    The fast_colorthief library doesn't work directly with PIL images but we can use an in memory buffer (BytesIO) to store the picture
    This saves us writing then reading from the disk which is costly
    '''
    
    # Save screenshot region to in-memory bytes buffer (instead of to disk)
    # Seeking and truncating fo performance rather than using "with" and creating/closing BytesIO object
    screenshot_memory.seek(0)
    screenshot_memory.truncate(0)
    screenshot.save(screenshot_memory, "PNG") 
    # Get the dominant colour
    dominant_color = fast_colorthief.get_dominant_color(screenshot_memory, quality=1) 
    # Return the colour in the form of hex (without the # prefix as our Bluetooth device doesn't use it)
    return '{:02x}{:02x}{:02x}'.format(*dominant_color) The code is commented, so hopefully, it should be clear as to what’s happening, but we’re taking a smaller region of the screen from the middle and then getting the dominant color from that region. The reason I’m taking a smaller region is for performance; fewer pixels would need to be analyzed. We’re almost there! We now know what to send it and where to send it. Let’s finish the last major part of this challenge which is to actually send it. Fortunately, with the Bleak library, this is quite straightforward. async def send_colour_to_device(client: BleakClient, uuid: str, value: str) -> None:
    #write to the characteristic we found, in the format that was obtained from the Bluetooth logs
    await client.write_gatt_char(uuid, bytes.fromhex(f"7e070503{value}10ef"))

async def toggle_on(client: BleakClient, uuid: str) -> None:
    await client.write_gatt_char(uuid, bytes.fromhex(ON_HEX))
    print("Turned on")

async def toggle_off(client: BleakClient, uuid: str) -> None:
    await client.write_gatt_char(uuid, bytes.fromhex(OFF_HEX))
    print("Turned off") As we discovered from the logs, each color has a fixed template, so we can use f-strings to hardcode the common part and simply pass a hexadecimal of a color for the value in the middle. This can be called from our loop. On and Off had unique hexademicals so I created individual functions and passed in a constant value that contained the relevant hex. while True: 
    # send the dominant colour to the device
    await send_colour_to_device(client, characteristic_uuid, get_dominant_colour())
    # allow a small amount of time before update
    time.sleep(0.1) And there we have it; our Bluetooth LED lights are now controlled by the colors on the screen, creating our own Ambient Monitor. You can see the full code on , which has a small amount of infrastructure code that wasn't specific to this post. I’ve tried to comment the code to be self-explanatory but feel free to ask any questions or make suggestions. GitHub Hopefully, this gives you an idea on how you can start getting creative with your LED lights. Future Improvements - My light strips can only have one color at a time, but I have another set that can have four quadrants, each with its own colors. This means it could be possible to have sections of the monitor match four sections on screen giving an even more accurate ambiance setting. Those lights run on Wifi instead of Bluetooth and could be a future project. Multi-colour – to keep it simple, I just looked for the color changing and the on-and-off commands. However, this can easily be improved by detecting the brightness control commands and throwing that into the color algorithm. Brightness - As we want to get the lights to change in realtime, performance is critical. There are some complex algorithms to detect which color would be considered the most dominant, especially when perceived by humans (which leads to a whole world of color conversions). However, since this needs to run quite quickly, there needs to be a balance between performance and accuracy. A future improvement could be to try and access the graphics card directly to read from the buffer rather than analyzing the pixels on the screen directly. If this is possible, you would also eliminate the time taken from the graphics buffer to the screen which could optimize the reaction of the lights. Performance Feel free to comment below if you have any feedback or questions. Also Published Here

Reverse Engineer LED Lights with Python to Convert your Computer Monitor to an Ambient Monitor

আপনার কম্পিউটার মনিটরকে অ্যাম্বিয়েন্ট মনিটরে রূপান্তর করতে পাইথনের সাথে বিপরীত প্রকৌশলী এলইডি লাইট

Reverse Engineer von LED-Leuchten mit Python, um Ihren Computermonitor in einen Umgebungsmonitor umzuwandeln

Ingeniería inversa de luces LED con Python para convertir el monitor de su computadora en un monitor ambiental

Reverse Engineering LED Lights avec Python pour convertir votre écran d'ordinateur en un moniteur ambiant

अपने कंप्यूटर मॉनिटर को एक एम्बिएंट मॉनिटर में बदलने के लिए पायथन के साथ रिवर्स इंजीनियर एलईडी लाइट्स

Python で LED ライトをリバース エンジニアリングして、コンピューター モニターをアンビエント モニターに変換する

Python을 사용하여 LED 조명을 리버스 엔지니어링하여 컴퓨터 모니터를 주변 모니터로 변환

Luzes LED de engenharia reversa com Python para converter seu monitor de computador em um monitor ambiente

Bilgisayar Monitörünüzü Ortam Monitörüne Dönüştürmek için Python ile Tersine Mühendislik LED Işıkları

Kỹ sư đảo ngược đèn LED với Python để chuyển đổi màn hình máy tính của bạn thành màn hình xung quanh

使用 Python 对 LED 灯进行逆向工程，将您的计算机显示器转换为环境显示器

Sometimes we encounter problems processing big files using Node.js because the main thread (responsible for the event loop) can stop. For this reason, I decided to write about how to use streams in Node.js showing a funny example. Let's go! : Node.js application that downloads a huge CSV file from Google Cloud Storage, processes the data, transforms it into a JSON file, extracts some data insights, and finally compresses the file and uploads it again to the Cloud Storage. (We are going to create a terminal progress bar to visualize the process progress) Application : Main principles Streams: Interface to work with chunks of data. Readable Streams: Interface to consume data streams. Writable Streams: Interface to provide data and source to the data streams. Duplex Streams: Implement both interfaces, Readable and Writable. Transform Streams: It's a Duplex Stream used to modify the data during the process. PassThrough: It's a Transform Stream useful when we need to check or test something during the stream pipeline process. Pipeline: It's useful to handle all the stream process. : Steps to reproduce Download file stream Create a progress bar Transform each CSV file line into javascript objects Get information from the file Convert the data into JSON format Compress the data Upload the new file converted Requirements The CSV file you can find here We are going to use Node version 16.16 You need to have a Google account to access Google Cloud Services. Cloud Storage Service We need to install cloud storage library to deal with google cloud service. npm install @google-cloud/storage If you need help configuring your Cloud Storage service on your Google account, there are many tutorials that can help with that, it's not the purpose of this tutorial. Let's create our first file in folder to work with our storage. cloudStorageFileService.js src src/cloudStorageFileService.js const { Storage } = require('@google-cloud/storage')
const path = require('path')
const serviceKey = path.join(__dirname, '../gkeys.json')


class CloudStorageFileService {

// (1)
    constructor() {
        this.storage = new Storage({
            projectId: 'my-project-id',
            keyFilename: serviceKey
        })
    }

// (2)
    async downloadFile(bucketName, fileName) {
        return await this.storage
            .bucket(bucketName)
            .file(fileName)
            .createReadStream()
    }

// (3)
    async uploadFile(bucketName, destFileName) {
        return await this.storage
            .bucket(bucketName)
            .file(destFileName)
            .createWriteStream()
    }

// (4)
    async getFileSize(bucketName, fileName) {
        const [metadata] = await this.storage
                        .bucket(bucketName)
                        .file(fileName)
                        .getMetadata();
        return metadata.size
    }
}

module.exports = CloudStorageFileService From the code sections above: Basic configurations to use Cloud Storage service, as the project id and the path with your Google Cloud credentials. Google Cloud Storage provides us a Readable Stream for downloading files. We can use it to download our huge file as a stream and not have the main Node.js thread become stuck. Google Cloud Storage also provides a Writable Stream to upload files. The last function we are going to use to create our progress bar. Progress Bar Here we are extending because we don't need to apply any modification to the stream, only to get some data to create our progress bar. PassThrough It is important to know that Streams implement interface, and we can work with to emit events and to listen to them. Event Emitter emit on src/progressPass.js const { PassThrough } = require('stream')

class ProgressPass extends PassThrough {

// (1)
    constructor(fileSize, options = {}) {
        super({ ...options })
        this.on('data', this.processData)
        this.on('progress', this.showResult)
        this.on('close', this.finishProgress)
        this.bytesRead = 0
        this.progress = 0
        this.fileSize = fileSize
        this.createProgressBar()
    }

// (2)
    processData(data) {
        this.bytesRead += data.length
        this.progress = (this.bytesRead / this.fileSize) * 100
        this.emit('progress', Math.floor(this.progress))
    }

// (3)
    createProgressBar() {
        process.stdout.write("\x1B[?25l")
        process.stdout.write('[')
        for(let i = 1; i <= 101; i++) {
            process.stdout.write('-')
        }
        process.stdout.write(']')
    }

// (4)
    showResult(progress) {
        process.stdout.cursorTo(progress+1)
        process.stdout.write('=')


        process.stdout.cursorTo(105)
        process.stdout.write(`${progress}%`)

    }

    finishProgress() {
        process.stdout.write("\x1B[?25h")
        process.stdout.write("\n")
    }
}


module.exports = ProgressPass From the code sections above: Initializing our progress bar: The file size parameter added to the constructor will be useful to create the progress percentage. event is emitted when a new chunk comes to the current stream. data is our custom event that we emit to update the progress bar. progress is the event emitted when there is no more data to pass through the stream. close Every time new data comes we get the chunk and add to the sum the chunk's length and emitting event to update the progress bar. progress Creating a unfilled progress bar like: [------------------------------------------------] 4 When the event happens we update the progress bar with the current percentage: progress [===========-------------------------------------]  25% Transforming CSV Line Into a Javascript Object Now it's time to get every line of our CSV file and convert it to a JS object. The intention of this is to manipulate the data easier and at the final step of the process, convert it to a JSON file. The strategy is to convert the binary chunk into text, and to read every line of the it. To get the values we need to split the lines using . , When we are reading using streams, by default each chunk has 16kb (we can modify it). Moments of separation could occur similar to the examples below: chunk 1: value1, value2, val chunk 2: ue3, value4, value5 Keep in mind we need to treat this kind of thing and temporarily save the previous chunk before splitting the text. To treat the transformation we are going to use Transform Stream. As I mentioned it's useful when we want to transform our data chunks. src/objectTransform.js const { Transform } = require('stream')

class ObjectTranform extends Transform {

// (1)
    constructor(options = {}) {
        super({ ...options })
        this.headerLine = true
        this.keys = []
        this.tailChunk = ''
    }

// (2) 
    _transform(chunk, encoding, callback) {
        const stringChunks = chunk.toString("utf8")
        const lines = stringChunks.split('\n')

        for (const line of lines) {
            const lineString = (this.tailChunk + line)
            let values = lineString.split(',')

            if (this.headerLine) {
                this.keys = values
                this.headerLine = false
                continue
            }


            if (values.length !== this.keys.length || lineString[lineString.length - 1] === ',') {
                this.tailChunk = line
            } else {
                const chunkObject = {}

                this.keys.forEach((element, index) => {
                    chunkObject[element] = values[index]
                })

                this.tailChunk = ''
                this.push(`${JSON.stringify(chunkObject)}`)
            }
        }
        callback()
    }

// (3)
    _flush(callback) {
        callback()
    }

}

module.exports = ObjectTranform From the code sections above: Let's save the keys to create our JS objects using a flag. The is for saving the incomplete CSV lines. tailChunk The magic happens here. We read every line, split the text whether the lines are completed, and convert it to JS object. is called when there is no more data to be processed. flush Extracting Information Now that we have JS objects we can extract some data from the chunks. Here again, we are going to use PassThrough Stream because we only want to check some information. src/monitorTransform.js const { PassThrough } = require('stream')

class MonitorTransform extends PassThrough {
    constructor(options = {}) {
        super({ ...options })
        this.on('data', this.processData)
        this.on('close', this.showResult)
        this.totalCrimes = 0
        this.boroughTotal = new Map()
        this.monthTotal = new Map()
        this.yearTotal = new Map()
    }

// (1)
    processData(data) {
        const row = JSON.parse(data.toString())
        const rowCrimeQuantity = Number(row.value) || 0
        const currentBoroughTotal = Number(this.boroughTotal.get(row.borough)) || 0
        const currentMonthTotal = Number(this.monthTotal.get(row.month)) || 0
        const currentYearTotal = Number(this.yearTotal.get(row.year)) || 0

        this.totalCrimes += rowCrimeQuantity
        this.boroughTotal.set(row.borough, currentBoroughTotal + rowCrimeQuantity)
        this.monthTotal.set(row.month, currentMonthTotal + rowCrimeQuantity)
        this.yearTotal.set(row.year, currentYearTotal + rowCrimeQuantity)
    }

// (2)
    showResult() {
        console.log(this.totalCrimes)
        console.log(this.boroughTotal)
        console.log(this.monthTotal)
        console.log(this.yearTotal)
    }
}


module.exports = MonitorTransform From the code sections above: When a event happens we can process the chunk and get whatever we want from it. data If there is no more data to process we show the extracted information. Transforming The File to a JSON File All the chunks are in a JS object format, but when we save the file, this won't work properly. We need to treat it by transforming it into an array of objects using Transform Stream. src/jsonTransform.js const { Transform } = require('stream')

class JsonTransform extends Transform {
    constructor (options = {}) {
        super({ ...options })
        this.once('data', this.startJson)
        this.firstLine = true
    }

// (1)
    startJson() {
        this.push('[')
    }

// (2)
    _transform (chunk, encoding, callback) {
        const row = JSON.parse(chunk.toString())
        const newChunk = this.firstLine ? `${JSON.stringify(row)}` : `,${JSON.stringify(row)}`
        this.push(newChunk)
        if(this.firstLine) {
            this.firstLine = false
        }
        callback()
    }

// (3)
    _flush(callback) {
        this.push(']')
        callback()
    }

}

module.exports = JsonTransform From the code section above: Our array should start with , it happens only in the first chunk. Here we are using instead of , to listen only one time the event . [ once on data Here we are putting to separate our JS objects. , At the end of the file we need to close the array with ] Compressing The Chunks We don't need to exert a lot of effort for this step because Node.js has a core library to help. The from Node.js is a Transform Stream used to compress chunks of data during the streaming process. We only need to add this to our stream pipeline. zlib Creating The Stream Pipeline Process The pipeline process needs to have at least the Readable and the Writable Stream, and it can have how ever many Transform Streams and PassThrough Streams we want. To handle the pipeline process we are going to use the Builder design pattern, to control the creation process of our pipeline and throw some errors. src/fileProcessor.js const { pipeline } = require('stream/promises')

class FileProcessor {
    constructor() {
        this.readableStream = null
        this.transforms = []
        this.writableStream = null
    }

// (1)
    setReadable(readableStream) {
        this.readableStream = readableStream
        return this
    }

// (2)
    addTransforms(transformsStream) {
        this.transforms = transformsStream
        return this
    }

// (3)
    setWritable(writableStream) {
        this.writableStream = writableStream
        return this
    }

// (4)
    async execute() {
        try {
            if(!this.readableStream) {
                throw Error('Readable stream not implemented')
            }
            if(!this.writableStream) {
                throw Error('Writable stream not implemented')
            }
            await pipeline(this.readableStream, ...this.transforms, this.writableStream)
        } catch (error) {
            console.log(error)
        }
    }
}

module.exports = FileProcessor From the code section above: Setting our Readable Stream, in this case, should be the download function from Google Cloud Storage. Adding Transforms to our pipeline. All the Transform and PassThrough should be added as an array. The Writable Stream is the upload function from Google Cloud Storage. To execute the pipeline if there is the Writable and Readable Stream. The function must have at least these two functions. pipeline Joining Everything It's time to import everything we've created, define the constants, and execute the entire app. src/index.js // (1)
const FileProcessor = require('./fileProcessor')
const JsonTransform = require('./jsonTransform')
const MonitorTransform = require('./monitorTransform')
const ObjectTransform = require('./objectTransform')
const { createGzip } = require('node:zlib')
const CloudStorageFileService = require('./cloudStorageFileService')
const ProgressPass = require('./progressPass')
const fileProcessor = new FileProcessor()
const cloudFileService = new CloudStorageFileService()

// (2)
const gzip = createGzip()

// (3)
const bucketName = 'myfileuploads'
const fileName = 'london_crime_by_lsoa2.csv'
const destFileName = 'london_crime_by_lsoa2.tar.gz'

// (4)
    ;
(async () => {
    try {
        const fileSize = await cloudFileService.getFileSize(bucketName, fileName)
        await fileProcessor
            .setReadable(await cloudFileService.downloadFile(bucketName, fileName))
            .addTransforms([new ProgressPass(fileSize), new ObjectTransform(), new MonitorTransform(), new JsonTransform(), gzip])
            .setWritable(await cloudFileService.uploadFile(bucketName, destFileName))
            .execute()
    } catch (e) {
        console.log(e)
    }
})() From the code sections above: Here are all the things we've created, services, Transform Streams and PassThrough Streams. As I mentioned, this is the Node.js library to compress data. We need to define our Cloud Storage bucket and file. This is our final function to execute everything together, defining the Readable, Transforms, and the Writable. Takeaways You can use this approach to import and export data between databases or generate reports. Streams are useful to process and treat audio and video files and for file conversion. You can take a look at the entire code here Also published here

Processing Massive Amounts of On Demand Data  Without Crashing NodeJS Main Thread

AdTech Holding is committed to high technologies that ensure top-notch quality for all its products. Our business approach relies much on software development and thus implies having a team of strong IT specialists who have not only enormous expertise but also an inspiration to grow and create. We always encourage our tech teams to go beyond their normal daily, quarterly, and annual tasks — and it turns into brand new ideas and insights. Today, we are glad to share one of the great examples of such an insight. Our AppLab team is responsible for developing mobile apps, but recently they have gone beyond the limits and created their own app store platform. We spoke to Artem Kovardin, the Head of Product Development of App Lab, to get the idea of why you might need your app store platform and a detailed guide on how to build it. Reasons for building your own app store The first question that might arise is why would anyone need a store when there are already Google Play and AppStore. However, Artem shared two potential situations when such a solution can be very reasonable — and these cases include both personal and business purposes. Reason 1: Building a corporate infrastructure Many companies have their operations based on particular apps. Keeping them in the in-house store might significantly simplify access and control over the whole infrastructure. Besides, you can disable downloads of local apps from the other stores for all employers’ devices. Reason 2: Helping senior family members We mentioned personal reasons, and here is one. Seniors often face issues getting around the modern app stores and struggle to find and install the apps they need. Your own store will solve this problem: you can create a very simplified interface and control what your loved ones install on their devices. Creating App Store Platform: Ready Guide So you are determined to implement such a solution in your company or need to build a store for other reasons. Artem shared the best practices from his team’s experience and we are ready to bring out a step-by-step guide including all necessary tools. Step 1. Planning Like with every project, it’s essential to determine the final goal of the whole work. In our case, it is basically an app that will help to install other apps. The next question is how this app will work. Here are the tools that we recommend using according to our experience: Interface Flutter Native Logic Kotlin APK files downloading Company’s own API API The Go Language Another important point is how we are going to add the apps to the store. The work of a store platform implies that we require apps in the form of APK files. Some of them have direct links, published by developers. However, most apps are only available via Google Play, which means that the project requires a Google Play parser. To sum up, the whole ecosystem of the future app store platform will consist of three parts: Step 2. App Development Flutter allows the creation of an application store with minimum time and effort. Thus, we will mention the most complicated points that might cause difficulties. To manage state in the app, our team used two packages: along with . Such a solution turned out to be the simplest and the most convenient option for a Flutter app state management. provider state_notifier Another important take: before a user can install an app from the storage, they will need to download it first — and this step requires testing. To test how it works, the team added the APK file to a server to make the file available for download. Now you need to download it in the application: void download(String url, {Function? success, Function? error}) async {
	var name = basename(url);
	var request = http.Request('GET', Uri.parse(url));
	var response = client.send(request);
	String dir = (await getApplicationDocumentsDirectory()).path;

	List<List<int>> chunks = [];
	int downloaded = 0;

	response.asStream().listen((http.StreamedResponse r) {
    	r.stream.listen((List<int> chunk) {
            	print('downloaded: ${downloaded * Megabyte}');

            	chunks.add(chunk);
            	downloaded += chunk.length;
        	}, onDone: () async {
  	          print('downloaded: ${downloaded * Megabyte}');

            	var path = '$dir/$name';

            	File file = new File(path);
            	final Uint8List bytes = Uint8List(downloaded);
            	int offset = 0;
            	for (List<int> chunk in chunks) {
                    bytes.setRange(offset, offset + chunk.length, chunk);
                	offset += chunk.length;
            	}

            	await file.writeAsBytes(bytes);

            	if (success != null) {
                	success(path);
            	}

            	return;
        	}, onError: (err) async {
            	if (error != null) {
                	error();
            	}
    	});
	});
} The `getApplicationDocumentsDirectory()` function returns the path to the directory where you need to download the APK file. With the help of the `basename(url)` function we get the file name; to start background loading, we use the `response.asStream()`, and when the downloading is finished, we use the callback `success(path);`. As a result, we have the file and can install it. Here we require a part of a native Kotlin code. To get this code, we need to install the__ __ package and create particular contracts in the pideons/install/apk.dart file. pigeon import 'package:pigeon/pigeon.dart';


class InstallRequest {
  String? file;
}

class InstallResponse {
  bool? status;
}

@HostApi()
abstract class InstallApk {
  @async
  InstallResponse install(InstallRequest request);
} Then, we generate interfaces for a native code and the Dart code: flutter pub run pigeon \
  --input pigeons/install/apk.dart \
  --dart_out lib/pigeons/install/apk.dart \
  --java_out ./android/app/src/main/java/ru/kovardin/getapp/pigeons/install/Apk.java \
  --java_package "ru.kovardin.getapp.pigeons.install" Pigeon generates Java files, but we can use them in the Kotlin native code. Now it’s important to support `InstallApk` interfaces from the generated Java code: package ru.kovardin.getapp.install

import android.app.Activity
import android.content.Intent
import android.content.pm.PackageManager
import android.content.pm.ResolveInfo
import android.net.Uri
import android.os.Build
import android.util.Log
import androidx.core.content.FileProvider
import ru.kovardin.getapp.pigeons.install.Apk
import java.io.File


open class Apk(val context: Activity): Apk.InstallApk {
	override fun install(request: Apk.InstallRequest, result: Apk.Result<Apk.InstallResponse>?) {
    	Log.d("APK", "install apk ${request.file}")

    	try {
        	val file = File(request.file ?: "")
        	val intent = Intent(Intent.ACTION_VIEW)
        	val authority =  context.getApplicationContext().getPackageName().toString() + ".provider"
        	val type = "application/vnd.android.package-archive"

        	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            	val apk: Uri = FileProvider.getUriForFile(
                    	context,
  	                  authority,
                    	file
            	)

                intent.setDataAndType(apk, type)
            	val infos: List<ResolveInfo> = context.getPackageManager().queryIntentActivities(intent, PackageManager.MATCH_DEFAULT_ONLY)
            	for (info in infos) {
                    context.grantUriPermission(authority, apk, Intent.FLAG_GRANT_WRITE_URI_PERMISSION or Intent.FLAG_GRANT_READ_URI_PERMISSION)
            	}
                intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_GRANT_WRITE_URI_PERMISSION or Intent.FLAG_GRANT_READ_URI_PERMISSION)
                intent.putExtra(Intent.EXTRA_NOT_UNKNOWN_SOURCE, true)

        	} else {
            	intent.setAction(Intent.ACTION_VIEW)
                intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
                intent.putExtra(Intent.EXTRA_NOT_UNKNOWN_SOURCE, true)
                intent.setDataAndType(Uri.fromFile(file), type)
        	}
            context.startActivity(intent)
    	} catch (e: Exception) {
        	e.printStackTrace()
    	}

    	val response = Apk.InstallResponse();
    	response.status = true;
    	result?.success(response)
	}
} Overall, the app installation is the launch of intent with the right type and the APK file in parameters. The rest of the work is done by Android — automatically. The next thing we recommend to do is to check the SDK version. The future logic we will use to work with the APK file will depend on this SDK version. For SDK 23 or earlier versions, we can use a standard access to a file: `Uri.fromFile(file)`. This code is executed in the else section: intent.setAction(Intent.ACTION_VIEW)
intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
intent.putExtra(Intent.EXTRA_NOT_UNKNOWN_SOURCE, true)
intent.setDataAndType(Uri.fromFile(file), type) Things get more complicated when you work with SDK 24 or later versions. To do things correctly, we will need to add a separate section to the AndroidManifest.xml file: <application
    	android:allowBackup="true"
        android:label="@string/app_name">
    	<provider
            android:name="android.support.v4.content.FileProvider"
        	android:authorities="${applicationId}.authorityStr"
            android:exported="false"
            android:grantUriPermissions="true">
        	<meta-data
                android:name="android.support.FILE_PROVIDER_PATHS"
                android:resource="@xml/paths"/>
    	</provider>
</application> The`@xml/paths` is a separate resource file: paths.xml from the xml folder. We need to define this file’s content: <?xml version="1.0" encoding="utf-8"?>
<paths xmlns:android="http://schemas.android.com/apk/res/android">
	<external-path
            name="files_root"
            path="Android/data/${applicationId}" />
	<external-path
            name="external_files"
        	path="." />
	<root-path name="root" path="/data/" />
</paths> You will find a detailed guide on working with files in the Android SDK 24+ in developer documentation. Now we can call the native code from the Dart code. Pigeon generated the class that will be  used in the service. InstallApk final apk = InstallApk();
final response = await apk.install(InstallRequest(
	file: apk,
)); Another essential point is that you need to request a user permission before installing an APK. You can easily do it with the package. permission_handler Permission.storage.request().then((value) {
	print(value);

    Permission.requestInstallPackages.request().then((value) {
    	print(value);
	});
}); Step 3: API The easiest way to create API is to stick to the Go language, which perfectly suits these needs. To work with HTTP, our team recommends to use : a very simple, but efficient router. chi func (a *Api) Route(r chi.Router) {
  	r.Route("/v1", func(r chi.Router) {

        	r.Route("/apps", func(r chi.Router) {
              	r.Route("/{bundle}", func(r chi.Router) {
                    	r.Get("/", a.apps.One)
                    	r.Get("/download", a.apps.Download)
              	})
              	r.Get("/search", a.apps.Search)
              	r.Post("/updates", a.apps.Updates)
        	})

    	r.Get("/file/*", a.static.File)

        	// ...

  	})
} All APK files are stored in the AWS. To share them correctly, a service needs a handler, that will proxy all requests to files and add a special header: `headers.Set ("Content-Type", "application/vnd.android.package-archive"). This header is required to download files exactly in the .apk format: if you don’t use it, some Android devices will download them as .zip archives. func (h Static) File(w http.ResponseWriter, r *http.Request) {
  	headers := http.Header{}

  	ext := path.Ext(r.URL.Path)
  	if ext == ".apk" {
        	headers.Set("Content-Type", "application/vnd.android.package-archive")
  	}

  	proxy := httputil.ReverseProxy{
        	Director:  func(r *http.Request) {},
        	Transport: responseHeadersTransport(headers),
  	}

  	target := h.config.Scheme + path.Join(h.config.Cloud, strings.Replace(r.URL.Path, "file/", "", 1))
  	req, _ := http.NewRequest("GET", target, nil)
  	proxy.ServeHTTP(w, req)
} The rest of the work with API is standard, so we won’t call special attention to the further actions. To create an application store, you obviously need applications. They are all available in a ready store, and the easiest way is to get them from there. We are speaking about the Google Play that we need to parse — for information purposes only, of course. Part 4: Parser GitHub has a ready library for downloading APK files: . googleplay To start downloading files, you need to log in to Google Play: googleplay -email EMAIL -password PASSWORD This command will generate a special token file that we will use for requests. Then we generate a file with a device identifier — all requests will be performed from it: googleplay -device After everything is done, you will get access to information about an app you want to download: > googleplay -a com.google.android.youtube
Title: YouTube
Creator: Google LLC
UploadDate: 2022-05-12
VersionString: 17.19.34
VersionCode: 1529337280
NumDownloads: 11.822 B
Size: 46.727 MB
File: APK APK APK APK
Offer: 0 USD And download a particular version of any application: googleplay -a com.google.android.youtube -v 1529337280 The Result The AppLab team got the following platform as a result of all these efforts: It looks and works like a normal application store. And, after all, it turned out to be comparatively easy to develop. Artem insists that most part of the work lies on Android itself, while a developer needs to correctly download the APK files, get all permissions from a user, and launch a standard installation for Android. The result you see in the pictures shows an application store with a limited set of functions. All that it allows you to do is install apps on Android devices — not bad already, though. However, you can go further and add more things: Push Notifications via package, or package to realize the updates logic. firebase_messaging installed_apps

How to Build Your Own App Store

All software programs run on some Platform and most software applications today use some kind of Framework. We will try to understand the difference between a Platform and a Framework What is a Platform? We will start with a few words on Platform Business to avoid confusion with the main focus area of this write-up. Platform Business Model A works as a for a network of people/participants to carry out some activity. Most platform business models are supported by a technology infrastructure. eBay, Shopify, Facebook, Uber, etc. are all examples of the . Platform Business platform Platform Business Models This is not the focus of this article. Platform in Software Development A platform is a system that allows programs to be built and run on it. The platform provides services to make it easy to write a program. Operating Systems Linux, Windows, Android, etc. are platforms. They allow programs to be built and run, and they provide services for storage, memory management, network access, etc. via their APIs. The platform would need an Entry Point to run the program: method or similar mechanism. The platform calls the Entry Point and transfers the control of execution to the program. The program has control and it can do whatever it wishes using the services of the platform. main When the program is run, the platform execution service will locate the Entry Point and start program execution. From Entry Point onwards the Application program has the control of execution. . Application may use the services of the platform. The platform does not enforce anything A platform is an abstraction layer. It hides implementation details of common services and allows Applications built on the platform to focus on solving business problems. Are Java, NodeJs, .Net, etc. also Platforms? Yes, they are platforms. They allow other programs to be built and run on them, and they provide services to simplify Application development e.g., File I/O operations using APIs in Java or .Net are easier than using Operating System APIs directly. Most of them are now Platforms because they can work on any Operating System. Platform-independent What is a Framework? A framework gives a pre-defined structure to the Application. Frameworks are also an abstraction layer. They implement common repetitive tasks and allow the Application to focus on the problems it is solving. But still, they are different from Platform. The following diagrams explain it. Sample Code Code is in Java and Spring Boot but it should be easy to understand as other frameworks also have a similar mechanism. The platform calls the Entry Point to start the Application. The Entry Point then loads the Framework. Frameworks are hosted within an Application only. The Framework then goes through a process to find its Discovery Plugins class is a because it is annotated with . This tells Spring Framework that this is a Plugin. User Plugin @RestController In some cases, the plug-in may be identified by the implementation of an interface. The interface is declared by the Framework. The Spring Framework discovered that there is a Plugin that should be called when there is an API request with HTTP GET verb and URL path matching pattern. User /user/{id} When there is an API request with a URL , Spring will call the method on an object of class http://localhost:8080/user/AARE2212 get User The Framework and the Application both may use Platform services. Frameworks implement the pattern. it is called because Inversion of Control Inversion of Control the control of execution is always with the Framework. The plugin declares its intent when it would like to act so that the Framework can pass on control of execution by calling the Plugin. The framework calls the Plugin when events that Plugin is interested in occurs e.g. API request . . HTTP GET /user/{id} If an event that the Plugin is interested in doesn’t occur, the Framework doesn’t call the Plugin The framework takes care of common repetitive tasks and the Plugin focuses only on core Domain / Business logic. As the Application written on a Platform grows in size and complexity, it requires Frameworks to have better Maintainability and Productivity - make changes faster with less effort. Sometimes the concept of Framework can also be applied to the Application logic. Example: We need to write an API that can be used to upload different types of CSV files. On upload of the file, data in the CSV is stored in different tables. In the following sample code, controls the whole processing and performs common tasks during the file processing. It calls Plugins to do the actual processing of a File of a type supported by the Plugin. FileProcessController Adding support for a new type of file requires just writing the Plugin i.e. a Class implementing interface . IFileProcessor //Common Type for data transfer between Framework and Plugin 

public class FileProcessRequest {
  private String type;
  private String path;
}

//Plugins will implement this interface to declare they are a plugin

public interface IFileProcessor {
  FileProcessResponse process(FileProcessRequest request);
}

//A file processor implements interface and declares the File Type it supports

@SupportedFileType("SALES")
public class SalesFileProcessor implements IFileProcessor {
  @Override
  public FileProcessResponse process(Framework.FileProcessRequest request) {
     //perform some domain logic here
     return null;
  }
}
    
//Controller that controls the flow of whole workflow and performs common tasks required for all types of files. 

public class FileProcessController {

  public FileProcessResponse process(FileProcessRequest request) {

    scanFile(request);
    validateFile(request);
    IFileProcessor processor = getProcessor(request);
    if(processor != null) {
      return processor.process(request);
    } else {
      //log error and send notification
    }
    return null;
  }
} Platform-as-a-Service (PaaS) Based on what we discussed above, PaaS can be thought of as a . Platform to quickly build and run Distributed Applications PaaS offerings in Cloud provide various Compute, Storage, Networking, etc. services via APIs. An Application can be built and run using these services. If we take AWS for example, AWS Lambda - Compute Service to run the program RDS - Store data and run Database Server S3 - Storage Hope you have found this helpful. Please share your feedback in the comments.

Difference Between a Platform and a Framework

Welcome to other chapters of Let’s Understand Chrome V8 Dispatch is responsible for scheduling bytecode, which is equivalent to registering EIP++, and jumps to the next bytecode. Dispatch consists of two parts, one is a dispatch table and the other is the physical register. The table is an array that contains all bytecode addresses. V8 uses the physical register to dispatch bytecode for getting greater efficiency. 1. Dispatch Table The dispatch table is an array of pointers, which is used to store the address of the bytecode processing program. The array type is Code, and the Code Class is below: class Code: public HeapObject {
    public: NEVER_READ_ONLY_SPACE
    using Flags = uint32_t;
    #define CODE_KIND_LIST(V)\
    V(OPTIMIZED_FUNCTION)\
    V(BYTECODE_HANDLER)\
    V(STUB)\
    V(BUILTIN)\
    V(REGEXP)\
    V(WASM_FUNCTION)\
    V(WASM_TO_CAPI_FUNCTION)\
    V(WASM_TO_JS_FUNCTION)\
    V(JS_TO_WASM_FUNCTION)\
    V(JS_TO_JS_FUNCTION)\
    V(WASM_INTERPRETER_ENTRY)\
    V(C_WASM_ENTRY)
    enum Kind {
      #define DEFINE_CODE_KIND_ENUM(name) name,
        CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
      #undef DEFINE_CODE_KIND_ENUM
      NUMBER_OF_KINDS
    };
    static
    const char * Kind2String(Kind kind);
    #ifdef ENABLE_DISASSEMBLER
    const char * GetName(Isolate * isolate) const;
    V8_EXPORT_PRIVATE void Disassemble(const char * name, std::ostream & os,
      Address current_pc = kNullAddress);
    #endif
    //................omit................
  }; : In the isolate, there is another pointer array that is the same type as the dispatch table. It holds all the Builtins addresses, which can confuse beginners easily. Note The dispatch table is maintained by BuildWithMacroAssembler, code is below: Code BuildWithMacroAssembler(Isolate * isolate, int32_t builtin_index,
    MacroAssemblerGenerator generator,
    const char * s_name) {
    HandleScope scope(isolate);
    // Canonicalize handles, so that we can share constant pool entries pointing
    // to code targets without dereferencing their handles.
    CanonicalHandleScope canonical(isolate);
    constexpr int kBufferSize = 32 * KB;
    byte buffer[kBufferSize];
    MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
      CodeObjectRequired::kYes,
      ExternalAssemblerBuffer(buffer, kBufferSize));
    masm.set_builtin_index(builtin_index);
    DCHECK(!masm.has_frame());
    generator( & masm);
    int handler_table_offset = 0;
    // JSEntry builtins are a special case and need to generate a handler table.
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSConstructEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSRunMicrotasksEntry), Builtins::ASM);
    if (Builtins::IsJSEntryVariant(builtin_index)) {
      handler_table_offset = HandlerTable::EmitReturnTableStart( & masm);
      HandlerTable::EmitReturnEntry( &
        masm, 0, isolate -> builtins() -> js_entry_handler_offset());
    }
    //.....................................................
    //................omit.............................
  } You can see regarding how to debug the BuildWithMacroAssembler. When the value of the parameter builtin_index is 65, the function pointer generator points to which is responsible for maintaining the Dispatch table, code is below: Chapter 9 Generate_InterpreterEnterBytecodeDispatch static void Generate_InterpreterEnterBytecode(MacroAssembler * masm) {
    // Set the return address to the correct point in the interpreter entry
    // trampoline.
    Label builtin_trampoline, trampoline_loaded;
    Smi interpreter_entry_return_pc_offset(
      masm -> isolate() -> heap() -> interpreter_entry_return_pc_offset());
    DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero);
    // If the SFI function_data is an InterpreterData, the function will have a
    // custom copy of the interpreter entry trampoline for profiling. If so,
    // get the custom trampoline, otherwise grab the entry address of the global
    // trampoline.
    __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset));
    __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister);
    __ j(not_equal, & builtin_trampoline, Label::kNear);
    __ movq(rbx,
      FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset));
    __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag));
    __ jmp( & trampoline_loaded, Label::kNear);
    __ bind( & builtin_trampoline);
    // TODO(jgruber): Replace this by a lookup in the builtin entry table.
    __ movq(rbx,
      __ ExternalReferenceAsOperand(
        ExternalReference::
        address_of_interpreter_entry_trampoline_instruction_start(
          masm -> isolate()),
        kScratchRegister));
    __ bind( & trampoline_loaded);
    __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value()));
    __ Push(rbx);
    // Initialize dispatch table register.
    __ Move(
      kInterpreterDispatchTableRegister,
      ExternalReference::interpreter_dispatch_table_address(masm -> isolate()));
    // Get the bytecode array pointer from the frame.
    __ movq(kInterpreterBytecodeArrayRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp));
    if (FLAG_debug_code) {
      // Check function data field is actually a BytecodeArray object.
      __ AssertNotSmi(kInterpreterBytecodeArrayRegister);
      __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
        rbx);
      __ Assert(
        equal,
        AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry);
    }
    // Get the target bytecode offset from the frame.
    __ movq(kInterpreterBytecodeOffsetRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
    __ SmiUntag(kInterpreterBytecodeOffsetRegister,
      kInterpreterBytecodeOffsetRegister);
    // Dispatch to the target bytecode.
    __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister,
      kInterpreterBytecodeOffsetRegister, times_1, 0));
    __ movq(kJavaScriptCallCodeStartRegister,
      Operand(kInterpreterDispatchTableRegister, r11,
        times_system_pointer_size, 0));
    __ jmp(kJavaScriptCallCodeStartRegister);
  }
  //================================separation=========================
  void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler * masm) {
    Generate_InterpreterEnterBytecode(masm);
  } In the above code, the is the entry point of bytecode dispatch, and the is the key code that implements the bytecode dispatch. Here are two important concepts: Generate_InterpreterEnterBytecodeDispatch Generate_InterpreterEnterBytecode The is a Builtin and its index is 65. (The index may be dissimilar in different V8 versions) Generate_InterpreterEnterBytecodeDispatch V8 uses a physical register to manage the dispatch table, the name of the register is . Using the physical register can avoid the push and pop of the dispatch table frequently, to improve efficiency. kInterpreterDispatchTableRegister Here are the key lines of code： Line 35, loads the dispatch table to the A register. Line 37 of code, take out the table address from the isolate. The implementation of A is in the below three functions. (1) ExternalReference ExternalReference::interpreter_dispatch_table_address(
  Isolate * isolate) {
  return ExternalReference(isolate -> interpreter() -> dispatch_table_address());
}
interpreter::Interpreter * interpreter() const {
  return interpreter_;
}
Address dispatch_table_address() {
  return reinterpret_cast < Address > ( & dispatch_table_[0]);
} Line 39 takes out the bytecode array from the stack. (2) Line 51 takes out the offset of the target bytecode from the bytecode array. (3) Lines 56 and 58 calculate the target bytecode address and store the address in kJavaScriptCallCodeStartRegister. (4) Line 61 jumps to register kJavaScriptCallCodeStartRegister and executes bytecode. Figure 1 is the call stack. (5) 2. TailCall The Dispatch() is the last step in a bytecode, so its alias is the tail call. Let’s look at a few bytecodes： IGNITION_HANDLER(StaGlobal, InterpreterAssembler) {
    TNode < Context > context = GetContext();
    //omit..............
    Goto( & end);
    Bind( & no_feedback);
    CallRuntime(Runtime::kStoreGlobalICNoFeedback_Miss, context, value, name);
    Goto( & end);
    Bind( & end);
    Dispatch(); // !!! this is the tail call.
  }
  IGNITION_HANDLER(LdaContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here also is.
  }
  IGNITION_HANDLER(LdaImmutableContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here 
  } The above three bytecodes all end with Dispatch(). Below is the code of Dispatch: void InterpreterAssembler::Dispatch() {
    Comment("========= Dispatch");
    DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
    TNode < IntPtrT > target_offset = Advance();
    TNode < WordT > target_bytecode = LoadBytecode(target_offset);
    if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
      target_bytecode = StarDispatchLookahead(target_bytecode);
    }
    DispatchToBytecode(target_bytecode, BytecodeOffset());
  } The 2nd line is the comment function. When debugging, we can use its output information to locate the execution position. The 4th line takes out the offset of the target(next) bytecode. The 5th line loads the target bytecode. The 9th line calls which calls eventually. DspatchToBytecode() DispatchToBytecodeHandlerEntry() void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
  TNode < RawPtrT > handler_entry, TNode < IntPtrT > bytecode_offset) {
  // Propagate speculation poisoning.
  TNode < RawPtrT > poisoned_handler_entry =
    UncheckedCast < RawPtrT > (WordPoisonOnSpeculation(handler_entry));
  TailCallBytecodeDispatch(InterpreterDispatchDescriptor {},
    poisoned_handler_entry, GetAccumulatorUnchecked(),
    bytecode_offset, BytecodeArrayTaggedPointer(),
    DispatchTablePointer());
} In , parameter 1 is the target bytecode and 2 is the offset of the bytecode. Parameter 1 is used to load the bytecode handler and 2 is used to load operands. Then call , which is below: DispatchToBytecodeHandlerEntry TailCallBytecodeDispatch template < class...TArgs >
    void CodeAssembler::TailCallBytecodeDispatch(
      const CallInterfaceDescriptor & descriptor, TNode < RawPtrT > target,
        TArgs...args) {
      DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
      auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
        zone(), descriptor, descriptor.GetStackParameterCount());
      Node * nodes[] = {
        target,
        args...
      };
      CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
      raw_assembler() -> TailCallN(call_descriptor, arraysize(nodes), nodes);
    } In the above code, the 5th line creates the descriptor, as below: CallDescriptor * Linkage::GetBytecodeDispatchCallDescriptor(
    Zone * zone,
    const CallInterfaceDescriptor & descriptor,
      int stack_parameter_count) {
    const int register_parameter_count = descriptor.GetRegisterParameterCount();
    const int parameter_count = register_parameter_count + stack_parameter_count;
    DCHECK_EQ(descriptor.GetReturnCount(), 1);
    LocationSignature::Builder locations(zone, 1, parameter_count);
    locations.AddReturn(regloc(kReturnRegister0, descriptor.GetReturnType(0)));
    for (int i = 0; i < parameter_count; i++) {
      if (i < register_parameter_count) {
        // The first parameters go in registers.
        Register reg = descriptor.GetRegisterParameter(i);
        MachineType type = descriptor.GetParameterType(i);
        locations.AddParam(regloc(reg, type));
      } else {
        int stack_slot = i - register_parameter_count - stack_parameter_count;
        locations.AddParam(LinkageLocation::ForCallerFrameSlot(
          stack_slot, MachineType::AnyTagged()));
      }
    }
    MachineType target_type = MachineType::Pointer();
    LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
    const CallDescriptor::Flags kFlags =
      CallDescriptor::kCanUseRoots | CallDescriptor::kFixedTargetRegister;
    return new(zone) CallDescriptor( // --
      CallDescriptor::kCallAddress, // kind
      target_type, // target MachineType
      target_loc, // target location
      locations.Build(), // location_sig
      stack_parameter_count, // stack_parameter_count
      Operator::kNoProperties, // properties
      kNoCalleeSaved, // callee-saved registers
      kNoCalleeSaved, // callee-saved fp
      kFlags, // flags
      descriptor.DebugName());
  } In , parameter 2 is the target bytecode, and parameter 3 is the stack parameter count. This function is used to apply for register resources and create a . The gives what parameters to supply when executing a bytecode. The comments on lines 24 to 25 give its layout. GetBytecodeDispatchCallDescriptor CallDescriptor CallDescriptor In , the on the 9th line is below, we see that it’s parameter 1 is . TailCallBytecodeDispatch TailCallN() CallDescriptor void RawMachineAssembler::TailCallN(CallDescriptor * call_descriptor,
    int input_count, Node *
    const * inputs) {
    // +1 is for target.
    DCHECK_EQ(input_count, call_descriptor -> ParameterCount() + 1);
    Node * tail_call =
      MakeNode(common() -> TailCall(call_descriptor), input_count, inputs);
    schedule() -> AddTailCall(CurrentBlock(), tail_call);
    current_block_ = nullptr;
  } The 5th line generates a node. In the 7th line adds the node to the end of the current basic block. So far, the dispatch is completed and the next bytecode is started to execute. Figure 2 shows the function call stack. AddTailCall() Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. : qq9123013 : v8blink@outlook.com WeChat Email Also published . here

Stories, News & Mentions about FILEDROP

Filedrop’s Stories on HackerNoon