A fully decentralized ecosystem to help users optimize \u0026 retain their crypto by using a suite of intuitive DeFi product offerings such as TeraBlock Co-op farms, our novel NFT marketplace and Trade Automation

TeraBlock

One of the most amazing things about the crypto market is that it stays live 24x7, 365 days a year. For traders, it's a blessing. There's no time restriction to when they can or cannot trade. Of course, no trader, beginner or expert, can track the markets all the time, which means leaving out opportunities. That's something Shivam Tandon, the founder of , faced when he started trading cryptocurrencies in 2016. So, he created algorithms to automate his trades. TeraBlock Those initial efforts led him to establish TeraBlock — a machine learning-enabled trade automation and asset management platform. Let's see what Shivam Tandon has to offer to the crypto space and what's his take on the different aspects of cryptos and trading. Q1: Welcome to Unhashed. What was the first thing about crypto that caught your attention and what things finally led you to build TeraBlock? Answer: I was a serial entrepreneur and an experienced trader, so I started mining and trading cryptocurrencies towards the end of 2016. I was attracted to the nascent technology behind crypto and the ability to trade around the clock, thus I created fully automated algorithms to assist me with my trading. This initial spark started my journey towards building TeraBlock. For those who don’t know, Terablock is a solution for people looking to enter the cryptocurrency ecosystem and easily manage their portfolio with the help of machine learning (ML) trade automation. In other words, we provide a user-friendly interface like Coinbase with the ability to manage and trade with high-end technology. Q2. With the growing demand for crypto investments, there are numerous crypto-focused asset management platforms being launched. What differentiates TeraBlock from its competitors? Answer:  When surveying the market, we found that while there are many crypto-focused platforms to trade on, there aren't many who provided tools to help new users manage their assets, automate their trading, and also become more comfortable navigating the crypto ecosystem. We are also not a fund that will simply hold your assets leaving them to the mercy of the market, but we give the power back to the users to be better wealth managers themselves. We have two primary products—an automated index trader and an automated portfolio trader. Depending on our users’ level of comfort in trading, they can either select a predefined index based on parameters they desire or select their own assets in a simple-to-use, drag-and-drop interface. Once completed, TeraBlock’s proprietary ML trading algorithms will begin automated trading. Q3: Being a centralized project in the blockchain space is considered to be a contradiction. Amidst this, how does TeraBlock place itself in the crypto market? How do you plan to demystify centralization in the crypto community and ensure that users can still trust the platform from a security perspective like they would any decentralized platform? Answer: That is a great question! There is a clear growing distrust of centralization and this especially holds true in the crypto ecosystem. Despite the many issues with centralization, currently, it is still the key to a low-risk entry to the crypto ecosystem. The decentralized space is littered with bad actors scamming people of their money. Plus, the complexity of DeFi is beyond many people's comprehension, which hinders the growht of the DeFi and crypto space as a whole. In addition, we need better security in all regards. TeraBlock, or other centralized projects, despite their centralization act as key to the adoption of cryptocurrencies and DeFi protocols. For most people who like easy, one-click options to invest in assets - like they do for stocks, mutual funds, and the likes - whether the crypto-experienced people like centralization or not is never a concern. Newbies look for ease and that's what centralization offers. Of course, decentralization lies at the core of the blockchain and crypto space, and we will eventually reach there. But if tell people to go right from centralization to decentralization in one step, I don't think anyone would be able to comfortably do that. This is why, centralization is key to crypto adoption. Once most people know what crypto is and its potential, we can then take them to the next phase and then the next and eventually reach where complete decentralization may be possible. In regards to trust, Binance is one of the most trusted central entities in the crypto space. And we are partnering with Binance Cloud to bring the highest level of reliability, especially in terms of liquidity as well as utilizing their security and technology. We want to position ourselves to introduce as many people as we can to this growing industry so we can one day realize the dream of decentralization. We also aim to add DeFi products to our platform so people from all walks of life, not necessarily from the crypto space, can experience first-hand what crypto and DeFi is all about. And after seeing the benefits of the technology, maybe, they will be more motivated to try out the actual decentralized version of this industry. Q4: We know that both machine learning and automation are memory-intensive disciplines. How does TeraBlock integrate them with the volatility and diversity of the cryptomarkets? Please delve into this blend, keeping sustainability in mind. Answer: This is a complicated topic when it comes to the environmental impact of memory-intensive disciplines. While we currently do not have the specific data for our trading algorithms in regards to ESG matters, we have built them to be the most efficient, especially when it comes to the volatility of the cryptomarkets. While many automated trading tools revolve around something called high-frequency trading, we have built our ML models to only trade when there is a significant change in market conditions. Q5: The fear and greed index is largely used to measure the sentiment of the crypto market. Can you shed light on how the adoption of AI and its disciplines that are devoid of emotions can revolutionize this market? Answer: As an experienced trader, I know how difficult it is to master the psychology of trading, especially when it comes to fear and greed. That is why trading with the assistance of ML trading algorithms has greatly benefited me and I want to bring this benefit to others. Trading automation tools and management services can help many inexperienced traders keep their emotions at bay and manage their assets better against market volatility. This aspect of risk management is usually the hardest thing to master when it comes to trading. We believe such tools (as seen on TeraBlock) will empower people to manage their own wealth, without having to master the technical, fundamental, and emotional side of trading. While this may still be far from actualization, I am curious how the market will evolve if humans no longer trade and it became totally dependent on the choices made by purely ML and AI-powered tools! Q6: The crypto market is dynamic with constant innovation. Where do you see the automated trading experience headed towards? Answer: These days, everything is becoming automated! I believe we are still in an early phase of trading automation, and trade automation platforms in the crypto space are well-positioned for the coming years. Tools that help every trade leverage the opportunities in the crypto market will eventually become commonplace. The rapidly spreading adoption of crypto and the demand from more people to invest in digital assets is just the beginning of it. As it is today with stocks and other traditional assets, crypto too is en route to becoming a high-potential asset with great possibilities over the long-term. And there will certainly be a huge demand for automation tools that can help interested traders reap the benefits of the market without the need to dedicate multiple hours every day to it. Disclaimer: The sole purpose of Unhashed is to unhash (decode) information about projects innovating using blockchain and cryptocurrencies and share it with the community. The writer does not have any vested interest in any of the projects covered herein. Not that this article shares any, but still, taking investment advice from strangers on the internet is not a wise thing to do.

Despite Risks with Centralization, It is Key to Crypto's Growth - Unhashed #10

Google’s MLKit library finds text in images and this works well for simple text but for tabular data such as receipts or tables, it does not. If you’ve ever used an you might have noticed that it works reasonably well when scanning a page with uniform text but when dealing with any kind of tables or text formatting, it just falls flat. OCR app This article discusses an algorithm used in a mobile application I wrote that processes text to keep it in line. We’ll take a common example of a store receipt. In the example below you can see exactly the problem that I’m trying to solve. Lens does not prefer lines for text but will rather put together text that is physically closer together. This works sometimes but definitely does not work for receipts and other tabular data. See specifically how Google Lens put the price as a new line because it was physically far away from the lines on the left. Google 1,49€ is an application developed specifically to scan tabular data and the results of scanning a receipt are in the top right corner.  You can see how it respected the horizontal layout of the receipt and put the price together with the correct article. Line Text Scanner Google OCR library Here is a quick overview of how to use the OCR library: load an image and get text. Recognition of characters happens entirely on Google’s side. InputImage image = InputImage.fromBitmap(mSelectedImage, 0);
        TextRecognizer recognizer = TextRecognition.getClient();
        
        recognizer.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<Text>() {
                            @Override
                            public void onSuccess(Text texts) {
                                processTextRecognitionResult(texts);
                            }
                        })
                .addOnFailureListener(
                       // 
                        }); Full documentation is here and the diagram below is from this link. https://developers.google.com/ml-kit/vision/text-recognition/v2?embedable=true Once we have the Text object we can begin our own logic. We’ll try to process Text to do better than Google Lens. First, we need to look at the Text object. Text is a hierarchical representation of the scanned text as seen in the following diagram from Google’s documentation. The algorithm looks for characters and words in physical space and puts them into a hierarchical structure. As mentioned, this works well for easy text as in the diagram above but for tabular data like a receipt it does not. Below we have the full text of the receipt scanned by Google Lens. ENTRETIEN/BAZAR......
MPX FILM FRAICH30M
EPICERIE/BOISSONS.......
1,49€
265G POIS CHICHES HARICOTS ROUGES TR
0,95€
PECHE FRAICH FRTS
COOKIES SABLES CHO
1,25€
3,69€
2,39€
HYGIENE/BEAUTE.......
2,99€
20 ELAST COURTS WA
2 X BATISTE SHP SEC 6,59€ 13,18€
2è à -60%
-3,95€
MPX FIL DENTAIR 50 SOIN BLANCHEUR GOU
2,09€
7,29€
SURGELES/PRODUITS FRAIS...........
LAITIERE PV VANILL
1,69€
MALO F.FRAIS FRUIT COMTE AOP 6M 450G
2,35€
5,29€
QUICHE LORRAINE ESCAL.PANEES DE BL
2,79€
OEUFS PLEIN AIRX12
2,85€
MORIN MOUSSE CHOCO
3,25€
2,09€
LONGLEY FARM COT.C
1,99€
TOTAL HORS AVANTAGES
57,62€
18
NOMBRE D'ARTICLES I think that you’ll agree that this is not very useful. The algorithm picked the columns first rather than the rows. It made new lines for text that was far away. This is the difference in text processing that this article explores. Processing Text To demonstrate what MLKit does I’ve modified the application to only output the index of Text Elements (those are boxes with dark green border in the diagram from Google). In the screen below we can see text blocks 0 to 31. We can see how the MLKit library prefers physical distance to group words together into phrases. This is not exactly what Google Lens has outputted. We can see that Google Lens made the price of 1,49€ below the first three lines. It treated the text blocks differently but didn’t manage to output clear lines. As seen from this output, the OCR library makes up block 0 as ‘Entrentien/Bazar. MPX FILM FRAICH30M’. The second block is made up of multiple lines of the left column. The library continues to create text blocks from the left column and then moves to the right column to create the text blocks from prices. The image is correctly converted into characters and words. We’ll use these words but do it using a different algorithm to prefer lines to make our sentences. It’s clear that Google Lens also processes these blocks but obviously in yet another way. Breaking boxes Now to our algorithm. The first thing we’ll do is process all the TextBlocks from Text to extract the individual lines. Each line has one or more object and we extract them all and put them into a single  list. Text.Element List<Text.Element> textElements = new ArrayList<>();

        for (int i = 0; i < blocks.size(); i++) {
            Rect rect = blocks.get(i).getBoundingBox();
  
            List<Text.Line> lines = blocks.get(i).getLines();
  
            for (int j = 0; j < lines.size(); j++) {
                List<Text.Element> elements = lines.get(j).getElements();
                for (int k = 0; k < elements.size(); k++) {
                    Text.Element e = elements.get(k);
                    textElements.add(e);
                 }
            } At this point, we have an array of objects which all contain some text. In our example, the four in block 0 are 'ENTRETIEN/BAZAR......’, ‘MPX’, ‘FILM’, and ‘FRAICH30M’. All of the elements are put into a list. Text.Element Text.Elements Sorting boxes So now that we have all these objects in a list, how do we determine what goes after what? As seen from above, the OCR algorithm just recognized blocks of text but it made no effort to make correct sentences. First, we need to realize that object is bound by Rect object which has coordinates and dimensions. We use this fact to sort the . Text.Element Text.Element Text.Elements We take the top and left coordinates of the rectangles and sort them: public int compare(Text.Element t1, Text.Element t2) {
            int diffOfTops = t1.getBoundingBox().top - t2.getBoundingBox().top;
            int diffOfLefts = t1.getBoundingBox().left - t2.getBoundingBox().left;

            int height = (t1.getBoundingBox().height() + t2.getBoundingBox().height()) / 2;
            int verticalDiff = (int)(height * 0.35);

            int result = diffOfLefts;
            if (Math.abs(diffOfTops) > verticalDiff) {
                result =  diffOfTops;
            }
            return result;
        } The main decision in this algorithm is to decide whether one rectangle should go after another based on whether it is more to the right of it or more below it. The horizontal difference is easy, if one rectangle has coordinates more to the left of another rectangle then it will come before it. But this will be taken into consideration only if the difference in the tops is more than 35% height of the line. Basically, we allow for some skew in the picture-taking where the text might not align perfectly. But if a rectangle is 35% the height of the current rectangle below the next rectangle then we consider it as another line. Overall, in our algorithm, we prefer horizontal lines along which we can find the objects. Text.Element Making lines In this final processing step, we will make lines by processing the list above. Remember that the list just has rectangles and so we need to add a condition based on coordinates to decide whether to start a new line. To do this, we get the difference between the top of the boxes and take the average of their height. We don’t check the difference in location on the horizontal axis as we already did that when sorting boxes. Here we just have one decision to make: whether or not to make a new line. private boolean isSameLine(Text.Element t1, Text.Element t2) {
        int diffOfTops = t1.getBoundingBox().top - t2.getBoundingBox().top;
    
        int height = (t1.getBoundingBox().height() + t2.getBoundingBox().height()) * 0.35;

        if (Math.abs(diffOfTops) > height ) {
            return false;
        }
        return true;
    } This finally gives us the well-formatted tabular text. Here is the full text again. ENTRETIEN/BAZAR.  
MPX FILM FRAICH3OM 1,49€  
EPICERIE/BO1SSONS.  
265G POIS CHICHES 0,95€  
HARICOTS ROUGES TR 1,25e  
PECHE FRAICH FRTS 3,69e  
COOKIES SABLES CHO 2,39e  
HYGIENE/BEAUTE.....  
20 ELAST COURTS WA 2,99€  
2 X BATISTE SHP SEC 6,59€ 13,18€  
2è à -60% -3,95€  
MPX FIL DENTAIR 50 2,09e  
SOIN BLANCHEUR GOU 7,29€  
SURGELES/PRODUITS FRAIS....  
LAITIERE PV VANILL 1,69€  
MALO F.FRAIS FRUIT 2,35€  
COMTE AOP 6M 450G 5,29€  
QUICHE LORRAINE 2,79€  
ESCAL.PANEES DE BL 2,85e 
OEUFS PLEIN AIRX12 3,25€  
MORIN MOUSSE CHOCO 2,09e  
LONGLEY FARM COT.C 1,99e  
TOTAL HORS AVANTAGES 57,62e 
NOMBRE D'ARTICLES 18 Conclusion The solution to process the text in lines in this article is not without faults. The text should be relatively straight and not skewed too much. With some effort, we could calculate the vectors of lines even in the most crumpled receipt but that would be for another article. Here we show how a small tweak in treating the output of a large library can have a big effect for a very specific purpose. If you think that this is useful to you, the app is available in the . Google Play Store

Using Google MLKit Text Recognition to Scan Tabular Data

Fetching token balances for one or more addresses (at a specific point in time) is a super common task, regardless of what it is that you’re building. Despite being such a common task, when I first started working with data I found it surprisingly difficult to figure out how to do this. It isn’t exactly obvious from just scrolling through the list of available endpoints Ethereum JSON-RPC Once you do figure it out, the other issue (even less obvious) is figuring out how to do this for multiple addresses across different time periods in a reasonable amount of time that won’t burn through all your credits. API In this article, I am going to save you the pain I had to go through figuring out the best way to fetch token balances. I’ll go over the different methods available (and their issues), starting with the “naive approach” and ending with the best approach. Overview: The naive approach Batching JSON-RPC requests Using a multicall contract Final remarks (link to code) The naive approach The naive approach is to make a single HTTP request using the “eth_call” JSON-RPC endpoint. Here’s the code: def fetch_token_balance_naive(wallet_address, token_address, block_number, node_provider_url, api_key):
    balanceof_function = "balanceOf(address)(uint256)"
    balanceof_signature = Signature(balanceof_function)
    block_number_hex = Web3.toHex(primitive=block_number)
    data = balanceof_signature.encode_data([wallet_address]).hex()
    payload = {
        "jsonrpc": "2.0",
        "method": "eth_call",
        "params": [
            {
                "to": token_address,
                "data": "0x" + data,
            },
            block_number_hex,
        ],
        "id": 1,
    }
    headers = {"Content-Type": "application/json", "Accept-Encoding": "gzip"}
    url = f"{node_provider_url}/{api_key}"
    res = requests.post(url, headers=headers, json=payload)
    res_data = res.json()
    balance_encoded_hex = res_data["result"]
    balance_encoded_bytes = Web3.toBytes(hexstr=balance_encoded_hex)
    balance_decoded = Call.decode_output(balance_encoded_bytes, balanceof_signature, returns=None)
    return balance_decoded There are a few things that are not so obvious if this is your first time using “eth_call” so let’s quickly go over these things. “eth_call” is the JSON-RPC endpoint used to call smart contract functions. “balanceOf” is a function that all ERC20 tokens have. You can call this function to return how much an address holds of the token in question. To use “eth_call” you need to specify two parameters: “to” and “data”. The “to” parameter is the address of the smart contract you want to call a function from. In the “data” parameter you specify the function you want to call and its inputs. Not super user-friendly: But to “data” requires you to encode the function name and inputs into a hexadecimal string. Similarly, the output of our call has to be decoded. To make life easier, I use the Call and Signature classes of the multicall package (see ) to help me with encoding and decoding. https://github.com/banteg/multicall.py The problem with the naive approach is that it’s (in terms of API credits). If you need to fetch balances for multiple addresses, blocks, and/or tokens. For each block, address, and token you need to perform a separate request. super slow and expensive Batching requests Batching requests alleviates some of the problems of the naive approach if you need to fetch balances for multiple blocks, addresses, and/or tokens. In particular, it helps . Instead of making multiple separate requests — batching enables you to do it in a single request. The code for batching “eth_call” requests is as follows: speed things up significantly def fetch_token_balance_batch(wallet_addresses, token_addresses, block_numbers, node_provider_url, api_key):
    balanceof_function = "balanceOf(address)(uint256)"
    balanceof_signature = Signature(balanceof_function)
    payload_list = []
    for i, (wallet_address, token_address, block_number) in enumerate(
        zip(
            wallet_addresses,
            token_addresses,
            block_numbers,
        )
    ):
        block_number_hex = Web3.toHex(primitive=block_number)
        data = balanceof_signature.encode_data([wallet_address]).hex()
        payload = {
            "jsonrpc": "2.0",
            "method": "eth_call",
            "params": [
                {
                    "to": token_address,
                    "data": "0x" + data,
                },
                block_number_hex,
            ],
            "id": i + 1,
        }
        payload_list.append(payload)
    headers = {"Content-Type": "application/json", "Accept-Encoding": "gzip"}
    url = f"{node_provider_url}/{api_key}"
    res = requests.post(url, headers=headers, json=payload_list)
    res_data_list = res.json()
    balances = []
    for res_data in res_data_list:
        balance_encoded_hex = res_data["result"]
        balance_encoded_bytes = Web3.toBytes(hexstr=balance_encoded_hex)
        balance_decoded = Call.decode_output(balance_encoded_bytes, balanceof_signature, returns=None)
        balances.append(balance_decoded)
    return balances Some things to keep in mind: You can’t batch an unlimited number of requests. You’re allowed by your plan. (This depends on the node provider you use.) limited by the maximum response size, and maximum number of requests per second Despite being much faster than the naive approach, the problem with batching is that you will still end up using the same amount of API credits. Depending on your use-case this can be . cost prohibitive Using a multicall contract Multicall contracts are smart contracts that allow multiple function calls to be bundled together and executed as a single function call. Similar to batching requests, using a multicall significantly speeds up bulk fetching balances. Instead of being charged for each separate “eth_call” request, you’ll only be charged for a single request. The other benefit: It’s a lot more cost efficient. The code that uses the multicall contract is a bit long. To make it more readable I have broken the code up into two functions: the main function and the inner function . fetch_token_balance_multicall create_multicall_payload_list def fetch_token_balance_multicall(wallet_addresses, token_addresses, block_numbers, node_provider_url, api_key):
    block_map = defaultdict(lambda: [])
    for block_number, token_address, wallet_address in zip(block_numbers, token_addresses, wallet_addresses):
        block_map[block_number].append((token_address, wallet_address))
    aggregate_function = "tryBlockAndAggregate(bool,(address,bytes)[])(uint256,uint256,(bool,bytes)[])"
    aggregate_signature = Signature(aggregate_function)
    balanceof_function = "balanceOf(address)(uint256)"
    balanceof_signature = Signature(balanceof_function)
    payload_list = create_multicall_payload_list(block_map, aggregate_signature, balanceof_signature)
    headers = {"Content-Type": "application/json", "Accept-Encoding": "gzip"}
    url = f"{node_provider_url}/{api_key}"
    res = requests.post(url, headers=headers, json=payload_list)
    res_data_list = res.json()
    balances = []
    for res_data in res_data_list:
        output_hex = res_data["result"]
        output_bytes = Web3.toBytes(hexstr=output_hex)
        returns = None
        decoded_output = Call.decode_output(
            output_bytes,
            aggregate_signature,
            returns,
        )
        output_pairs = decoded_output[2]
        for flag, balance_encoded in output_pairs:
            balance_decoded = Call.decode_output(balance_encoded, balanceof_signature, returns)
            balances.append(balance_decoded)
    return balances The logic is very similar to what we have already seen in the previous sections. All the interesting logic is contained in . That being said, there is still one thing worth mentioning: fetch_token_balance_multicall create_multicall_payload_list combines both request batching and the use of a multicall contract. The request batching was implemented to enable us to fetch historical balances across multiple blocks in a single call. fetch_token_balance_multicall Now the interesting code: def create_multicall_payload_list(block_map, balanceof_signature, aggregate_signature):
    multicall3_address = "0xcA11bde05977b3631167028862bE2a173976CA11"
    state_override_code = load_state_override_code()
    require_success = False
    gas_limit = 50000000
    payload_list = []
    for i, block_number in enumerate(block_map.keys()):
        block_number_hex = Web3.toHex(primitive=block_number)
        call_params_list = []
        for token_address, wallet_address in block_map[block_number]:
            call_params_list.append(
                {
                    "to": token_address,
                    "data": balanceof_signature.encode_data([wallet_address]),
                },
            )
        multicall_params = [
            {
                "to": multicall3_address,
                "data": Web3.toHex(
                    aggregate_signature.encode_data(
                        [
                            require_success,
                            [[c["to"], c["data"]] for c in call_params_list],
                        ]
                    )
                ),
            },
            block_number_hex,
        ]
        if gas_limit:
            multicall_params[0]["gas"] = Web3.toHex(primitive=gas_limit)
        if state_override_code:
            multicall_params.append({multicall3_address: {"code": state_override_code}})
        payload = {
            "jsonrpc": "2.0",
            "method": "eth_call",
            "params": multicall_params,
            "id": i + 1,
        }
        payload_list.append(payload) The function creates the payload_list for a batch JSON-RPC request. For each block we create a separate payload and append it to the list. create_multicall_payload_list Each payload is an “eth_call” request. The call we are making is to the function, which requires us provide it with the list of calls we want to aggregate into a single call. tryBlockAndAggregate(bool, (address,bytes)[])(uint256, uint256,(bool,bytes)[]) Things to note: If the number of balances you’re fetching is large you should set a high value for “gas_limit”. The value of 50000000 will almost always work. “state_override_code” is a long hexadecimal string that needs to be provided in order for us to be able to fetch historical balances. The multicall contract I am using can be found . But, it’s also possible to use other multicall contracts. here Final remarks All code and test cases can be found on my Github here: . https://github.com/martkir/get-erc20-balance If you have any questions or want to give feedback on anything I have written you can let me know on Twitter @martkiro If you’re working with onchain data you might also be interested in checking out where we are indexing the Ethereum blockchain :) https://www.syve.ai

The Best Method for Bulk Fetching ERC20 Token Balances

Java developers have often envied JavaScript for its ease of parsing JSON. Although Java offers more robustness, it tends to involve more work and boilerplate code. Thanks to the Manifold project, Java now has the potential to outshine JavaScript in parsing and processing JSON files. Manifold is a revolutionary set of language extensions for Java that completely changes the way we handle JSON (and much more…). https://www.youtube.com/watch?v=AoBnGZ7q6rk&embedable=true Getting Started With Manifold The code for this tutorial can be found on my . Manifold is relatively young but already vast in its capabilities. You can learn more about the project on their website and Slack channel. GitHub page To begin, you'll need to install the Manifold plugin, which is currently only available for JetBrains IDEs. The project supports LTS releases of Java, including the latest JDK 19. We can install the plugin from IntelliJ/IDEAs settings UI by navigating to the marketplace and searching for Manifold. The plugin makes sure the IDE doesn’t collide with the work done by the Maven/Gradle plugin. Manifold consists of multiple smaller projects, each offering a custom language extension. Today, we'll discuss one such extension, but there's much more to explore. Setting Up a Maven Project To demonstrate Manifold, we'll use a simple Maven project (it also works with Gradle). We first need to paste the current Manifold version from their website and add the necessary dependencies. The main dependency for JSON is the dependency. manifold-json-rt Other dependencies can be added for YAML, XML, and CSV support. We need to add this to the file in the project. pom.xml I'm aware of the irony where the boilerplate reduction for JSON starts with a great deal of configuration in the Maven build script. But this is configuration, not "actual code"; it's mostly copy & paste. Notice that if you want to reduce this code, the Gradle equivalent code is terse by comparison. This line needs to go into the properties section: <manifold.version>2023.1.5</manifold.version> The dependencies we use are these: <dependencies>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-json-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency> The compilation plugin is the boilerplate that weaves Manifold into the bytecode and makes it seamless for us. It’s the last part of the pom setup: <build>
   <plugins>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.0</version>
           <configuration>
               <source>19</source>
               <target>19</target>
               <encoding>UTF-8</encoding>
               <compilerArgs>
                   
                   <arg>-Xplugin:Manifold</arg>
               </compilerArgs>

               
               <annotationProcessorPaths>
                   <path>
                       <groupId>systems.manifold</groupId>
                       <artifactId>manifold-json</artifactId>
                       <version>${manifold.version}</version>
                   </path>
               </annotationProcessorPaths>
           </configuration>
       </plugin>
   </plugins>
</build> With the setup complete, let's dive into the code. Parsing JSON With Manifold We place a sample JSON file in the project directory under the resources hierarchy. I placed this file under : src/main/resources/com/debugagent/json/Test.json {
  "firstName": "Shai",
  "surname": "Almog",
  "website": "https://debugagent.com/",
  "active": true,
  "details":[
    {"key": "value"}
  ]
} In the main class, we refresh the Maven project, and you'll notice a new Test class appears. This class is dynamically created by Manifold based on the JSON file. If you change the JSON and refresh Maven, everything updates seamlessly. It’s important to understand that Manifold isn’t a code generator. It compiles the JSON we just wrote into bytecode. The Test class comes with several built-in capabilities, such as a type-safe builder API that lets you construct JSON objects using builder methods. You can also generate nested objects and convert the JSON to a string by using the and methods. write() toJson() It means we can now write: Test test = Test.builder().withFirstName("Someone")
        .withSurname("Surname")
        .withActive(true)
        .withDetails(List.of(
                Test.details.detailsItem.builder().
                        withKey("Value 1").build()
        ))
        .build(); Which will printout the following JSON: {
  "firstName": "Someone",
  "surname": "Surname",
  "active": true,
  "details": [
    {
      "key": "Value 1"
    }
  ]
} We can similarly read a JSON file using code such as this: Test readObject = Test.load().fromJson("""
        {
          "firstName": "Someone",
          "surname": "Surname",
          "active": true,
          "details": [
            {
              "key": "Value 1"
            }
          ]
        }
        """); Note the use of Java 15 syntax for writing a long string. The method returns an object that includes various APIs for reading the JSON. In this case, it is read from a but there are APIs for reading it from a URL, file, etc. TextBlock load() String Manifold supports various formats, including CSV, XML, and YAML, allowing you to generate and parse any of these formats without writing any boilerplate code or sacrificing type safety. In order to add that support, we will need to add additional dependencies to the pom.xml file: <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-csv-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-xml-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-yaml-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
</dependencies> With these additional dependencies, this code will print out the same data as the JSON file... With the output would be: test.write().toCsv() "firstName","surname","active","details"
"Someone","Surname","true","[manifold.json.rt.api.DataBindings@71070b9c]" Notice that the Comma Separated Values (CSV) output doesn’t include hierarchy information. That’s a limitation of the CSV format and not the fault of Manifold. With the output is familiar and surprisingly concise: test.write().toXml() <root_object firstName="Someone" surname="Surname" active="true">
  <details key="Value 1"/>
</root_object> With we again get a familiar printout: test.write().toYaml() firstName: Someone
surname: Surname
active: true
details:
- key: Value 1 Working With JSON Schema Manifold also works seamlessly with JSON schema, allowing you to enforce strict rules and constraints. This is particularly useful when working with dates and enums. Manifold seamlessly creates/updates byte code that adheres to the schema, making it much easier to work with complex JSON data. This schema is copied and pasted from the : Manifold GitHub project {
  "$schema": "http://json-schema.org/draft-07/schema#",
  "$id": "http://example.com/schemas/User.json",
  "type": "object",
  "definitions": {
    "Gender": {
      "type": "string",
      "enum": ["male", "female"]
    }
  },
  "properties": {
    "name": {
      "type": "string",
      "description": "User's full name.",
      "maxLength": 80
    },
    "email": {
      "description": "User's email.",
      "type": "string",
      "format": "email"
    },
    "date_of_birth": {
      "type": "string",
      "description": "Date of uses birth in the one and only date standard: ISO 8601.",
      "format": "date"
    },
    "gender": {
      "$ref" : "#/definitions/Gender"
    }
  },
  "required": ["name", "email"]
} It’s a relatively simple schema, but I’d like to turn your attention to several things here. It defines name and email as required. This is why when we try to create a object using a builder in Manifold, the method requires both parameters: User build() User.builder("Name", "email@domain.com") That is just the start... The schema includes a date. Dates are a painful prospect in JSON, the standardization is poor and fraught with issues. The schema also includes a gender field which is effectively an enum. This is all converted to type-safe semantics using common Java classes such as LocalDate: User u = User.builder("Name", "email@domain.com")
       .withDate_of_birth(LocalDate.of(1999, 10, 11))
       .withGender(User.Gender.male)
       .build(); That can be made even shorter with static imports, but the gist of the idea is clear. JSON is effectively native to Java in Manifold. The Tip of The Iceberg Manifold is a powerful and exciting project. It revolutionizes JSON parsing in Java, but that’s just one tiny portion of what it can do! We've only scratched the surface of its capabilities in this post. In the next article, we'll dive deeper into Manifold and explore some additional unexpected features. Please share your experience and thoughts about Manifold in the comments section. If you have any questions, don't hesitate to ask.

How Manifold Revolutionizes JSON Parsing in Java

জাভাতে JSON পার্সিংকে কীভাবে ম্যানিফোল্ড বিপ্লব করে

Wie Manifold das JSON-Parsing in Java revolutioniert

Cómo Manifold revoluciona el análisis de JSON en Java

Comment Manifold révolutionne l'analyse JSON en Java

कैसे कई गुना जावा में JSON पार्सिंग में क्रांति लाता है

Manifold が Java での JSON 解析に革命を起こす方法

Manifold가 Java에서 JSON 구문 분석을 혁신하는 방법

Como o Manifold revoluciona a análise JSON em Java

Manifold, Java'da JSON Ayrıştırmada Nasıl Devrim Yaratıyor?

Cách Manifold cách mạng hóa phân tích cú pháp JSON trong Java

Manifold 如何革新 Java 中的 JSON 解析

Step-by-Step Guide to Building Your First (Voice) Bot with Microsoft Power Virtual Agent

In a , I outlined the three main jobs of the in order to run a UWP app on iOS, Android, and in the browser: previous article Uno Platform Parse XAML files; Implement data-binding; Implement the suite of views in the for each platform. UWP framework In this article I want to focus on that last point. How does Uno implement UWP’s views? As a case study I’m going to use that humbly ubiquitous UI control, the button. The number goes up I present the simplest interactive application imaginable, one step above ‘Hello World’: XAML: <Page x:Class="UnoExtTestbed.MainPage"xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"xmlns:d="http://schemas.microsoft.com/expression/blend/2008"xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"mc:Ignorable="d"> <StackPanel>   
    <TextBlock x:Name="ClickTextBlock"   
               Text="Button wasn't clicked yet" />   
    <Button Content="Click me"   
            Click="Button\_Click" />   
</StackPanel> </Page> code-behind: using System;using Windows.UI.Xaml;using Windows.UI.Xaml.Controls; namespace UnoExtTestbed{public sealed partial class MainPage : Page{public MainPage(){this.InitializeComponent();} private int \_clickCount = 0;   
    private void Button\_Click(object sender, RoutedEventArgs e)   
    {   
        \_clickCount++;   
        ClickTextBlock.Text = $"Button was clicked {\_clickCount} times.";   
    }   
} } I made a blank app using the and put this code on the main page. Whenever the is clicked, the number goes up. Add a bit more chrome and we could have a . Uno Solution template Button viral hit Note that the XAML is useful here but not obligatory, either on UWP or Uno. We could have defined and created all our views in C#, had we really wanted to. That flexibility is handy to have. Exhibit A — the visual tree Visual tree information for UWP Visual tree information for Android Visual tree information for iOS Visual tree information for WASM So what does that get us? You can see the resulting visual trees on each target platform. They’re all substantially similar. The top-level wrapping varies a little, but inside we can see the , , and we defined in XAML. (The is created in the stock code that comes with the project template.) MainPage StackPanel TextBlock Button Frame App.xaml.cs You might notice there are a couple of extra views inside the that weren't explicitly defined in the XAML. These are part of Button's . If you're not familiar with UWP/WPF/Silverlight/etc's concept of control templating, there's a lot to say about , but the gist of it is that any view which inherits from is a tabula rasa, an empty vessel which will be filled with inner views as defined in its template. (Some of these child views might be templated controls themselves.) It's a powerful means to customise the look of a reusable control. Button default template the subject Control How do we go from a logical tree defined in XAML to a native visual tree? Let’s keep the visual aids rolling. We’ll create an empty class inheriting from , and take a look at its inheritance hierarchy. Button Inheritance chains for the Button class on UWP, Android, iOS, and WASM Like the visual tree, the platform-specific inheritance chains are pretty similar (identical in fact) at the ‘leafward’ end, and diverge a bit at the root. Let’s focus on where they diverge: after the UIElement class, the in UWP. base view type On UWP, inherits from , the base class for types which support data-binding using values. UIElement DependencyObject DependencyProperty In Uno.Android and Uno.iOS, any is an instance of the native base view type ( and respectively, mapped to managed types via the magic of ). So views defined in XAML are also native views. This means, for example, that it's possible to incorporate native views that know nothing about Uno directly into your app's XAML. The following works on iOS: UIElement Android.Views.View UIKit.UIView Xamarin <Page x:Class="UnoExtTestbed.MainPage"...xmlns:uikit="using:UIKit">...<StackPanel><uikit:UILabel Text="Native label"/></StackPanel></Page> This is uniquely easy to do in Uno. We talk about ‘leaving an escape hatch’: the goal is 100% code reuse, but if you positively have to use a platform-specific feature or view library, the flexibility is there. But wait, what about ? DependencyObject Since it’s an important part of the UWP contract, we didn’t want to leave out of the picture, but we also have to be able to support that aren't views at all. ( and , to name just a few.) In Uno therefore is defined as an . It's a 'special' interface however: Uno's code generation automatically adds the backing methods when it finds a class like , allowing code written for UWP to mostly 'just work.' I'll talk more about it in a future article on code generation in Uno. DependencyObject DependencyObjects Brushes Transforms DependencyObject interface MyDependencyObject : DependencyObject In WebAssembly, for now the inheritance hierarchy is a bit simpler and is at the root of the type tree. As you can see in the screenshot, Uno.WASM is generating elements for each view in the visual tree. UIElement <div> Style points The code above nets us a very plain, workaday button, but we could easily spice it up. We set the property to a text string, but can be anything, even another view. Our button could be an , a , or a complex visual hierarchy. It could even have another button inside of it. Content Content image shape What if we want to go in the opposite direction? What if we want to abdicate control over our button’s appearance entirely? A number of controls implemented by Uno, included, support the concept of a 'native' style. Instead of a button that's consistent across all versions of your app, you get a button that looks the way a user of the target platform would expect it to look. Button It’s supported by setting a pre-defined that puts an instance of the native control inside the XAML control. In our code above, we could have written: Style <Button Content="Click me"Click="Button_Click"Style="{StaticResource NativeDefaultButton}" /> Since Android’s default button looks rather similar to UWP’s, I’m going with a more visually obvious illustration using a different control, . I’ll use the from the app. ToggleSwitch sample Uno Gallery Uno’s ToggleSwitch control on Android and iOS, using default and native styles. The with the default style looks the same on all platforms, both statically and in motion. On Android and iOS, however, the with the style replicates the native toggle control of each platform. Of course you can still bind to its properties in XAML as you normally would. This is another powerful option to have: for some apps it makes sense to look as 'native' as possible, for others its desirable to have a rich, customised UI. You may even want to mix and match different approaches for different screens in your app. With Uno it's straightforward. ToggleSwitch ToggleSwitch NativeDefaultToggleSwitch What if I don’t like buttons? In fact implements primitive interaction events like , , etc, so all views in Uno can handle touches/clicks, not just . (The big advantage of using , apart from the MVVM-friendly property, is that it implements to animate your button with.) UIElement PointerPressed PointerReleased Button Button Command visual states There’s plenty more to talk about, like the way that UWP’s API is hooked into each platform’s native input detection, or the way that layouting is done, but that’s all for now. Uno, and if you have any questions. Try out hit us up

Pushing the right buttons : How Uno implements views — Under the hood

Incase you missed it, here are the prequels to this article about the Mobile Vision API. was on the Face Detection API while was on the Barcode Detection API. The first post the second Text Detection API According to , the Text Detection API allows for detecting text in images and videos and it breaks down those texts into blocks (paragraphs/columns), lines (sets of words on the same vertical axis) and words (set of alphanumeric characters on the same vertical axis). The API recognizes text in various Latin based languages. the overview Potential applications I’ll write about what’s possible with this API before I go ahead to explain how to use it . Imagine you were invited to attend the Firebase Dev Summit in Berlin and you got all excited, but you didn’t know a word of German. The only foreign language you understand (apart from English) is some Spanish you picked up on two years ago. Tough huh? How would you communicate if all the signs were in German? Typing the text into Google Translate ALL THE TIME was going to be out of the question because you know German words have a reputation for being unusually long. An option would be to have some sort of way to detect any text you want translated and be able to receive translations in your preferred language immediately. The Text Detection API will help with detecting the text but the Google Translate API will be used for the translations. Duolingo Another possibility is converting a very large amount of text (e.g. from a book) into digital format. The traditional method would be to scan each page, which might damage the . With the Text Detection API, all that’ll be needed is a device with a camera for focusing on the text and maybe some API that uploads the recognized text to a server. book Getting started Here, we are going to detect text from a default image preloaded in an app using the Text Detection API. I initially wanted to take this a step further by translating that text into a specified language as described in the scenario above but I left that part out when I discovered the Translate API is billed per usage. Google Here we go (again)… Create a new project in Android Studio. Import Google Play Services SDK for the Mobile Vision API into your app level build.gradle file. As at the time of writing this article, the latest version is 9.8.0. You are bound to hit the 65k method limit if you import the whole SDK instead of the specific one (play-services-vision) you need. compile 'com.google.android.gms:play-services-vision:9.8.0' To enable the vision dependencies to be automatically installed for text detection, add this meta-data to the manifest file. This ensures the appropriate libraries are downloaded in time for first time users of the app. <meta-dataandroid:name="com.google.android.gms.vision.DEPENDENCIES"android:value=" "/> ocr We’ll create a very simple layout consisting of a , an and a . The loads a cute image of a cat with some German text from the drawable folder. The button starts the processing of the image while the displays whatever text is detected from the image. Button ImageView TextView ImageView TextView Just like the Face Detection and Barcode Detection API, the image has to be converted into a to be processed. Bitmap Bitmap textBitmap = BitmapFactory. (getResources(), R.drawable.cute_cat_image); decodeResource The Text Recognizer is initialized to process the image already present in the . ImageView TextRecognizer textRecognizer = new TextRecognizer.Builder(this).build(); Next, we need to check if the text recognizer is operational already. There’s always the possibility that it won’t work the first time because a library needs to be downloaded to the device and it might not have been completed in time for use. if (!textRecognizer.isOperational()) {new AlertDialog.Builder(this).setMessage("Text recognizer could not be set up on your device :(").show();return;} We then create a frame using the text bitmap and call the text recognizer. Frame frame = new Frame.Builder().setBitmap(textBitmap).build();SparseArray<TextBlock> text = textRecognizer.detect(frame); Our results are now contained in the SparseArray which is then displayed in the . TextView for (int i = 0; i < text.size(); i++) {TextBlock textBlock = text.valueAt(i);if (textBlock != null && textBlock.getValue() != null) {detectedText += textBlock.getValue();}}detectedTextView.setText(detectedText); The Text recognizer should be released once the transaction is completed. textRecognizer.release(); Please note that all these operations should be carried out on a background thread. The code from this article is . on Github here References: _Text recognition is the process of detecting text in images and video streams and recognizing the text contained…_developers.google.com Text Recognition API Overview | Mobile Vision | Google Developers _Optical Character Recognition (OCR) gives a computer the ability to read text that appears in an image, letting…_codelabs.developers.google.com See and Understand Text using OCR with Mobile Vision Text API for Android _text-detector - This application contains all the code from my article on the Text Detector API._github.com moyheen/text-detector Thought this was great? Please don’t forget to “Recommend” and “Share”.

Machine Learning for Android Developers with the Mobile Vision API — Part 3 — Text Detection

Get the DragonBoard Running Windows 10 IoT Core The DragonBoard 410c from Qualcomm is available and now it’s time to get it up and running with Windows 10 IoT Core and Universal Windows Platform apps. The DragonBoard is based on the 64-bit, quad-core Snapdragon 410 processor running at 1.2 GHz with 1 GB of RAM and 8 GB of of internal storage. You get 1 micro USB and 2 USB 2.0 ports along with full sized HDMI and a micro SD card slot. Onboard connectivity and location support are provided by Wi-Fi 802.11 b/g/n, Bluetooth 4.1, and GPS. The Adreno 306 GPU with support for OpenGL ES 3.0 and DirectX will accelerate the graphics of your Universal Windows Platform apps. A 40-pin, low speed and 60-pin, high speed expansion connector will power your projects. Let’s put together a quick shopping list: DragonBoard 410c from $75.00 Arrow Electronics 12 Volt 2 Amp power supply with a cylindrical female output (1.75 x 4.75) from $12.67 Arrow Electronics USB to Micro USB cable from $4.79 Amazon HDMI cable from $6.49 Amazon USB keyboard and mouse from $14.99 Amazon HDMI capable monitor Windows 10 PC Visual Studio 2015 Update 1 Once the items in your shopping list have arrived, head over to the Qualcomm Developer Network for the DragonBoard and download either the x86 or x64 . Extract the zip file and double click to launch the installation wizard. Navigate through the wizard to install the Qualcomm device driver. Tools and Resources page Update Tool for Windows 10 IoT Core DragonBoardUpdateTool_X64.msi Next up, navigate your browser to the Windows IoT page and click the button to download the ISO file: Downloads and Tools DragonBoard Once the ISO file has downloaded, turn it into a virtual CD-ROM (remember those?) drive by double-clicking it. A file called will appear. Double-click the file to launch the installation wizard shown below: Windows_10_IoT_Core_QCDB410C.msi When the wizard has finished, an image file called will be placed in the C:\Program Files (x86)\Microsoft IoT\FFU\QCDB410C\ directory. flash.ffu Now it’s time to connect your Windows 10 PC to the DragonBoard to upload the Windows IoT Core image. The cool thing is you won’t have to boot off an SD card like you’re accustomed to with Arduino or the Raspberry Pi. I need you to flip the DragonBoard over and switch the the switch to while leaving the other three switches OFF. Use a paper clip to flip the switch as shown below: USB BOOT ON Connect the big end of your USB cable to your Windows 10 PC and the micro end to the DragonBoard and connect the power supply to bring it to life. Launch the from the shortcut on your desktop: DragonBoard Update Tool When the Update Tool launches, verify the Connection Status light is green. Click the button and navigate to the file as shown below: Browse flash.ffu Click the button to upload the image to the board. This will overwrite the pre-installed Android image. If you get an error, just retry the process. Give the programming a minute or two and wait for a dialog to pop up to let you know you’re finished. Program Programming successful With the board programming complete, disconnect the power supply and use your paper clip to switch back to the position. USB BOOT OFF Now it’s time for the moment of truth. Connect the HDMI cable from the DragonBoard to your monitor and then connect the USB keyboard and mouse and plug in the power supply to boot Windows IoT Core. I booted mine on my TV. It starts with a SnapDragon boot just to remind you what you’re probably running in your smartphone. Next up, you get a generic picture of a single board computer. Last but not least, you boot into a default Universal Windows Platform (UWP) app just like the Raspberry Pi. If you find yourself having trouble getting Windows 10 IoT Core to boot, try re-seating all your connections on your board and flip the USB BOOT setting back and forth from ON to OFF. Worst case scenario, use the Update Tool again to re-flash your board. The default app should display information about your board, the operating system, connected devices and network status. Since the DragonBoard has onboard Wi-Fi, use your mouse to click the icon on the top-right part of the screen next to the icon. Select and then select the appropriate SSID displayed from your Wi-Fi access point. Click the button and type in your network security key and click . Device Settings Power Network & Wi-Fi Connect Next The last step in the process is to ensure you can connect to the DragonBoard from your Windows 10 PC. From the Start menu, navigate to | and launch the . It will scan the network and list any boards running Windows IoT Core as shown below: All apps Microsoft IoT Windows IoT Core Watcher Right-click on your listed device and select from the context menu to connect to your DragonBoard from your browser. You will be prompted for device credentials so enter for the username and for the password. You’ll be presented with the as shown below: Web Browser Here Administrator p@ssw0rd Windows Device Portal From here, you’ll be able to remotely monitor, configure and deploy software to your DragonBoard. I highly recommend you start out by changing the Administrator password. You also have the option to remotely connect via SSH and PowerShell. You are now up and running with Windows 10 IoT Core on the Qualcomm DragonBoard and ready to build and deploy Universal Windows Platform apps so go ahead and launch Visual Studio 2015 Update 1. Once your IDE has loaded, click . Once your app project has loaded, you’ll have to make some adjustments to Visual Studio in order to deploy and debug against your DragonBoard. You’ll need to select to support the Qualcomm CPU and to debug over Wi-Fi as shown below: File | New | Project | Blank App (Universal Windows) ARM Remote Machine The first time you switch to , a dialog will popup. Using the information from the Windows IoT Core Watcher app, type in the IP address of the DragonBoard in the text box and click the button as shown below: Remote Machine Remote Connections Address Select To perform a quick smoke test, I want you to remotely run a sample app to verify everything is working properly. Open MainPage.xaml in the IDE, click the combo box at the top and select . Throw a control in the center and type as shown below: 10″ IoT Device (1024 x 768) 100% scale TextBlock Hello DragonBoard Run this simple app against your remote machine. This first time out, Visual Studio must deploy appropriate .NET assemblies to the DragonBoard. If you experience a deployment failure, it may be because your DragonBoard has been running for a while and the remote debugger has shut down. If this is the case, restart the DragonBoard and try again. A successful smoke test will look something like this: Congratulations on getting Windows IoT Core to run on the Qualcomm DragonBoard and deploying a Universal Windows Platform app! With its fast graphics and CPU performance coupled with onboard wireless networking, I think you’ll find the DragonBoard to be a great IoT device to work with the Azure IoT Suite. Rob

TERABLOCK

terablock.com

-- employees

Since n.d.

COMPANY RANKING

TERABLOCK

EVERGREEN INDEX #10191

Representing this company? Click here to claim and customize this page!

TeraBlock WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

TERABLOCK

terablock.com

-- employees

Since n.d.

COMPANY RANKING

TERABLOCK

EVERGREEN INDEX #10191

RELATED COMPANIESRANK

STORIES ABOUT TERABLOCK

Representing this company? Click here to claim and customize this page!

TeraBlock WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!