Smartmile

smartmile

A comprehensive list of the 7 most important SaaS trends in 2023. Most of them inevitably continued ruling the industry from 2022 but some are fresh and are here to change the course of it, maybe, forever. Customer expectations keep on pushing businesses to provide cutting-edge solutions and staying on top of the market trends may be exactly what will set you apart from competitors.
Let’s jump to it. 1. Future of work Remember the first weeks of COVID when everyone was miserable—even about the thought of working from home? There were so many unanswered questions: how will it affect my personal life? My pay rate? Should I still wear a suit during office hours? How will I cooperate with my colleagues and know what’s going on with the tasks? But the chaos died down pretty quickly when everyone realized the fantastic advantages of working remotely, and how your work-life situation is finally balanced after so many years. Now it’s a totally different conversation. People are ready to quit jobs that don’t offer remote setups. The data shows that the importance of remote software solutions is growing significantly, and companies are allocating more funds to satisfy scattered teams. Therefore, there’s a huge spike in collaboration software options. Every week there are at least a couple more newcomers on Product Hunt alone, and the stream of them doesn’t seem to be dying down in the near future. Top picks: / - ready-to-use templates, intuitive UI, and simplicity make these the power duo. Notion Slack - the number  of integrations is amazing and allows remote teams to share pretty much any piece of information in any format Slite (acquired by ) - it’s time to move from Excel sheets and Google Docs to a way more innovative platform Pipeline saas.group 2. Niche micro-Saases Overcomplicating and adding dozens of features and control buttons don’t work anymore. People don’t want every aspect of their life/business optimized, they want focus and smaller niche products to do the job. If you want a landing page, it’s irrational to go and learn Bubble or Webflow. Although they are fantastic at doing what they do, when you want to open a little coffee subscription business, you need a landing page to be recognizable and serve its purpose. Better yet, if the builder provides specific nooks for coffee fans. Although there’s a never-ending debate about a smaller market for vertical SaaS, then again, the advantages are great. For one, there’s a lower price CAC and less marketing spending. In vertical SaaS, you don’t expect to win everybody in the space but you do need to develop a pool of ambassadors that love and nurture your product. These fans offer exclusive and very focused insights into their needs. On the other hand, the churn in these businesses is usually very minimal. Top picks: - allows restaurant staff to pick, release, and swap shifts with a single click\ HotSchedules – A CRM tool designed specifically for home care agencies ClearCare - a platform that brings together all feedback into a single place Upvoty 3. AI If you haven’t heard of ChatGPT by now, you probably live in a sealed barrel underground. It has taken every news and social media outlet by storm, leaving no one behind and disrupting every industry on the way. From the hysterics of whether or not it’ll take all our jobs away to a more conscious approach where the creative mind behind the AI capabilities is not overlooked,  we’ve seen it all in a matter of a couple of weeks. And it can only mean one thing: AI is no longer something people are trying in a lab—it’s coming into our lives and, inevitably, into pretty much every business.
Software development platforms, obviously, took it to a new level first. But SaaS is not far behind offering all kinds of outstanding advantages to its users. The capabilities of AI seem endless, from optimizing business processes to automating redundant tasks. However, the utilization of those capabilities is only starting, and it’s a fraction of what it could become. AI has been causing changes in the SaaS industry since 2017, taking baby steps, and now it’s ready for the big leap. Top picks: - with the AI-enabled text editor, it delivers real-time language and grammar recommendations to the user. Grammarly - or Twilio Autopilot to be exact, helps bridge the gap between bots and humans through conversational AI Twilio - that explains and generates code saving developers hours of work Replit’s Ghostwriter 4. Low-code Low-code is often confused with no-code and perceived as a drag-and-drop solution that doesn’t require any technical skills whatsoever. In this particular case, low code means “less code” and is a solution that gives immediate advantages to software developers, ridding them of redundant tasks and allowing them to focus on business logic. SMEs have picked up on the advantages and lower costs of low-code development becoming one of the fastest adopters of the technology. And since low-code development is progressing far beyond app development, the increase in demand for it is inevitable. Limited financing no longer means slower or less functional technology. And with the growing number of deployment and integration options, scalability is less and less of an issue. Top picks: - one of the most powerful low-code platforms so far, giving enormous opportunities to tech founders to experience its features, and to non-tech founders, to find collaboration opportunities with skilled developers Replit - a design-to-code platform that offers fantastic opportunities to designers and understands the importance of the UI Locofy.ai - an up-and-coming new low-code platform with an increased level of abstraction powered by micro-apps, ridding developers of the most mundane tasks once and for all MarsX Inc 5. Extreme transparency through content Launching a SaaS is easier than ever before. No-code, low-code, and cloud platforms give you a chance to successfully implement your solution in a fraction of the time. The hardest part, though, is yet on you. Getting people to know about your product is hard and often takes a lot more dedication than building a product itself. Spend all your marketing budget (if it even exists) on social media ads? Seems like a great idea, but can you picture people clicking on a no-name brand ad? The price for a campaign can drown your funds very quickly and be a total miss after all.
To add, blind outreach on LinkedIn is simply bad manners. Community is the new holy grail for the founders, and building in public is a trend that won’t go away in the nearest future. Building in public and sharing every step of your journey can build trust and generate the buzz you need to get the first customers. Having several tiers to this strategy can also add a feeling of ownership and value to your users. There’s no need to sugarcoat your journey, too. 2022 has proven that people are hungry for real stories, and want to see a person behind the business more than ever. Everyone wants proof that you’re not a robot shipping 100 features a week and living a full life while raising a family and saving turtles on tropical islands. Showing vulnerability makes you oh-so relatable and makes people want to support you and your work. There are a ton of different formats you can play with when implementing this: articles, screencasts, screenshots, tweets and threads, photos, and much more. Find the ones that work for you and be real. Top picks: - simplifying your copywriting process Copy.ai - combining your data sources and services into a unified graph with GraphQL or TypeScript WunderGraph - business management and collaboration platform for freelancers and small businesses Plutio - complete payments, tax, and subscriptions solution for SaaS Paddle 6. Integrations With the rise of remote job opportunities, one thing has become clear - we need a better solution to keep track of all the content and data we have on hand. It’s often scattered in 100 different places, and getting to the bottom of it is a task nobody wants to deal with.
Create a tool that allows you to monitor all the data movements, see who’s responsible for which document, and how to get access to it, and you’re golden. We no longer want to choose and have one or the other. If it’s a file-sharing tool, let it cover everything from sharing passwords to documents to entire folders and see what exactly has been changed and by whom.
Zapier took the integration game to a whole new level, and the SaaS task is to keep up. Top Picks: - a password manager, digital vault, form filler, and secure digital wallet 1Password - resource management platform. And if you want more niche products - and are for you monday.com airfocus Smartsheet Digital asset management solutions: and Wedia Canto - secure file sharing & transfer SmartFile - task and project tracker Asana 7. Customer brand + employer brand Employees are empowered more than ever. 2 years of working from home showed no drop in productivity and, actually, even increased it for some industries. Everyone now advocates for more flexibility, cutting time for commuting, and better work-life balance. And employers are recognizing these claims and using them as leverage for creating more employee-friendly brands. According to Bloomberg - “Remote job posts draw more than half of all applications”. (Source: ) https://snip.ly/7zfb8m But a great employer brand is much more than just offering a remote setup. It’s about culture, trust, a feeling of ownership, and leveraging employees' strengths to create truly powerful teams. The future of work is finally entering every workspace and virtually “planting” diversity ideas doesn’t cut it. People are looking for truly integrated and diverse setups where they can feel comfortable and thrive. It also means creative adaptability where management takes trends and development seriously trying new tools and exploring personalized development opportunities. CONCLUSION That was the glimpse into the 7 SaaS trends that are here to stay. And, although, the world of software is constantly in flux, knowing the scope of what’s coming can cover the gaps in your growth strategy. With the industry adopting AI and taking integrations to the next level, the opportunities for growth are endless. Hopefully, this gave you a better idea of where SaaS is going. Also published . here

7 SaaS Trends to watch out for in 2023

In the current scenario, when the crypto transactions for goods and services is on the boiling side, it is essential to maintain a certain degree of privacy. Any crypto hodler knows that a transaction history can be traced by the recipient using only the wallet address of the payee. Since blockchain powers every cryptocurrency, each transaction is recorded on the blockchain network. Though it is tough to hijack a block or tamper recorded data, there are still loopholes that can be exploited for personal gains. Only if there was a way to keep the transactions anonymous! It turns out there is a solution which is, what the crypto geniuses are calling, crypto mixing. So, what is crypto mixing, and how does it work, adding an extra layer to privacy? As the term suggests, crypto mixing is simply mixing various cryptocurrencies to make the trail of original transaction source anonymous. That said, in practicality, it is not as simple as the explanation. There are different ways to tumble cryptocurrencies, each one offering something different to help keep privacy strong. Let’s take a look at a few crypto tumbler platforms to understand the concept in practice and what unique feature they have on their table. Smartmixer One of the newest and most reliable blending services is taking a road less travelled. Smartmixer isn’t simply mixing different coins to hide the trail, it blends the coins with random fund transfers. Smartmixer only accepts three coins at the moment including Bitcoin, Litecoin and Bitcoin Cash. The mixing process is reasonably quick and straightforward, and clients can choose from one of the three types of mix they want for their crypto. Either they can have their funds mixed with other user’s inbound funds. Or with other users’ fund along with crypto’s of investors and the reserved services. And finally, only with reserved services and investor’s coins, which the platform touts as stealth pool. The usability is pretty easy as well. One has to choose a coin from the mentioned above and send it to the entered address. Users can choose to delay the transaction, if they wish, by upto 72 hours or three days. Platform charges a nominal fee, 1% of the mixed coins, which also happens to be the profit model for Smartmixer. Anonymix Another notable name in the crypto tumbling world, especially if you’re looking for entirely anonymous Bitcoin transactions. Anonymix has a mix of hot and cold storage that results in a really sophisticated reserve system. This system ensures mixing of upto 100 Bitcoins, delivering absolutely traceless bitcoin. In layman’s term, a user’s BTC is mixed with bitcoins reserved in the company’s system pool. As it wasn’t hard enough, Anonymix gives its user even harder to trace options by providing a number of delay settings as well a feature to send BTC to more than one address. The option goes by the name Bulletproof mixing. This comprises of using blockchain analysis resistant algorithm to give the user the best possible BTC mix. On top of that, to entice more users, the platform has introduced a comparatively lower transaction fee of 0.3% — a payout of one Satoshi per transactions. Bitmix It’s one of the safest bitcoin tumblers out there. The objective here is to provide you untraceable Bitcoin and in order to do that, the platform takes your BTC and other user’s coin and tumbles it in a central mix to give you a different but same amount of BTC. Bitmix calls it cleaning the coin while keeping the transparent BTC network anonymous. Bitmix deducts a small fee of 0.4% - 4% for mining and 0.0005BTC for address output covering up any transaction charges incurred by the miners. The platform usually does mixing instantly but sometimes can take upto 24 hours given the amount of BTC a user is mixing. Any user is allowed to mix a minimum of 0.007 BTC to a maximum of 1000 BTC. When you’re mixing your coin with others, the probability of you getting your original coin rises. However, Bitmix has taken care of that as well. The user is provided with a code, this code is utilized to make use of the service, and the same code makes sure a user doesn’t receive the coin it originally submitted to the mix. Mixing cryptocurrency definitely seems like a viable option if a user is concerned with its privacy or wants to keep the transaction unknown to the recipient or anyone else. The platforms don’t keep any personal log or signs of a user using the platform or making a transaction. This in whole, adds a slight but much-needed layer of protection to the crypto ecosystem in general.

Fortifying Crypto-transactions' Anonymity via Crypto-Mixing Solutions

Survey and Analysis of Smart Contract Quality Assurance: Conclusions, Acknowledgement and References

Survey and Analysis of Smart Contract Quality Assurance: Defense Methodologies

The os package in Python provides a wide range of functionalities for interacting with the operating system. One of the most commonly used aspects of this package is its ability to perform file and folder operations such as iteration, deletion, creation, moving, and opening. In this article, we'll explore how to utilize the os package for these tasks. Iterate Through All the Items Within a Folder You can use the os package in Python to iterate through all the items within a folder using the os.listdir() method. And you can use the os.path.join function to concatenate the folder path with each item in the folder to get the absolute path. Here's an example of how to do it: import os

# Replace 'folder_path' with the path of the folder you want to iterate through
folder_path = 'path_to_folder'

# Iterate through all items in the folder
for item in os.listdir(folder_path):
		print(item) 
		# Get the absolute path of the item
		item_path = os.path.join(folder_path, item) 
		# Display the absolute path of the item
		print(item_path) In this example, returns a list of all the items (files and subfolders) in the specified folder. You can then iterate through this list and perform any operations you need for each item. os.listdir(folder_path) Remember to replace with the actual path of the folder you want to iterate through. 'path_to_folder' Deleting Files and Folders The package provides methods to delete both files and folders. Here's how you can achieve this: os To Delete a File: import os
os.remove('file_path/file.txt') To Delete an Empty Folder: import os
os.rmdir('folder_path')  # Replace with the actual folder path To Delete a Non-Empty Folder and All Its Contents: import shutil
shutil.rmtree('folder_path')  # Replace with the actual folder path Remember to replace and with the actual paths of the file or folder you want to delete. Use these functions with caution as they will permanently delete the specified files or folders. 'file_path/file.txt' 'folder_path' Creating Folders Creating a new folder using the package is straightforward: os import os
os.mkdir('new_folder')  # Replace with the desired folder name Moving and Renaming Files/Folders The package allows us to move and rename files and folders as well. Here's an example of moving a file: os import os
os.rename('old_location/file.txt', 'new_location/file.txt') Opening Files and Folders You can also open a folder in the default file explorer using the package. For instance, to open a folder in the File Explorer (Windows): os import os
os.startfile('folder_path')  # Replace with the actual folder path Conclusion The package in Python offers powerful capabilities for file and folder operations, allowing developers to efficiently manage file system tasks within their applications. os By utilizing the methods provided by the package, you can seamlessly iterate, delete, create, move, and open files and folders in your Python programs. os Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on . Happy exploring!👋 LinkedIn Also published here

How to Use the os Module for High-Level File Operations Such as Iterating, Moving, and More

As an iOS engineer, for the most time in my career, I have been “transforming JSONs into beautiful UI.” Compared to backend development, handling large amounts of data and doing performance optimizations is not a typical part of our work. Of course, from time to time, performance does matter – especially to make the UI smooth, but the techniques are often different – such as reusing views or offloading expensive work from the main thread. Additionally, if we want the client to be thin, most of the heavy job is delegated to the server; for example, content ranking, search, filtering, and so on. However, sometimes you still have to perform some expensive operations on the client side – for example, because for privacy reasons, you don’t want some local data to leave the device. It’s easy to accidentally make those parts of code extremely inefficient – especially if you haven’t built this muscle of quickly spotting potential complexity issues yet. Algorithms and data structures do matter – this is something I only truly realized only several years into my mobile career, and I still see this thing to be often overlooked in the industry. Of course, early optimization is not needed and may even do harm (see ), but even basic calculations can become performance bottlenecks that severely harm the user experience. premature optimization There is only one way to solve it – embrace the basics – which means using appropriate algorithms and data structures for the task at hand. that I always recall is a thing I built for one of my projects many years ago. One real example For an invitation flow, I had to implement a contact merge feature where the data would come from three different sources – the backend, social account, and the local iPhone address book. We wanted to combine contacts from these sources into one if they had any overlapping channels (phone numbers or emails). The result would be an array of contacts with all their channels, so there would be no duplicate channels for two different contacts. At first, my naive approach was just to go one by one and see if any in the remainder of the list, any contact has overlapping channels with the current one; merge them if yes, and repeat. This was needed because, for example, the last channel in the list could have two channels – one that would overlap with the current one, and the second one that could have appeared in the previous contacts which would mean having to go through the list again. I implemented this, and it worked pretty reliably, here is the pseudocode: func slowReliableSmartMerge(contacts: [Contact]) -> [Contact]  {
    var mergedContacts = contacts
    var results = [Contact]()
    var merged = true

    while merged {
        merged = false
        results.removeAll()

        while !mergedContacts.isEmpty {
            var commonContact = mergedContacts.first!
            let restContacts = mergedContacts.dropFirst()

            mergedContacts.removeAll()

            for contact in restContacts {
                if contact.hasNoOverlappingChannels(with: commonContact) {
                    mergedContacts.append(contact)
                } else {
                    merged = true
                    commonContact = Contact.mergedContactFrom(contact: commonContact, otherContact: contact)
                }
            }
            results.append(commonContact)
        }

        mergedContacts = results
    }

    return mergedContacts
} An experienced engineer would quickly spot the issue here, but please bear with me for a minute. I tested this on my device which had roughly 150 local contacts, 100 friends on social media, and a couple dozen users from the server. It would finish in just a couple of seconds after showing a spinner – “Not a huge deal,” I thought and moved on to the next feature. Test devices had much fewer contacts, so it worked instantly there. Then, a couple of weeks later, we started getting some reports from users that this spinner can take a minute or even longer. Suddenly, I realized that the issue was related to complexity, and then I figured that the approach I had taken could actually hit the O(n^2) complexity – similar to the bubble sort. I quickly discussed that with another engineer on a whiteboard, and we came up with hashmaps to optimize this significantly: func smartMerge(contacts: [Contact]) -> [Contact] {
    var channelToContact = [String: Contact]()
    var contactToChannels = [Contact: Set<String>]()

    for contact in contacts {
        var mergedContact = contact

        for channel in contact.allChannels {
            if let matchingContact = channelToContact[channel] {
                if mergedContact !== matchingContact {
                    let mergedMatchingContact = Contact.mergedContactFrom(contact: matchingContact, otherContact: mergedContact)
                    contactToChannels[mergedMatchingContact] = (contactToChannels[mergedContact] ?? []).union((contactToChannels[mergedMatchingContact] ?? []))

                    if let channels = contactToChannels[mergedContact] {
                        for c in channels {
                            channelToContact[c] = mergedMatchingContact
                        }
                    }

                    contactToChannels[mergedContact] = nil

                    mergedContact = mergedMatchingContact
                }
            } else {
                channelToContact[channel] = mergedContact

                if contactToChannels[mergedContact] != nil {
                    contactToChannels[mergedContact]!.insert(channel)
                } else {
                    contactToChannels[mergedContact] = [channel]
                }
            }
        }
    }

    return contactToChannels.keys
} The eventual complexity was linear, the spinner would just flicker for a split second, and the tests were luckily green. Since then, I’ve always been much more alert when it comes to doing some computation on the client side that potentially can have a variable-sized input. This all seems to be very obvious to me now, but back in the day, this didn’t look too important to me. I think having a proper understanding of the complexity that comes with various algorithms and data structures can make you a much better software engineer which will lead to better products you build. After all, this is how – they value coding skills more than knowledge of certain frameworks. the big tech companies hire These days, it’s also important for new folks who switch to software engineering from other areas – they often start their career with simple projects that involve UI work or simply connecting the stuff that’s built on top of well-known frameworks. I’d encourage them to also master the core things like algorithms in order to excel at this job.

Performance Bottlenecks Hiding on the Client Side and How to Approach Them

Banks, merchants, brands and nations have implemented literally hundreds of digital wallets as of this writing and in 2021 were used to make an astounding $15.9 trillion in payments.  Unfortunately, these wallets suffer from rampant problems such as questionable security, intrusive business models, black box design, and limited capabilities. And, they’re restricted by vendor lock-in to boot, with each wallet doing only a few things well. To address these limitations, Foundation Europe, part of the bigger Linux Foundation, recently announced the launch of the vendor-neutral OpenWallet Foundation (OWF), together with Visa, American Express and more than 30 for-profits and nonprofits. The OWF, while not publishing a wallet, seeks to become the core global standard that others leverage to truly consumer centric interoperable digital identities and digital wallets, driven by the investments in existing standards such as eIdas 2.0 and the EU Digital Wallet reference implementation. Linux True to its Linux Foundation roots, the OWF promises to follow the open source software ethos and create an open source engine that belongs to us all. Financial organizations of all shapes and sizes back the OWF and have vouched to create applications using the open software they create as a base for global, interoperable wallets. We might be witnessing the beginning of something big. As Daniel Goldscheider, the OpenWallet Foundation’s founder puts it: “With open source at the core of wallets, like it is at the core of web browsers, anyone can build a digital wallet that works with others and gives consumers the freedom to maintain their identity and verifiable credentials and share relevant data when, where, and with whom they choose.” If successful, the OWF will be crucial for humanity’s future, laying the foundation for interoperability among a wide range of wallet use cases, including making payments, proving identity, storing validated credentials such as employment, education, financial standing, and entitlements. By adopting the same open source core, crypto can potentially be used in any digital transaction. Not many think about validating credentials and proving identity while discussing a crypto wallet, but blockchain may very well be an ideal solution for global interoperable digital wallets. People need to know who they’re doing business with, who they are paying, and who they are playing with. And they need to trust them. If crypto wallets can serve as digital IDs, and the whole world runs on an interoperable engine, the future looks bright. Everyone, from giant corporations to small communities, can develop wallets that serve their specific use case. Thanks to the OWF, all of those wallets will be able to talk to each other. And that makes all the difference in the world. The Problem with Digital Wallets Today That all kinds of organizations are creating digital wallets today suggests these organizations, regardless of their actual intentions, are part of the problem – spreading vendor lock-in, questionable security and black box design, among other ills. The main problem with the current situation is that “without them all staying in sync, every country or organization that issues credentials could become a walled garden. IDs and wallets from elsewhere won’t work, disrupting travel, international students, and mobile workforces.” This is a major issue. An issue that resonates with the words of the Linux Foundation Europe’s Gabriele Columbro: “The world needs a place to store digital assets that matter, and the work of this foundation has the potential to redefine the credentials landscape globally, creating in turn much better digital experiences for people everywhere and new market opportunities.” The wallets of the future will be multi-faceted. Of course, they’ll sign crypto transactions, but they’ll also be used for “proving identity, storing validated credentials such as employment, education, financial standing, and entitlements. And all of this will “enable trust in the digital future.” The Linux Foundation, one of the most credible names in open source technology, is behind the crucial and much-needed initiative. Other names behind the OWF The OpenWallet Foundation is an initiative from the Linux Foundation Europe, but the names behind it are even more prominent, they “include Accenture, Gen, Futurewei and Visa.” Plus, among the general sponsors are "American Express, esatus AG, Fynbos, IAMX, IndyKite, Intesi Group, Ping Identity, SmartMedia Technologies (SMT), Spruce and Swisscom.” That’s not it, “more than 20 leading nonprofits and academic and government entities have joined the foundation.” Among them is the OpenID Foundation, whose chair Nat Sakimura said: "The experience and expertise of global technical Standards Development Organization (SDOs) like the OpenID Foundation and others can help guide the OpenWallet Foundation and increase opportunities for industry and governments.” The consumer and the open-source ethos seem to be at the core of the OpenWallet Foundation’s project. On the one hand, Visa’s Marie Austenaa said that their organization would be “adding our experience and expertise to enable the wider digital payments ecosystem, and make sure consumers have the greatest possible choice.” On the other, DIDAS’ Daniel Saeuberli promised, “together with OWF, we are committed to advancing a global open source approach to wallet data portability and interoperability.” Why the Right Time is Now In conjunction with the OpenWallet Foundation, the Linux Foundation released a . Titled, “Why the World Needs an Open Source Digital Wallet Right Now,” it starts with a little bit of history. “Twenty-five years ago, early-stage web browsers were incompatible and non-standardized. This threatened to derail the web. That threat brought everyone to the table to adopt a core set of standards that ensured interoperability and helped the web to flourish.” research paper stating their case And we want crypto to flourish, and this project is crucial for that to happen. Plus, as we already said, time is of the essence: “Our economic and social progress is being held back by the limitations of today’s digital wallets, especially the lack of interoperability. Meanwhile, many countries and groups are rushing ahead to create their own bespoke digital wallets. That’s why we need an open, secure digital wallet engine that anyone can use on any device, with any operating system, for any app or service, with any currency, in any language, anytime, anywhere. And we need it now.” The OWF will develop an engine that wants to run at the core of everyone’s digital wallet. That open system promises to be “highly secure,” “privacy-preserving,” and “interoperable.” So much so that they might even run at the core of at least one CBDC project. It’s the most important one, though. If you don’t believe us, this is what the executive director of the Digital Dollar Project, Jennifer Lassiter said: “Digital wallets will be at the forefront of providing improved privacy and security, serving as the interface with users around the world for their digital transactions. DDP is proud to be a founding supporter of the OpenWallet Foundation, as now is the time to ensure CBDCs and the user facing wallets are designed with these key principles in mind.” And if that wasn’t enough star power check out what Clive Smith, the executive director of ID2020, said: “It won't be long before digital wallets are the primary user interface by which individuals receive, store, and share their identification documents, educational credentials, health data, money, and other digital assets.” In Conclusion What the OWF proposes has huge implications for . The open-source engine that they’ll build practically guarantees that cryptocurrencies can potentially be included in every human transaction. The world’s identities and credentials will be secured by blockchains of all kinds. And cryptocurrencies and CBDC can be the default way in which future societies will exchange value. As we always believed they would. crypto In retrospect, it was inevitable from the very beginning. Information in this article was taken from the following resources: DISCLAIMER: https://www.prnewswire.com/news-releases/linux-foundation-europe-announces-formation-of-openwallet-foundation-301753956.html

Will the OpenWallet Foundation Deliver the Interoperability Digital Wallets Desperately Need? 

¿Ofrecerá OpenWallet Foundation la interoperabilidad que las billeteras digitales necesitan desesperadamente?

La Fondation OpenWallet fournira-t-elle l'interopérabilité dont les portefeuilles numériques ont désespérément besoin ?

क्या OpenWallet Foundation इंटरऑपरेबिलिटी डिजिटल वॉलेट की सख्त जरूरत को पूरा करेगा?

OpenWallet Foundation は、デジタルウォレットが切実に必要としている相互運用性を提供するでしょうか?

A OpenWallet Foundation fornecerá a interoperabilidade que as carteiras digitais precisam desesperadamente?

Liệu OpenWallet Foundation có cung cấp các ví kỹ thuật số có khả năng tương tác rất cần thiết không?

OpenWallet Foundation 会提供迫切需要的互操作性数字钱包吗？

Non-fungible tokens (NFTs) have taken crypto and the blockchain space by storm and have opened up a new way through which any artist or creative can monetize their content. However, it has been difficult for many artists and creators to fully understand how NFTs work and how/what data is stored. : Vested Interest Disclosure The author is an independent contributor publishing via our . Be it through direct compensation, media partnerships, or networking, the author has a vested interest in the company/ies mentioned in this story. HackerNoon has reviewed the report for quality, but the claims herein belong to the author. #DYOR. brand-as-author program Additionally, many artists who prefer doing things manually, and having control over their data, are reliant on platforms that have a high cost associated with maintaining NFTs. Specifically, most platforms will typically charge a specific percentage as a service cost from the selling price of an NFT, and this is a process that occurs with every single NFT minted or created on the platform in question. Additionally, storage needs for blockchain technology showcase that permanent storage for blockchain data can have a high cost associated with it initially. , which is an application-specific Layer-1 that developed SmartMint, aims to resolve this with the introduction of their permanent storage solution - Cascade. Pastel Network Cascade is a protocol that enables the storage of NFT data and metadata permanently within a highly redundant, distributed fashion with a single upfront fee. Today, we are going to explore everything users need to know about its usage and overall functionality. How A Blockchain Stores Data Blockchains are digital ledgers that store information – i.e. data. The data is stored in sequential blocks. In this case, every block within the blockchain gets identified through a distinct cryptographic hash, which is used to identify the previous block. Within each new block, data gets recorded and stored, after which it becomes a part of the overarching database or ledger. The Data Surrounding Non-Fungible Tokens (NFTs) NFTs have data associated with them which gets stored on the digital ledger. The NFTs in question can represent a specific digital or physical asset, such as an image, an art piece, music, or a highlight video or GIF file. In any case, all of this data needs to be recorded somewhere on the blockchain. This is due to the fact that an NFT can hold the digital asset itself and can even store a link to where the original asset can be found. What all of this essentially means is that storing an asset as an NFT can be costly due to the costs associated with its size. However, it does have benefits. Specifically, it's stored on the blockchain, which means the data is secure, immutable, and decentralized. SmartMint and Pastel Network’s Cascade Solution is a platform that has been developed to enable creators to create, manage, and mint non-fungible tokens (NFTs) on their own smart contracts without the need to learn a complicated programming language in order to do so. SmartMint The tool, however, features additional functionalities that enable it to stand out from many competing projects. One of the key features of interest here is an permanent NFT data storage solution known as Cascade, which provides fully distributed, permanent, and redundant data and metadata storage on-chain. Users just need to pay once and have all of the data stored permanently, and it can also prevent any points of failure that are typically commonplace among centralized systems. How Cascade Works And Its Importance In The Broader Blockchain Space Cascade is an integrated and decentralized storage layer that is based on advanced technology, including RaptorQ fountain codes. Pastel ensures that a digital asset’s data and metadata can be uploaded, verified, registered, and stored on-chain. This allows for data permanence. By utilizing a series of smart tickets which exist on top of the Pastel ledger, creators can store their assets in a distributed way across a variety of SuperNodes. Cascade has the goal of enabling 20, 50, or over 100 years of data storage for every single file stored on the Pastel Network, ensuring that anyone, with the corresponding credentials, can access it at any point in the future. Moving Forward With SmartMint and Cascade SmartMint, as a platform, aims to offer a no-code solution through which anyone can create non-fungible tokens (NFTs) without any prior knowledge of blockchain technology or coding. Any creator can use the platform to create their own NFTs whilst also retaining full ownership over their smart contracts. Additionally, through Cascade, creators have the NFTs permanently stored on the Pastel Network with a single upfront cost. All of these aspects make SmartMint the go-to solution for all creators to keep their digital works stored securely and permanently on-chain. Try out SmartMint today

How Pastel’s Cascade Stores NFT Data Securely

Cómo Pastel's Cascade almacena datos NFT de forma segura

Comment Cascade de Pastel stocke les données NFT en toute sécurité

कैसे पेस्टल का कैस्केड एनएफटी डेटा को सुरक्षित रूप से स्टोर करता है

Pastel’s Cascade が NFT データを安全に保存する方法

Como Pastel's Cascade armazena dados NFT com segurança

Cách Cascade của Pastel lưu trữ dữ liệu NFT một cách an toàn

Pastel 的 Cascade 如何安全地存储 NFT 数据

I was recently going through my notes of and was shocked to realize how actual this book still is. I'm going to share my summary of the book. I guarantee you'll find at least a few antipatterns in your current database design. SQL Antipatterns Logical Database Design Antipatterns Jaywalking Storing a delimiter-separated value string in a varchar field instead of creating an intersection table. It might be easier, but it makes queries harder. And updating the field is also a pain. And your field might have all kinds of consistency errors (for instance, ids are normally numbers, but now you have varchar. The DB cannot ensure consistency for you). Antipattern: when the data you're storing in the varchar is not needed to be used in the queries (gets displayed as-is). Legitimate Uses of the Antipattern: create an intersection table. Solution: Naive trees When you have multiple level parent -> child relationship and you represent it using an Adjacency list (you have a parent id in every row). It becomes impossible to get the whole tree in one query (because by default you can only get the next level). Antipattern: when you're certain that you will only have 1 level of queries. The alternatives are harder to implement. Legitimate Uses of the Antipattern: Solutions: Path Enumeration (storing the string of ancestors as an attribute of each node, just like the filesystem directories). Drawback: limitations of the Jaywalking antipattern. Nested Sets (add to each node nsleft and nsright: the nsleftnumber is less than the numbers of all the node’s children, whereas the nsright number is greater than the numbers of all the node’s children. These numbers have no relation to the id values). General tree reading becomes easy, but editing the tree becomes hard because all the nsleft and nsright need to be reprocessed. Closure Table: an extra table that holds all the relations between ancestors and descendants (including node indirect relationships and a reference to itself). The only drawback is the extra table size for big trees. But other operations are very easy to implement. "Joe Celko’s Trees and Hierarchies in SQL for Smarties" Reference: ID required Using a primary key that is not the appropriate primary key for this table (e.g., there is a natural primary key like social security number or there could be a compound key in there). If a table has a unique column then, most probably that could be the primary key. Antipattern: declare a primary key on a field that is easy to index and makes the most sense for that particular table Solution: Keyless entry when you don't use the constraints offered by the DB (especially foreign keys). Antipattern: never, unless your DB doesn't support it Legitimate Uses of the Antipattern: always declare constraints Solution: Mixing data with metadata For example, by appending the year onto the base table name, we’ve combined a data value with a metadata identifier. Antipattern: This is the reverse of mixing data with metadata from the Entity-Attribute-Value and Polymorphic Associations antipatterns. In those cases, we stored metadata identifiers (a column name and table name) as string data. In Multicolumn Attributes and Metadata Tribbles, we’re making a data value into a column name or a table name. If you use any of these antipatterns, you create more problems than you solve. Entity-value-attribute when you have a table with the columns: entity_id, attribute_name, attribute_value Antipattern: It appears when you have OOP inheritance and the children have various fields. If you use it, you lose referential integrity and data type validation. you shouldn't use this in a relational DB. Just use a non-relational DB or one of the solutions below. Legitimate Uses of the Antipattern: Solutions: Single table inheritance: one table with all the attributes of the children (it's going to be a sparse table Concrete table inheritance: completely independent tables for each subtype Class table inheritance (one table for the parent properties and tables with the child-specific properties) Semistructured data (one table with the parent properties and an extra blob field with the child-specific attributes). Disadvantages similar to the Entity-value-attribute. Polymorphic associations When you need to reference from a single table, or multiple parent tables (e.g., comments to features/bugs). You're using the pattern if you store in a column the name of your type of parent table. Antipattern: Solutions: Create intersection tables Create a common super table (with only ids) and reference that with your new table. The children will reference the super table (ex: comments references issues; bugs references issues, features references issues) Multicolumn attributes When an entity's attribute can have multiple values, you create multiple columns called attribute1, attribute2, etc. Antipattern: Solutions: Create a dependent table (a table that references the initial table by id and has the attribute as the other column) Store each value with the same meaning in a single column. Metadata tribbles When to support scalability and performance, you clone tables or new columns to support new partitions: ex: sales_2013, sales_2014, etc. (tables of the same schema with different entities). Basically, in your database, you will have a table per "some data value". Antipattern: when splitting the database sensibly makes database administration tasks easier after the database size passes a certain threshold. Legitimate Uses of the Antipattern: Solutions: Using Horizontal Partitioning: rows are separated into partitions. Mostly managed by the DB. Using Vertical Partitioning: splitting a table by columns. Databases usually do this for TEXT and BLOB. Physical Database Design Antipatterns Rounding errors (when you want to store floating point numbers in the DB) When you use float, double, or any other related DB type. The problem is how the number is represented internally by the DB. It will do all kinds of unpredictable roundings. Antipattern: scientific applications. Legitimate Uses of the Antipattern: use NUMERIC or decimal Solution: 31 flavors When you want to restrict a column to specific values (e.g., the status of a ticket), you define the allowed values in the table's schema or as a trigger. Antipattern: when you have very few values that will never change. But you might still get it wrong (e.g., gender). Legitimate Uses of the Antipattern: create a lookup table. Solution: Phantom files When you want to store Store Images or Other Bulky Media (when you reference them via the DB), and you use the FS directly, instead of the DB. These need to be specifically backed up, and the DB does not manage them. Antipattern: when the data files might affect how your DB behaves. Legitimate Uses of the Antipattern: Use BLOB Data Types As Needed Solution: Index shotgun When you want to Optimize the performance of the DB, and you throw indexes here and there without thinking too much about it (no indexes, too many indexes, queries that cannot benefit from indexes). Antipattern: none Legitimate Uses of the Antipattern: Solution: Measure the query times Get the query execution plan (QEP) Analyze the QEP and find where the index needs to be added
after creating the index, test Optimize: covering (compound) indexes could speed up things even more; use in mem vs. on disk indexes Rebuild: because indexes become fragmented as rows are deleted/created/updated Query Antipatterns Fear of the unknown thinking that null is just another value. Actually, SQL treats null as a special value, different from zero, false, or an empty string. As a general rule, all operations with null will return null. Or using a value to represent null. Antipattern: Treat null as a unique value. Declare Columns NOT NULL when it makes sense. Also, consider if using default makes sense. Solution: Ambiguous groups What you're already doing: Get Row with Greatest Value per Group. When you're using group by and are trying to get extra information from the row that you selected (like other columns that are not included in the group by expression), in other words, referencing Nongrouped Columns in the select list of the query. Antipattern: Every column in the select list of a query must have a single value row per row group. This is called the Single-Value Rule. Columns named in the GROUP BY clause are guaranteed to be exactly one value per group, no matter how many rows the group matches. none because most DBs will throw an error Legitimate Uses of the Antipattern: Solutions: Don't add an extra column to the select list Using a Correlated Subquery (own note: seems pretty hard to implement) Using a Derived Table: use the group query as a subquery of a query that selects the columns that you need. But merging their results with left join https://stackoverflow.com/questions/7745609/sql-select-only-rows-with-max-value-on-a-column Using an Aggregate Function for Extra Columns -> apply a function to the extra column in the select list so that you ensure that there's only one value coming back (e.g., max or GROUP_CONCAT) Random selection When you must fetch a random sample from one of your tables, you sort data randomly -> ORDER BY RAND(). This operation does a full table scan. Antipattern: only when you know for sure that the size of the data that you're randomizing will not be bigger than 50-100 rows. Legitimate Uses of the Antipattern: Solutions: Pick a Random primary Key Value Between 1 and MAX; only when primary keys are contiguous Choose Next Higher Key Value: just like before, except you'll be picking the next available key (assumes that the keys are non-contiguous). The results will not be evenly distributed Get a List of All Key Values. Choose One at Random (do it in the application; does not scale well) Choose a Random Row Using an Offset: select random between 0 and total_rows and use it in an OFFSET command Search the docs of your DB of choice Spaghetti query When you want to achieve everything in only one SQL query (solving a complex problem in one step, Antipattern: You might create a cartesian product without wanting to do that It's going to be hard to maintain when you're going to use that query as a data source in a 3rd party app Legitimate Uses of the Antipattern: Solutions: Split your initial query into multiple smaller ones Use the union label (to combine smaller queries) Writing SQL Automatically—with SQL -> use concat to create a list of queries to run; you can also do this with a script in bash Readable passwords Store Password in Plain Text Antipattern: hash your passwords with salt directly in your application. Solution: SQL injection when writing dynamic SQL queries, you end up executing unverified input as code. Antipattern: Solutions: Parameterize Dynamic Values (use query parameters) Filter Input Do your best not to write standard SQL. Rely on your data access framework as much as possible Diplomatic immunity when you want to code fast, completely skip engineering best practices. Make SQL a Second-Class Citizen, not giving the DB the same importance that the code gets in terms of quality. Antipattern: Solution: Forget about self-documenting code. It's a myth. Use Entity-relationship diagrams, break them down into functionalities, and mention triggers and stored procedures Use source control Have tests that test the interaction with the DB Magic beans when designing an MVC application and you don't consider enough how to separate the app logic between the M, V, and C. (Own note: I'll probably need to re-read this chapter from the book) Antipattern: Active record is a design pattern that maps objects to DB tables. The Model Has an Active Record -> basically, build services that compose the models. Aim to make your model a domain model, not a database model. Solution: Rules of normalization Should be considered only in the context of your app. How much do you want to normalize/denormalize? It's a tradeoff. And it would be best if you benchmarked it. The objectives of normalization: To represent facts about the real world in a way that we can understand To reduce storing facts redundantly and to prevent anomalous or inconsistent data To support integrity constraints The forms First Normal Form: no repeating groups (no multicolumn attributes, no multiple values in one column) Second Normal Form: when you're repeating values on a column, instead of creating a dependent table Third Normal Form: single responsibility principle for tables (put the column in the table that it belongs to) Advanced 3rd form (Boyce-Codd Normal Form): table doesn’t contain any field (other than the primary key) that can determine the value of another field. Example: teacher, subject, student. The subject is always dependent on the teacher. Fourth Normal Form: BCNF without compound keys Sixth normal form: It’s typically used to support a history of changes to attributes (e.g., an audit log). See no evil discarding DB error messages or not looking at the raw SQLs that get run when debugging the application. Antipattern: Recover from Errors Gracefully -> log potential exceptions every time. Solution: Antipatterns that are not that current anymore? Implicit Columns when you want to reduce typing (like explicitly mentioning all columns in the select list), you use: Antipattern: For insert without specifying the columns, when you refactor you might break the insert or, even worse, the database A select with * will fetch and display all the data when you're writing queries to try things out Legitimate Uses of the Antipattern: Name Columns Explicitly Solution: Poor man’s search engine when you want to do a full-text search, you use pattern-matching predicates (e.g., LIKE, REGEXP). Antipattern: don't use SQL. Elasticsearch has made this one easy. If you have to use SQL (for simple cases, each vendor has a solution for this already) Solution: Pseudokey neat-freak when you want to have contiguous keys in a table (e.g., when you have deletions in the DB), you want to fill in the gaps. Antipattern: Instead of allocating a new primary key value using the automatic pseudo key mechanism, you might want to make any new row use the first unused primary key value Renumbering Existing Rows -> changing the existing keys so that they are contiguous. none. Legitimate Uses of the Antipattern: just let it be. You can see the primary key id as UUIDs. The fact that they are consecutive is just a coincidence of the implementation. Solution: Also published . here

An Overview of SQL Antipatterns

This is our final post in our three-part series demonstrating how to use the Salesforce Mobile SDK to build an Android app that works with the Salesforce platform. , we showed you how to connect to your org. showed you how to edit and add data to your org from your app. This post will show you how to synchronize data from your Salesforce org to your mobile device and handle scenarios such as network loss. Let’s get right into it! In our first post Our second post Working with Mobile Sync One of the hardest aspects of mobile development is dealing with data synchronization. How do you handle the situation when you need to add a new broker, but you’re offline? Or what if two agents are updating the same broker—how can you handle the merging of those two changes? With the Salesforce Mobile SDK, these real-world issues are handled for you by a system called . Mobile Sync has you map your phone’s local data to the data in Salesforce; it also requires you to define operations for fetching and pushing data—what it calls and . Mobile Sync syncDown syncUp Define the shape of data to be synced To get started with Mobile Sync, create a file in called : res/raw brokerstore.json {
 "soups": [
   {
     "soupName": "brokers",
     "indexes": [
       { "path": "Id", "type": "string"},
       { "path": "Name", "type": "string"},
       { "path": "Title__c", "type": "string"},
       { "path": "Phone__c", "type": "string"},
       { "path": "Mobile_Phone__c", "type": "string"},
       { "path": "Email__c", "type": "string"},
       { "path": "Picture__c", "type": "string"},
       { "path": "__local__", "type": "string"},
       { "path": "__locally_created__", "type": "string"},
       { "path": "__locally_updated__", "type": "string"},
       { "path": "__locally_deleted__", "type": "string"},
       { "path": "__sync_id__", "type": "integer"}
     ]
   }
 ]
} This file defines the shape of the data on your phone, as well as some additional metadata that’s necessary for the sync. Next, create a file called : brokersync.json {
 "syncs": [
   {
     "syncName": "syncDownBrokers",
     "syncType": "syncDown",
     "soupName": "brokers",
     "target": {"type":"soql", "query":"SELECT Name, Title__c, Phone__c, Mobile_Phone__c, Email__c, Picture__c FROM Broker__c LIMIT 10000"},
     "options": {"mergeMode":"OVERWRITE"}
   },
   {
     "syncName": "syncUpBrokers",
     "syncType": "syncUp",
     "soupName": "brokers",
     "target": {"createFieldlist":["Name", "Title__c", "Phone__c", "Mobile_Phone__c", "Email__c", "Picture__c"]},
     "options": {"fieldlist":["Id", "Name", "Title__c", "Phone__c", "Mobile_Phone__c", "Email__c", "Picture__c"], "mergeMode":"LEAVE_IF_CHANGED"}
   }
 ]
} These are the operations that Mobile Sync will use when syncing data down and up. The code to complete the Mobile Sync process depends on several factors, such as when you want to perform a synchronization, as well as hooking into the Android event cycle when a device loses (and regains) connectivity. The following code samples will show you a complete example of what needs to happen to get synchronization working, but they should be considered high-level concepts, and not necessarily production-ready enterprise-grade code. Set up periodic sync With that said, let’s take a look at how to implement synchronization. First, add this line to the end of our method in : onResume(client: RestClient) MainActivity.kt setupPeriodicSync(); Next, we’ll add a new variable and a new function to the class: MainActivity private val SYNC_CONTENT_AUTHORITY =
   "com.salesforce.samples.mobilesyncexplorer.sync.brokersyncadapter"

private fun setupPeriodicSync() {
   val account = MobileSyncSDKManager.getInstance().userAccountManager.currentAccount

   ContentResolver.setSyncAutomatically(account, SYNC_CONTENT_AUTHORITY, true)
   ContentResolver.addPeriodicSync(
       account, SYNC_CONTENT_AUTHORITY,
       Bundle.EMPTY, 10
   )
} Since we’re using in our function, let’s make sure to import it by adding this line alongside the other import statements near the top of : ContentResolver MainActivity.kt import.android.content.ContentResolver We have defined two methods that trigger synchronization. will run a sync every seconds. This is much too frequent for a production environment, but we’ll set it this way for demonstration purposes. setupPeriodicSync 10 Mapping sync operations to our data and UI We will show the next few code samples all at once, and discuss what they’re doing afterward. In , create a new file called and paste these lines into it: app/java/com.example.sfdc BrokerSyncAdapter.kt package com.example.sfdc

import android.accounts.Account
import android.content.AbstractThreadedSyncAdapter
import android.content.ContentProviderClient
import android.content.Context
import android.content.SyncResult
import android.os.Bundle
import com.salesforce.androidsdk.accounts.UserAccount
import com.salesforce.androidsdk.accounts.UserAccountManager
import com.salesforce.androidsdk.app.SalesforceSDKManager
import com.example.sfdc.BrokerListLoader

class BrokerSyncAdapter
   (
   context: Context?, autoInitialize: Boolean,
   allowParallelSyncs: Boolean
) :
   AbstractThreadedSyncAdapter(context, autoInitialize, allowParallelSyncs) {
   override fun onPerformSync(
       account: Account, extras: Bundle, authority: String,
       provider: ContentProviderClient, syncResult: SyncResult
   ) {
       val syncDownOnly = extras.getBoolean(SYNC_DOWN_ONLY, false)
       val sdkManager = SalesforceSDKManager.getInstance()
       val accManager = sdkManager.userAccountManager
       if (sdkManager.isLoggingOut || accManager.authenticatedUsers == null) {
           return
       }
       if (account != null) {
           val user = sdkManager.userAccountManager.buildUserAccount(account)
           val contactLoader = BrokerListLoader(context, user)
           if (syncDownOnly) {
               contactLoader.syncDown()
           } else {
               contactLoader.syncUp() // does a sync up followed by a sync down
           }
       }
   }

   companion object {
       // Key for extras bundle
       const val SYNC_DOWN_ONLY = "syncDownOnly"
   }
} Now, in that same folder, create with these lines: BrokerListLoader.kt package com.example.sfdc

import android.content.AsyncTaskLoader
import android.content.Context
import android.content.Intent
import android.util.Log
import com.salesforce.androidsdk.accounts.UserAccount
import com.salesforce.androidsdk.app.SalesforceSDKManager
import com.salesforce.androidsdk.mobilesync.app.MobileSyncSDKManager
import com.salesforce.androidsdk.mobilesync.manager.SyncManager
import com.salesforce.androidsdk.mobilesync.manager.SyncManager.MobileSyncException
import com.salesforce.androidsdk.mobilesync.manager.SyncManager.SyncUpdateCallback
import com.salesforce.androidsdk.mobilesync.util.SyncState
import com.salesforce.androidsdk.smartstore.store.QuerySpec
import com.salesforce.androidsdk.smartstore.store.SmartSqlHelper.SmartSqlException
import com.salesforce.androidsdk.smartstore.store.SmartStore
import org.json.JSONArray
import org.json.JSONException
import java.util.ArrayList

class BrokerListLoader(context: Context?, account: UserAccount?) :
   AsyncTaskLoader<List<String>?>(context) {
   private val smartStore: SmartStore
   private val syncMgr: SyncManager
   override fun loadInBackground(): List<String>? {
       if (!smartStore.hasSoup(BROKER_SOUP)) {
           return null
       }
       val querySpec = QuerySpec.buildAllQuerySpec(
           BROKER_SOUP,
           "Name", QuerySpec.Order.ascending, LIMIT
       )
       val results: JSONArray
       val brokers: MutableList<String> = ArrayList<String>()
       try {
           results = smartStore.query(querySpec, 0)
           for (i in 0 until results.length()) {
               brokers.add(results.getJSONObject(i).getString("Name"))
           }
       } catch (e: JSONException) {
           Log.e(TAG, "JSONException occurred while parsing", e)
       } catch (e: SmartSqlException) {
           Log.e(TAG, "SmartSqlException occurred while fetching data", e)
       }
       return brokers
   }

   @Synchronized
   fun syncUp() {
       try {
           syncMgr.reSync(
               SYNC_UP_NAME
           ) { sync ->
               if (SyncState.Status.DONE == sync.status) {
                   syncDown()
               }
           }
       } catch (e: JSONException) {
           Log.e(TAG, "JSONException occurred while parsing", e)
       } catch (e: MobileSyncException) {
           Log.e(TAG, "MobileSyncException occurred while attempting to sync up", e)
       }
   }

   /**
    * Pulls the latest records from the server.
    */
   @Synchronized
   fun syncDown() {
       try {
           syncMgr.reSync(
               SYNC_DOWN_NAME
           ) { sync ->
               if (SyncState.Status.DONE == sync.status) {
                   fireLoadCompleteIntent()
               }
           }
       } catch (e: JSONException) {
           Log.e(TAG, "JSONException occurred while parsing", e)
       } catch (e: MobileSyncException) {
           Log.e(TAG, "MobileSyncException occurred while attempting to sync down", e)
       }
   }

   private fun fireLoadCompleteIntent() {
       val intent = Intent(LOAD_COMPLETE_INTENT_ACTION)
       SalesforceSDKManager.getInstance().appContext.sendBroadcast(intent)
   }

   companion object {
       const val BROKER_SOUP = "brokers"
       const val LOAD_COMPLETE_INTENT_ACTION =
           "com.salesforce.samples.mobilesyncexplorer.loaders.LIST_LOAD_COMPLETE"
       private const val TAG = "BrokerListLoader"
       private const val SYNC_DOWN_NAME = "syncDownBrokers"
       private const val SYNC_UP_NAME = "syncUpBrokers"
       private const val LIMIT = 10000
   }

   init {
       val sdkManager = MobileSyncSDKManager.getInstance()
       smartStore = sdkManager.getSmartStore(account)
       syncMgr = SyncManager.getInstance(account)
       // Setup schema if needed
       sdkManager.setupUserStoreFromDefaultConfig()
       // Setup syncs if needed
       sdkManager.setupUserSyncsFromDefaultConfig()
   }
} What did we just do? Each file has a specific role, and while the objects and fields will certainly be different for your app, the functions and philosophies of these classes are the same: is responsible for mapping the sync operations you defined in with the Kotlin code that will actually perform the work. Notice that there are and methods that use the Mobile SDK’s to load the JSON files and communicate back and forth with Salesforce. BrokerListLoader brokersync.json syncUp syncDown SyncManager can perhaps best be thought of as the code that’s responsible for scheduling the synchronization. That is, it’s the entry point for , and can be called by UI elements (such as during a refresh button click) or Android system events (such as connectivity loss). BrokerSyncAdapter BrokerListLoader Lastly, we need to add one line to our file (in ). Our new sync functionality will need special Android permissions, which we ask the user to allow upon app installation at runtime. Add the following line with to the end of your manifest: AndroidManifest.xml app/manifests WRITE_SYNC_SETTINGS <uses-permission android:name="com.example.sfdc.C2D_MESSAGE" />
  <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
</manifest> Testing sync Our last step is to test that mobile sync works. With the emulator running, you should be logged in and see a list of brokers. This list should mirror the broker list that you see in your web browser on your local machine. In your web browser, edit one of the broker names, and save that change. Then, in your emulator, you can power off the phone or switch to another application and then switch back to your . You should see your list of broker names updated with the change you made in your browser: sfdc-mobile-app And that’s all! Again, this is just a foundational building block for you to learn from. In just about 150 lines of code, we’ve devised a solution for a rather complicated series of moving parts: Mapping Salesforce custom objects to JSON Setting up a timer to periodically sync data back and forth between a Salesforce org and a mobile device Handling errors (and recovering from issues) around network connectivity Conclusion The Salesforce Mobile SDK makes it tremendously easy to connect mobile devices with Salesforce data. In this post, you learned how to query and manipulate data from your phone, and saw the results reflected instantaneously on Salesforce. You also learned about Mobile Sync and its role in anticipating issues with connectivity. And yet, with all of this information, there’s still that the Salesforce Mobile SDK can do. Take a look at the on working with the SDK. Or, if you prefer to do more coding, there are to keep you busy. We can’t wait to see what you build! so much more complete documentation plenty of Trailhead tutorials

Stories, News & Mentions about SMARTMILE

Smartmile’s Stories on HackerNoon