SINGAPORE, Singapore, September 14th, 2023/Chainwire/--Right from the start, TomoOne embarked on a nostalgic journey, embracing the charm of the 1990s classic, Tamagotchi. This fully on-chain digital pet game was born not only to pay homage but to infuse a brilliantly engaging gamification layer into applications, in an effortless way. Inaugurating its journey, TomoOne made its debut within the MetaOne® Wallet. Here, it served a dual purpose: not only to educate Web2 users of Web3 basics via a hands-on experience but also ingeniously ensure that users never forgot their signature for transaction signing. How? By enticing them to interact with it multiple times a day right from the start, even in the absence of any assets in their wallet. Today marks an exciting milestone as AAG opens the doors to TomoOne for 3rd party applications, tapping into the irresistible emotional bond that digital pets create, offering them a golden opportunity to attract and retain users on a daily basis. Once seamlessly integrated, these 3rd party apps can introduce an entirely novel dimension to the pet-raising experience. Imagine this: you visit a participating restaurant, and not only do you indulge yourself, but you also get the joy of feeding your digital companion simultaneously—a delightful fusion of real-world and virtual interaction! SingSing, a Sing-to-Earn karaoke application that recently launched on Saakuru Blockchain, is the first application to utilize TomoOne API for gamification. “As a pioneer embracing the TomoOne API for a thrilling gamification experience, TomoOne users can now harmonize with their digital companions through lively karaoke sessions and dive into a world of engaging activities on SingSing!" said Jack Vinijtrongjit, CEO of AAG. As the TomoOne platform evolves, AAG is set to elevate the excitement by introducing an array of captivating gamification features. It all begins with the expansion of stats, now encompassing not just happiness, but intelligence and strength, rendering each pet truly one-of-a-kind, shaped by their owners' tender care. But that's not all—users will soon embark on thrilling competitions, pitting their pets against friends and challengers alike in a medley of exhilarating activities! “AAG is a promising and rapidly expanding web3 platform with a solid foundation, and we are thrilled to be a partner, bringing over 70,000 members, NFTs, vouchers, and more for exchange and interaction. We believe that a sustainable partnership will create additional value for both communities, with underlying technology from TomoOne and the MetaOne wallet.” said Hai Nguyen, SingSing's Head of Product. Ready to infuse a burst of excitement into TomoOne's digital pet world? Get started today! TomoOne API is now available, and access can be requested from the AAG website. About AAG AAG is a Web3 infrastructure company focused on providing a software ecosystem that helps simplify interactions with blockchain applications and the Metaverse for both mainstream users and traditional companies. AAG provides a secure and easy-to-use seedless MetaOne® wallet and MetaOne® SDK, as well as infrastructure software, such as a cross-chain search engine and gas-fee-less Saakuru blockchain for enterprise companies. Our mission is to empower individuals and businesses by bridging the gap to harness the power of Web3 via our technology while providing strategies for businesses to successfully adapt and create the next level of engagement-focused products and services. For more information about AAG, visit: AAG Linktree About SingSing SingSing is a unique application that connects web3 technology with physical singing activities, transforming web2 karaoke parties into an enjoyable web3 experience. Our goal is to promote happy lifestyles with the power of blockchain. With the Sing-to-Earn feature, SingSing encourages singing lovers to sing better. Apart from that, users can enjoy many other features such as singing contests, social activities, lucky draws, NFT minting, NFT marketplace, voucher exchange, and much more to come. Quietly working in the background, SingSing has attracted more than 70,000 organic users. The number keeps growing, welcoming thousands of new users every day across South East Asia, especially from the Philippines. Contact Jack Vinijtrongjit partnership@aag.ventures This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program: https://business.hackernoon.com/business-blogging?ref=hackernoon.com

How to Revolutionize Your Business With AAG's TomoOne API: Take Gamification to the Next Level

Cómo revolucionar su negocio con la API TomoOne de AAG: lleve la gamificación al siguiente nivel

Comment révolutionner votre entreprise avec l'API TomoOne d'AAG : faites passer la gamification au niveau supérieur

AAG के TomoOne API के साथ अपने व्यवसाय में क्रांति कैसे लाएं: Gamification को अगले स्तर पर ले जाएं

AAG の TomOne API でビジネスに革命を起こす方法: ゲーミフィケーションを次のレベルに引き上げる

Como revolucionar seu negócio com a API TomoOne da AAG: leve a gamificação ao próximo nível

Cách cách mạng hóa hoạt động kinh doanh của bạn với API TomoOne của AAG: Đưa Gamification lên một tầm cao mới

如何利用 AAG 的 TomoOne API 彻底改变您的业务：将游戏化提升到新的水平

In today's "Behind the Startup" series, we delve deep into the entrepreneurial journey of a serial innovator who has seamlessly navigated his ventures from airlines to luxury fashion. He's revolutionizing the world of Web3 and is on a mission to onboard 1 billion users by 2030. Join us as Jack Vinijtrongjit unveils how experiences across various sectors influence the vision of AAG and what lies ahead for the Web3 economy. More Than Just an SDK: How AAG is Redefining Web3 User Experience & Bridging the Wallet Gap Ishan Pandey: Hi Jack, great to have you here for our "Behind the Startup" series. As a serial entrepreneur, you have extensive experience in creating platforms for different sectors. Can you share some insights on how your past experiences are helping shape the vision and execution of AAG? Ishan, thanks for having me on the show. I’m a big fan of the series. You’re quite right to point out that I’ve worked across a number of different sectors and verticals. I think this has helped me as an entrepreneur, but, to be honest, I don’t think working across different industries – in my case, everything from airline to luxury fashion – is necessarily something exclusive to founders. Jack Vinijtrongjit: The key to making these experiences build on one another, however, rather than being unrelated areas, is to find lessons you’ve learned in one domain and apply them to another. Like Steve Jobs said, you’ve got to figure out how to join the dots. Everything I’ve learned in my previous work has led me to what we’re doing with AAG: Not just the practicalities of founding a company, but the importance of figuring out a strong vision to build around and then providing the tools to make it possible to create it. For example, I think having a strong foundation is very important because it allows us to be able to test out ideas quickly. Everything we built is modular, so while the idea may not work, we still end up with another component we can use for the new idea. You just need a guiding north-star vision to decide what you’re trying to do and how it fits together. This is how we execute ideas at AAG. Ishan Pandey: As an individual with a background in enterprise software architecture and development, how do you intend to use this expertise to simplify access to the Web3 economy and achieve your goal of onboarding 1 billion users by 2030? To get to that kind of number, the fastest way is to go the enterprise route and work with companies that already have a large user base. Imagine working with a telco company that already has 70m users. In that case, you have the opportunity to onboard a large chunk of users in one go. However, while that’s great for us, it could also be viewed as a risk by them. Large companies serving an enterprise market are, totally understandably, cautious about embracing bleeding edge technologies in some cases. Jack Vinijtrongjit: They have to do the right things by their users – and that user base is very likely to contain lots of people that aren’t early adopters excited about new technology for new technology’s sake. As a result, they want to work with companies that can de-risk the opportunity for them – to make it a very cheap experiment with very little time to go-to-market, without causing disruption to their existing businesses. Once you can get to that point and arm yourself with a range of use cases they can easily understand and see validated, it becomes a no-brainer for them. Ishan Pandey: Given your time at TIBCO Software where you worked on large-scale integration projects across various sectors, how does this experience inform your current strategies in developing and deploying AAG’s platform? Selling to enterprises is all about presenting a solution to a problem. You can have the best product, but by itself, that may not be good enough. We also need to align ourselves with service integrators who are already working with a lot of their clients and arm them with tools that they can use to onboard them to Web3. Imagine having 10,000 developers actively using your software because it makes their lives easier and their clients happy. That’s what I have learned from my days at TIBCO, and that’s how we are intending to scale. Jack Vinijtrongjit: Ishan Pandey: Can you elaborate on the specific ways AAG aims to achieve what you just described? Sure. One recent example we have is our MetaOne Wallet. Our users love using our wallet because it’s much easier to use and they feel much more comfortable because we took away the complexity of managing seed phrases and private keys. Those were major pain points we see with other solutions in the same space. However, we also understand that businesses want to control the user experience and eliminate the need to have an external wallet. So what did we do? Jack Vinijtrongjit: We used the existing components we used to create MetaOne Wallet and created MetaOne Embeddable SDK. Now businesses and service integrators can use the SDK as a tool to enable Web3 aspects of their business. Ishan Pandey: How is your SDK different from something like Magic or Venly? Remember when I told you that for a business to venture its way into Web3, it must be cheap and easy, with minimal disruptions? That’s exactly what we did. You essentially get everything MetaOne Wallet provides, including all the UI. If you have not developed a wallet before, you would not have known that 60+ screens are required to provide comprehensive flows. That’s a lot of time taken away from developers being able to focus on their core features. Jack Vinijtrongjit: Ishan Pandey: That’s great. Seems like that will help save a lot of time. Are there any other reasons why developers should pick MetaOne SDK? It depends on what they do. One thing that I think will be quite common across is what we call Shared Mode. Let’s do this. Take your phone out and tell me how many apps you have installed. Jack Vinijtrongjit: Ishan Pandey: I would say at least 70. Imagine if they are all Web3 dApps. If they all use Magic or Venly, you will end up with 70 wallets because they are bound to the dApp even if you use the same credentials to sign up. Most people can’t even manage one bank account. Imagine having to manage 70. Imagine gas fees in 70 wallets: it’s a nightmare. So while a lot of SDKs allowed dApp to solve UX problems, it actually ended up creating one major UX problem. With the Shared Mode that we support, users have control of their own wallets and can choose to use the same wallet with any dApp, just like how you use a standalone wallet like MetaOne or MetaMask. Jack Vinijtrongjit: This also enables businesses to have insights into users’ behaviours since activities are on-chain. If a new user always starts with a new wallet, they would have no clue how to personalize the journey until they have collected enough information. Ishan Pandey: That sounds like a big problem to me. I’m surprised that popular SDKs are not addressing this. With that said, having a wallet per dApp is also safer, right? What if someone makes a mistake? Wouldn’t they lose everything? That’s actually a very interesting point. For us, we prefer the preventative measure. We have many security measures that warn users if they are about to do something wrong. You can actually try to go to a website like Chain Abuse and try to send ETH to one of those blacklisted addresses. You will find that we will give a very strong warning that you should not. Anyway, they also have the option to create a new wallet within the same account if they so choose. It’s more about providing control to the users. Jack Vinijtrongjit: : This 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 Vested Interest Disclosure brand-as-author program Ishan Pandey: Project Titan seems to be a significant achievement for AAG. Can you explain in more detail how this score infrastructure contributes to the scalability and security of the platform? Yes, Project Titan is the foundation for us. It allows us to develop and deploy new software quickly. Without having this kind of framework, it will be very difficult for a junior developer to jump in and contribute for example. We are actually working on some exciting features that will allow non-developers to also deploy business logic and test the outcome without having to know how to code. This is going to be very essential for us in the near future. You will certainly hear more about this soon as it becomes available. Jack Vinijtrongjit: Ishan Pandey: Thanks for sharing and I’m looking forward to hearing more about it. It certainly looks like you guys are always doing a lot of things. Just one last question from me. What made you decide to develop your own layer 2 protocol? It’s called SAA-KU-RU, right? Did I pronounce that correctly? Yes, you were spot on. Saakuru is a Japanese word that means “circle” or “activity club.” I know the double A does confuse some people. The reason we decided to have our own L2 is because we want to have some control over how the chain behaves in the future. Besides that, we have also worked with enough projects that see gas fees as a major obstacle. By building on top of Oasys, we were able to eliminate gas fees. As you can see with TomoOne, we are able to give our MetaOne users a digital pet right after they create an account. Besides being a game, it also serves two more purposes: One, which is to introduce users to how to sign a transaction, and, secondly, to make them use the pin code for authorization that they just entered so they don’t forget. I actually thought it was a genius idea when my team came up with it. Jack Vinijtrongjit: We are currently looking to onboard around seven projects to Saakuru by the end of 2023. People definitely see the benefits of having no gas fees, but at the same time, they also know that Oasys are backed by quite a few gaming giants so they are looking to benefit from the massive gaming ecosystem as well. Ishan Pandey: Awesome! I’m going to wrap it up here for today. It’s been great catching up with you and hearing about all the exciting things going on at AAG. Likewise. Thanks again for having me on the show. It’s been great! Jack Vinijtrongjit: Don’t forget to like and share the story!

Code-Free Logic Deployment: A Peek into AAG's Vision for Empowering Non-Developers

Implementación de lógica sin código: un vistazo a la visión de AAG para empoderar a los no desarrolladores

Déploiement logique sans code : un aperçu de la vision d'AAG pour l'autonomisation des non-développeurs

कोड-मुक्त तर्क परिनियोजन: गैर-डेवलपर्स को सशक्त बनाने के लिए एएजी के दृष्टिकोण पर एक नज़र

コードフリーのロジック展開: 非開発者を支援するための AAG のビジョンを覗く

Implantação de lógica livre de código: uma espiada na visão da AAG para capacitar não desenvolvedores

Triển khai logic không có mã: Xem qua tầm nhìn của AAG để trao quyền cho những người không phải là nhà phát triển

无代码逻辑部署：一窥 AAG 为非开发人员提供支持的愿景

Integrating Physics-Informed Neural Networks for Earthquake Modeling: Summary & References

If you have ever worked on a Spring application using Hibernate 5, you probably encountered the challenge of dealing with duplicated entities. It is an odd scenario where your collection contains multiple entries referencing the same entity. This is a quite known issue, and there are ways to address it whether using the keyword, Sets, or JPA EntityGraph. DISTINCT However, I happened to have quite disturbing behavior using EntityGraph returning duplicated entities! We will be diving a bit under the hood of Hibernate 5 to understand what happened. A Simple Spring Boot Application To illustrate Hibernate 5 behavior, let’s start with a basic Spring Boot project connected to a database: https://github.com/Shaolans/HibernateEntityGraphDeduplicationIssue The database schema is a simple model as follows: The Hibernate entities are defined as follows: Our focus will be on the queries generated by this JPA repository: @Repository
public interface AuthorRepository extends JpaRepository<Author, Integer> {

    @Query("SELECT a FROM Author a LEFT JOIN FETCH a.books")
    List<Author> findAuthorsLeftJoinFetchNoEntityGraph();

    @EntityGraph(attributePaths = "books")
    @Query("FROM Author a LEFT JOIN a.books")
    List<Author> findAuthorsLeftJoinWithEntityGraph();

    @Query("FROM Author a LEFT JOIN a.books")
    List<Author> findAuthorsLeftJoinWithoutEntityGraph();

    @EntityGraph(attributePaths = "books")
    @Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
    List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph();

    @EntityGraph(attributePaths = "books")
    @Query("SELECT a FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
    List<Author> findAuthorsWithJoinNotFetchedAndEntityGraphAndSelect();
} Entity Duplication Why Does It Happen? To understand the occurrence of entity duplication, let’s consider a use case where the objective is to retrieve all authors and their respective books. In order to avoid the issue I include in my JPQL query the keyword . N+1 query FETCH It enables the retrieval of both authors and their associated books in a single SQL query, eliminating the necessity to individually fetch books for each author. @Query("SELECT a FROM Author a LEFT JOIN FETCH a.books")
List<Author> findAuthorsLeftJoinFetchNoEntityGraph(); Invoking this method will result in the compilation of an SQL query equivalent to the following: SELECT A, B FROM AUTHOR A LEFT JOIN BOOK B ON A.ID = B.BOOK_AUTHOR_ID; In a case where you have 2 authors that have respectively 2 and 3 books, the result of the SQL query will yield the following table: Depending on the type of used, the association between the and tables are established based on the provided condition. join Author Book This will produce for each that matched an , a new row containing the columns of the table but also the columns of the table. Book Author Book Author Hibernate, upon retrieving this result set, intelligently resolves the entity without duplication. In our case, we end up with only two instances of the entity. However, it handles resolution on a row-by-row basis and does not inherently deduplicate the rows by default. Author This explains why the , returned by calling , returns the following collection: List findAuthorsLeftJoinFetchNoEntityGraph [Author@5640, Author@5640, Author@5641, Author@5641, Author@5641] being the instance representing J.R.R Tolkien entity and representing the Isaac Asimov. Author@5640 Author Author@5641 Author This duplication is mostly observed on and relationships since joining with these types of relations might match multiple rows of the associated table. @OneToMany @ManyToMany On the contrary, and relationships match at most only 1 entry on the associated table and will not induce duplication. @OneToOne @ManyToOne How to Deduplicate Although this duplication issue is quite common and often occurs during the development of applications, there are ways to address and resolve this issue. Set A straightforward solution involves using the returning type instead of : Set<Author> List<Author> @Query("FROM Author a LEFT JOIN FETCH a.books")
Set<Author> findAuthorsLeftJoinFetchNoEntityGraph(); When the results are collected, duplicated entities will be filtered through the . Set DISTINCT keyword Another approach is to use the keyword: DISTINCT @Query("SELECT DISTINCT a FROM Author a LEFT JOIN FETCH a.books")
List<Author> findAuthorsLeftJoinFetchNoEntityGraph(); It should be noted that using as two semantic meanings: DISTINCT : The conventional SQL meaning involves filtering duplicate values in the selected columns. SQL : It indicates a desire to filter duplications in the parent entity. Hibernate When the keyword is used in a JPQL query, it leads to the generation of an SQL query featuring the keyword but also instructing Hibernate to filter duplicated entities. DISTINCT DISTINCT However, using in SQL induces an overhead when executed in the database, and in some cases, the goal is to only filter duplicate entities induced by the join. For such cases, the Hibernate hint can be employed to avoid the generation of in the SQL query: DISTINCT HINT_PASS_DISTINCT_THROUGH DISTINCT @QueryHints(@QueryHint(name = HINT_PASS_DISTINCT_THROUGH, value = "false"))
@Query("SELECT DISTINCT a FROM Author a LEFT JOIN FETCH a.books")
Set<Author> findDistinctAuthorsLeftJoinFetchNoEntityGraph(); EntityGraph In JPA 2.1, EntityGraph was introduced as a powerful feature allowing developers to define the loading strategies of entities. In our case, we can just use the annotation to load the books along with the , as illustrated below: @EntityGraph Author @EntityGraph(attributePaths = "books")
@Query("FROM Author a LEFT JOIN a.books WHERE a.books.size > 2")
List<Author> findAuthorsLeftJoinWithEntityGraph(); This JPQL query is designed to retrieve all authors, along with their respective books, who possess more than 2 books. Even without explicitly including the keyword in the SQL query, the EntityGraph ensures the books are loaded and the parent entity remains non-duplicated. FETCH Author : This is a simple example of using EntityGraph; a more complete and sophisticated way of using it exists, but this is not the scope of this section. Note EntityGraph and Entity Duplication While it is established that EntityGraph handles entity deduplication, let's look into a more complicated scenario. Consider the entity, which has a relation with . Suppose the objective is to retrieve all authors and their books where the author's agent has a name containing "John", yet we have no intention of loading the entity for an arbitrary reason. In this case, we can accomplish this by the following code: Author @ManyToOne Agent Agent @EntityGraph(attributePaths = "books")
@Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); Since we are using EntityGraph, we expect to avoid duplicated , but upon executing the method, the outcome is unexpected: Author Duplicated entities are retrieved despite the use of EntityGraph. To understand the underlying reasons for this behavior, let’s dive a bit under the hood of Hibernate! How Hibernate Resolves Entity Duplication Hibernate is a quite complete and complex ORM, it can be hard to grasp entirely its fine details, but in our case, since we want to understand deduplication mechanisms, we will be focusing on the method of list . QueryTranslatorImpl For the sake of clarity, some portions of the code have been omitted in order to highlight the most crucial aspects. Upon invoking a method from the , the execution will eventually reach this code snippet. Here is a breakdown of its functionality: AuthorRepository It computes a boolean called , and as the name implies, it identifies whether the result set needs to be deduplicated. needsDistincting We can observe when we do use a keyword, EntityGraph, or limit the size of retrieval, there is a operation in the JPQL query; the distinction needs to be applied. DISTINCT AND FETCH In our issue, it can be observed that whenever EntityGraph is used, the distinction will be applied since EntityGraph will edit the source query to “ ” child entities given in the attribute paths. FETCH This method invocation executes the query in the database, retrieves the result set, and resolves the entities. This list might contain duplicated entities. This is the most interesting part here; when it does need to distinguish entities, Hibernate uses an to filter out the duplicated entity. IdentitySet At this point, it is established that using EntityGraph should filter duplicated entities, but what happened to cause the unexpected outcome previously discussed? Why EntityGraph Returns Duplicates in Some Cases Let’s Compare In order to have a better understanding of the situation, let’s compare the results of when invoking the following methods: queryLoader.list( session, queryParametersToUse ) (2) @EntityGraph(attributePaths = "books")
@Query("FROM Author a LEFT JOIN a.books")
List<Author> findAuthorsLeftJoinWithEntityGraph(); and @EntityGraph(attributePaths = "books")
@Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); Upon calling , the returned results contains: findAuthorsLeftJoinWithEntityGraph Given the EntityGraph is used, the duplication will be resolved through the , and at the end, the method will return a consisting of 3 authors/instances. IdentitySet List<Author> However, upon calling , the returned results contains the following: findAuthorsWithJoinNotFetchedAndEntityGraph In this scenario, the result is not a List of instances but rather a of distinct array instances of Objects; each encapsulating duplicated and instances. The reason behind the presence of duplicate entities becomes evident. Author List Author Agent Each array ( , , ..., ), being a unique instance, is not filtered during the distinction process with the . Object[2]@13551 Object[2]@135512 Object[2]@13555 IdentitySet Consequently, all arrays are considered as distinct instances, leading to the observed duplication. Explaining the Difference In order to understand the difference between obtaining a List of instances in the former case and a list of arrays containing and instances in the latter case, we need to explore deeper; let’s take a look at the class and especially the method . Author Author Agent QueryLoader initialize This initialization code has interesting parts, particularly the one highlighted in red. It creates an array of boolean where it checks which entities should be selected and be returned. includeInSelect Let’s take for example: @Query("SELECT a, b FROM Author a LEFT JOIN FETCH a.books b") The initialize method checks the content one by one which is and ; if the selected entity originates from a in the clause, then it will be omitted since is used to load children entities (but not in the case of the parent entity). Otherwise, the entity should be selected. SELECT a b FETCH FROM FETCH In this example, the array contains . includeInSelect [true (Author), false (Book)] In our case, of entity duplication with EntityGraph: @EntityGraph(attributePaths = "books")
@Query("FROM Author a INNER JOIN a.agent WHERE a.agent.name like 'John'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); We did not specify the clause, so by default, it will select all the entities from all the tables specified in the clause. SELECT FROM The logic returns an array where and (2 elements) should be selected because only is subject to a operation due to the use of EntityGraph. includeInSelect [true (Author), false (Book), true (Agent)] Author Agent Book FETCH This explains the difference between and . findAuthorsLeftJoinWithEntityGraph findAuthorsWithJoinNotFetchedAndEntityGraph The former returns only one value per row because the clause contained only and entities (the select of was generated by EntityGraph), however, since was subject to a , it was not taken into account in the . SELECT Author Book Book Book FETCH includeInSelect The latter returns an array per row because and were in the clause and are not subject to a operation unlike . Thus, returning an array consisting of 2 elements per row. Author Agent SELECT FETCH Book In summary, Hibernate consistently returns an array, and the content of this array is determined by the entities specified in the clause that are not associated with operations. SELECT FETCH However, if we follow the preceding logic, should also return an array but an array of a single element. This is accurate; it does. However, upon examining the implementation at ** **lines and , when the array consists of a single element, the element is just unwrapped. findAuthorsLeftJoinWithEntityGraph QueryLoader 476 620 How to Fix It To ensure correct duplicate filtering when applying a distinction, the result set should be a list of entities rather than a list of entity arrays. This behavior is determined by the entities selected. A straightforward solution is to include the desired entities in the clause: SELECT @EntityGraph(attributePaths = "books")
@Query("SELECT a FROM Author a INNER JOIN a.agent WHERE a.agent.name like '%John%'")
List<Author> findAuthorsWithJoinNotFetchedAndEntityGraph(); The clause will only contain and (the select being generated by the EntityGraph): SELECT Author Book Book Since is a operation, the will only select one element ( ), and instead of returning an array, it will return directly the instance which then will pass through the to be deduplicated. Book FETCH includeInSelect Author Author IdentitySet Conclusion Entity duplication occurs when tables are joined, and multiple rows are matched. There are several methods to address this issue, including using , the keyword, or EntityGraph to deduplicate the result set. Set DISTINCT In the last two cases, deduplication is achieved through a Hibernate flag that accumulates results into an . IdentitySet However, it may not work in certain scenarios due to the fact that, depending on your clause, it could return newly instantiated arrays of your selected entities for each row. This could undermine deduplication through the . SELECT IdentitySet Therefore, it is advisable, when writing JPQL queries, to always specify the clause. If not supplied, all entities in the clause that are not subject to a operation will be selected by default. SELECT FROM FETCH The issue of duplicated parent entities is addressed in Hibernate 6 (shipped in Spring Boot 3), as it has introduced automatic handling of duplicated entities. However, considering that the release of Hibernate 6 is relatively recent, many applications still run on Hibernate 5 or earlier versions, and migration from Hibernate 5 to 6 might be challenging. Thus, understanding how Hibernate 5 handles these situations remains relevant for the considerable number of applications still using it. Also published here

Hibernate 5 and Entities Duplication: Let’s Dive Under the Hood

A Roadmap for User Empowerment in the Dark Pattern Landscape

In the realm of business intelligence and data analytics, SAP BusinessObjects stands tall as a powerful tool, empowering organizations to transform raw data into actionable insights. While its capabilities are robust, accessing and managing data programmatically can offer even greater flexibility. This blog post delves into the world of SAP BusinessObjects and Python, demonstrating a step-by-step approach to retrieve the list of documents effortlessly. Why This Matters In SAP BusinessObjects, years of operation can result in a cluttered mess of documents and folders. Cleaning up this chaos is crucial for data teams. By using Python to retrieve the details like path and last modified date and status for all documents, you gain a powerful tool. Python Solution Part 1: Authentication To initiate the authentication process, please replace the placeholder values for "username," "password," and "localhost" with your specific configuration details. import requests
import pandas as pd
import xml.etree.ElementTree as ET

# define the login request parameters
username = 'username'
password = 'password'
localhost = 'localhost'

auth_type = 'secEnterprise'
login_url = 'http://{}:6405/biprws/logon/long'.format(localhost)
login_data = f'<attrs xmlns="http://www.sap.com/rws/bip"><attr name="userName" type="string">{username}</attr><attr name="password" type="string">{password}</attr><attr name="auth" type="string" possibilities="secEnterprise,secLDAP,secWinAD,secSAPR3">{auth_type}</attr></attrs>'
login_headers = {'Content-Type': 'application/xml'}

# send the login request and retrieve the response
login_response = requests.post(login_url, headers=login_headers, data=login_data)

# parse the XML response and retrieve the logonToken
root = ET.fromstring(login_response.text)
logon_token = root.find('.//{http://www.sap.com/rws/bip}attr[@name="logonToken"]').text
api_headers = {'Content-Type': 'application/xml', 'X-SAP-LogonToken': logon_token} The code focuses on the initial authentication process, forming a secure connection to the server. User credentials, server details, and authentication type are configured, and a POST request is made to the specified login URL. The XML response from the server is parsed to extract the crucial . This token is then employed to construct headers for subsequent API requests, ensuring authenticated access to SAP BusinessObjects. logonToken Part 2: Data Retrieval and DataFrame Creation Previewing Retrieved Data: First Document's Name As we venture into data retrieval from SAP BusinessObjects, a peek at the obtained information reveals its structure. This Python snippet fetchs all the information about documents from the server. If you run the code, it will print the name of the first document. url = "http://{}:6405/biprws/raylight/v1/documents/".format(localhost)
response = requests.get(url,api_headers)
root = ET.fromstring(response.text)

first_docu_key = root.findall('document')[0][2].tag
first_docu_item = root.findall('document')[0][2].text
print(first_docu_key, ":", first_docu_item) Data Transformation Functions: Transform to DataFrame The Python functions, and , work together to simplify SAP BusinessObjects data retrieval. The first function transforms XML data into a structured pandas DataFrame, capturing document attributes. The second function efficiently handles scenarios with documents exceeding a single request's limit by appending multiple DataFrames. Collectively, these functions streamline the conversion of XML to DataFrame and provide an easy solution for handling a large number of documents. get_dataframe_from_response get_all_dataframe def get_dataframe_from_response(response):
    # Parse the XML data
    root = ET.fromstring(response.text)
    # Extract the data into a list of dictionaries
    res = []
    for item in root.findall('document'):
        doc_dict = {}
        for elem in item.iter():
            if elem.text is not None:
                doc_dict[elem.tag] = elem.text
        res.append(doc_dict)
    # Convert the list of dictionaries to a pandas dataframe
    df = pd.DataFrame(res)
    return df

def get_all_dataframe(url):
    documents = []
    for i in range(50):
        offset = i * 50
        url_offset = url + "?offset={}&limit=50".format(offset)
        response = requests.get(url_offset, headers=api_headers)
        df = get_dataframe_from_response(response=response)
        if df.empty:
            break
        else:
            documents.append(df)
    dataframe = pd.concat(documents, axis=0)
    return dataframe Retrieve detailed information about SAP BusinessObjects documents effortlessly using a single line of Python code. Utilize the function, and the resulting DataFrame provides a straightforward overview of document attributes. get_all_dataframe df_documents url = "http://{}:6405/biprws/raylight/v1/documents/".format(localhost)
df_documents = get_all_dataframe(url=url)
print(df_documents.head()) Showcasing df_documents: What follows is a glimpse into the dataframe structure document id cuid name folderId description 10283 AfZQen_U5hGgHqB8 Revenue Report 10782 NaN 12012 AUgbex_JocxFfvSFw Sales Report 11931 NaN 12435 AaGqyXfPrFIuC1Eac Cost Report 11965 NaN 11232 ATvl8iD_ii2HdxkKEY Inventory Report 11038 NaN 11023 cyslJAAy.JAJBB13hE Finance Report 11021 NaN Part 3: Document Details Extraction If you need additional details such as the document's path, last updated time, scheduling status, size, and refresh status, utilize the following function. This function fetches the specified details for each document in the DataFrame, providing a more comprehensive overview of each entry. df_documents def get_document_detail(documentID, detail):
    url = 'http://{}:6405/biprws/raylight/v1/documents/{}'.format(localhost, documentID)
    res = requests.get(url, headers={
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-SAP-LogonToken": logon_token
    }).json()
    return res['document'][detail]

def get_more_information_from_documents(df):
		details = ['path', 'updated', 'scheduled', 'size', 'refreshOnOpen']
		for detail in details:
        df[detail] = [get_document_detail(id, detail) for id in df['id'].values]
    return df

df_documents_more_info = get_more_information_from_documents(df_documents) Showcasing df_documents_more_info: document id cuid name folderId description path updated scheduled size refreshOnOpen 10283 AfZQen_U5hGgHqB8 Revenue Report 10782 NaN Public Folders/Test 2023-06-04T08:24:23.461Z false 64613 true 12012 AUgbex_JocxFfvSFw Sales Report 11931 NaN Public Folders/Test 2023-06-04T08:30:17.907Z false 64481 true 12435 AaGqyXfPrFIuC1Eac Cost Report 11965 NaN Public Folders/Test 2020-06-22T02:06:55.858Z false 65471 true 11232 ATvl8iD_ii2HdxkKEY Inventory Report 11038 NaN Public Folders/Test 2023-07-17T08:06:38.444Z false 171294 true 11023 cyslJAAy.JAJBB13hE Finance Report 11021 NaN Public Folders/Test/Test 2023-07-08T03:04:05.241Z false 168952 true 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

Unlocking SAP BusinessObjects Data: The Full Guide to Retrieving Documents with Python

This article took longer than expected, and I struggled at almost every step for different reasons. But… stop crying, let's make some code =) 1. Introduction In this article, we dive into with NTFs, and because simply creating a smart contract with an NFT and deploying it is very dull and has already been partly in previous articles on this topic, I decided to complicate my life and make these same NFTs created from a bot in Telegram. web3 2. The boring part that everyone skips An NFT, or Non-Fungible Token, is a unique digital asset that represents ownership of a specific item or piece of content, such as artwork, music, videos, or other forms of creative work, using blockchain technology or, in simple words, a link to your asset (storing the asset itself on the blockchain is costly). Here are some critical aspects of NFTs: : NFTs provide a way for creators to sell digital items with a clear record of ownership. This ownership is secured and verified using blockchain technology, typically on the Ethereum blockchain. Digital Ownership : Each NFT has unique properties that cannot be replicated. This uniqueness can create scarcity, which can drive up the value of the NFT. Uniqueness and Scarcity : NFTs can often be used across different blockchain platforms and applications. This means a digital artwork tokenized as an NFT can be viewed, bought, or sold in various virtual environments and marketplaces. Interoperability : The blockchain ledger records the history of each NFT, including its creation, sale, and previous ownership. This transparency helps verify the authenticity and provenance of the digital asset. Provenance and Authenticity : NFTs can be programmed to provide ongoing royalties to their original creators. Whenever the NFT is sold to a new owner, a percentage of the sale can automatically go back to the original creator. Royalties Because it is expensive to store assets in the blockchain, and there is a strong desire to show off distributed technologies, hipsters reinvent torrents and call it IPFS. IPFS, which stands for InterPlanetary File System, is a protocol and peer-to-peer network for storing and sharing data in a distributed file system. IPFS was created to make the web faster, safer, and more open. Here are some key features and concepts associated with IPFS: : Unlike traditional centralized file storage systems, IPFS is built on a distributed network. This means files aren't stored in a single location but distributed across multiple network nodes. Decentralized and Distributed : IPFS uses content-based addressing rather than location-based addressing. Each file and piece of content on IPFS is identified by a unique fingerprint called a cryptographic hash. This ensures that users are accessing the content they requested, as the hash of the content verifies its integrity. Content Addressing : Since IPFS retrieves files from the nearest node rather than a central server, it can lead to faster download speeds and reduced load on any single server. This also makes the system more resilient to censorship and server failures. Efficient and Resilient : IPFS supports versioning and linking, which allows for the creating of complex webs of data with rich relationships and history. Versioning and Linking : IPFS has a wide range of applications, including decentralized web projects, blockchain data storage, file sharing, and as a replacement for traditional HTTP in specific scenarios. Use Cases : Its decentralized nature makes IPFS a popular choice for storing data in blockchain applications, enhancing storage capacity and access efficiency. Compatibility with Blockchain IPFS is part of a more significant movement towards a decentralized internet, where users have more control over their data and how it functions. It is often associated with decentralized technologies like blockchain and distributed ledger technology. 3. Principles of work How will our bot work? When a user sends a message or image, we check if the user added his Ethereum address. We unobtrusively ask you to add it if he hasn't added it. Otherwise, we won’t let you create an NFT. After we have an address, the user can send us an image, which will be a future NFT. When we got the image, we uploaded it into IPFS and created a metafile with information about NFT. This file will be uploaded into IPFS. After we upload everything, we mint NFT in the contract with a link to a metadata file. Say, user, that's all done. … Profit 4. Prerequisites First, we need an account on Telegram Second, create a bot using @BotFather Init app with next app (not that it's essential, and you can use express, but I make some space for the future) npx create-next-app@latest telegram-bot --use-npm Go to folder cd telegram-bot And init hardhat npx hardhat init And we have a basis for our project.. So clean and nice Create file and add into it .env NEXT_TELEGRAM_TOKEN=6440257800:AAGY...
NEXT_SEED=qwerty
NEXT_VERIFIER_ADDRESS=
NEXT_NFT_ADDRESS=
NEXT_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
NEXT_JSON_RPC=http://127.0.0.1:8545/
NEXT_CHAIN_ID=1337
NEXT_IPFS_NODE=http://127.0.0.1:5001/ Here is the credential for local development. can be taken from @BotFather NEXT_TELEGRAM_TOKEN 5. Contracts 5.1 Verification Here is a simple key-value storage Create file with the following content contracts/Verification.sol // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

// Uncomment this line to use console.log
// import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Verification is Ownable {
    mapping(uint => address) public verified;

    constructor() Ownable(msg.sender) {}

    function verify(uint256 _id, address _address) public onlyOwner {
        verified[_id] = _address;
    }
} and scripts/deploy_verification.js const hre = require("hardhat");

async function main() {
  const instance = await hre.ethers.deployContract("Verification");
  await instance.waitForDeployment();
  console.log(`Verification Contract deployed to ${await instance.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});4.2 Nft Deploy it npx hardhat run scripts/deploy_verification.js --network local Save contract address into file .env ...
NEXT_VERIFIER_ADDRESS=...
... 5.2 NFT And here I decided not to bother and created a file through the wizard . It’s very convenient, but first, I would still recommend that you practice writing such contracts yourself. https://docs.openzeppelin.com/contracts/5.x/wizard Create file with the following content. contracts/TelegramBot.sol // SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract TelegramBot is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
    uint256 private _nextTokenId;

    constructor(address initialOwner)
    ERC721("TelegramBot", "TGB")
    Ownable(initialOwner)
    {}

    function safeMint(address to, string memory uri) public onlyOwner {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
    }

    // The following functions are overrides required by Solidity.

    function _update(address to, uint256 tokenId, address auth)
    internal
    override(ERC721, ERC721Enumerable)
    returns (address)
    {
        return super._update(to, tokenId, auth);
    }

    function _increaseBalance(address account, uint128 value)
    internal
    override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }

    function tokenURI(uint256 tokenId)
    public
    view
    override(ERC721, ERC721URIStorage)
    returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
    public
    view
    override(ERC721, ERC721Enumerable, ERC721URIStorage)
    returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
} and scripts/deploy_nft.js const hre = require("hardhat");

async function main() {
  const signers = await hre.ethers.getSigners();
  console.log("Deploying contracts with the account:", signers[0].address);

  const instance = await hre.ethers.deployContract("TelegramBot", [
    signers[0].address,
  ]);
  await instance.waitForDeployment();
  console.log(`TelegramBot Contract deployed to ${await instance.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); Deploy it npx hardhat run scripts/deploy_nft.js --network local Save the contract address into file .env ...
NEXT_NFT_ADDRESS=...
... 6. Telegram webhook For local testing, I strongly recommend you to use ngrok 6.1 Preparement. Create with the following content. app/api/telegram/route.ts import { TelegramRequest } from "@/app/types";
import { ok } from "@/app/helpers/ok";

export async function POST(request: Request) {
  const reqData = (await request.json()) as TelegramRequest;
  console.log(reqData);

  return ok();
} app/helpers/ok.ts import { NextResponse } from "next/server";

export function ok() {
  return new NextResponse("Ok", {
    status: 200,
    statusText: "Ok",
    headers: {
      "Content-Type": "text/plain",
    },
  });
} helpers for interact with Telegram: app/helpers/tg.ts const sendMessageUrl = `https://api.telegram.org/bot${process.env.NEXT_TELEGRAM_TOKEN}/sendMessage`;
const fileUrl = `https://api.telegram.org/bot${process.env.NEXT_TELEGRAM_TOKEN}/getFile?file_id=`;
const downloadFileUrl = `https://api.telegram.org/file/bot${process.env.NEXT_TELEGRAM_TOKEN}/`;

export async function sendMessage(chat_id: String | number, message: String) {
  const req = await fetch(sendMessageUrl, {
    method: "POST",
    body: JSON.stringify({
      chat_id: chat_id,
      text: message,
      parse_mode: "markdown",
    }),
    headers: {
      "Content-Type": "application/json",
    },
  });

  const resp = await req.json();

  console.log("sendMessage", resp);

  return resp;
}

export async function getFile(file_id: String) {
  const req = await fetch(`${fileUrl}${file_id}`, {
    method: "GET",
  });

  const resp = await req.json();

  console.log("getFile", resp);

  return resp;
}

export async function downloadFile(file_path: String) {
  const req = await fetch(`${downloadFileUrl}${file_path}`, {
    method: "GET",
  });

  return await req.blob();
} Helpers for interact with IPFS: app/helpers/ipfs.ts export async function uploadFile(
  filename: string,
  data: Blob,
): Promise<{ Name: string; Hash: string; Size: string }> {
  const form = new FormData();
  form.append(filename, data, filename);

  const uploadResponse = await fetch(
    `${process.env.NEXT_IPFS_NODE}api/v0/add?pin=true`,
    {
      method: "POST",
      body: form,
      headers: {
        "accept-type": "application/json",
      },
    },
  );

  const resp = await uploadResponse.json();
  console.log(`upload ${filename} response:`, resp);

  return resp;
} app/types.ts export type TelegramPhotoRequest = {
  file_id: string;
  file_unique_id: string;
  file_size: number;
  width: number;
  height: number;
};

export type TelegramEntityRequest = {
  offset: number;
  length: number;
  type: string;
};

export type TelegramRequest = {
  update_id: number;
  message: {
    message_id: number;
    from: {
      id: number;
      is_bot: boolean;
      first_name: string;
      last_name: string;
      username: string;
      language_code: string;
      is_premium: boolean;
    };
    chat: {
      id: number;
      first_name: string;
      last_name: string;
      username: string;
      type: string;
    };
    date: number;
    text: string;
    photo: TelegramPhotoRequest[] | undefined;
    entities: TelegramEntityRequest[] | undefined;
    caption: string | undefined;
  };
}; Next steps will be in file app/api/telegram/route.ts 6.2 Initialise provider for work with Ethereum network. import { ethers, JsonRpcProvider } from "ethers";
import { TelegramRequest } from "@/app/types";
import { ok } from "@/app/helpers/ok";

export async function POST(request: Request) {
  const reqData = (await request.json()) as TelegramRequest;
  console.log(reqData);

  const provider = new JsonRpcProvider();
  const signer = new ethers.Wallet(
    process.env.NEXT_PRIVATE_KEY as string,
    provider,
  );

  return ok();
} 6.3 Initialise verification contract ...

const verifierAbi =
  require("@/artifacts/contracts/Verification.sol/Verification.json").abi;

export async function POST(request: Request) {
  ... 
  const verifierContract = new ethers.Contract(
    process.env.NEXT_VERIFIER_ADDRESS as string,
    verifierAbi,
    signer,
  );

  return ok();
} 6.4 Check user is registered. We need to make a hash of the user ID to preserve his anonymity. As we already know, the blockchain remembers everything, and it will not be very good for the user if we store in clear form a link between the user’s account and his telegram identifier. ...
import * as crypto from "crypto";
...

export async function POST(request: Request) {

	...

  const hash = crypto
    .createHash("sha256")
    .update(`${process.env.NEXT_SEED}:${reqData.message.from.id}`)
    .digest();

  let address = null;

  try {
    address = await verifierContract.verified("0x" + hash.toString("hex"));
  } catch (e) {
    console.log("address", e);
  }

	if (!address || address === "0x0000000000000000000000000000000000000000") {
	
	}

  return ok();
} 6.5 Registration. If the user is not registered yet, we check the message. If it is the correct address - make registration; otherwise, send a message that we need his address. ...
import { isAddress } from "ethers";
import { ok } from "@/app/helpers/ok";
import { sendMessage } from "@/app/helpers/tg";
...

export async function POST(request: Request) {
  ...

  if (!address || address === "0x0000000000000000000000000000000000000000") {
    if (isAddress(reqData.message.text)) {
      let r = await verifierContract.verify(
        "0x" + hash.toString("hex"),
        reqData.message.text.trim(),
      );
      console.log("resp", r);

      let address = await verifierContract.verified(
        "0x" + hash.toString("hex"),
      );

      const resp = await sendMessage(
        reqData.message.chat.id,
        `${address} registered\n now you can send NFTs`,
      );
      console.log("resp 1", resp);
      return ok();
    }

    const resp = await sendMessage(reqData.message.chat.id, "need authorize");
    console.log("resp 2", resp);
    return ok();
  }

  return ok();
} 6.6 Validate photo. If user doesn’t sent to us a photo, we need to talk about it ...

export async function POST(request: Request) {
  ...

  if (!reqData.message.photo) {
    const resp = await sendMessage(reqData.message.chat.id, `not found photos`);
    console.log("resp validate", resp);
    return ok();
  }
  return ok();
} 6.7 Download photo. If all checks are passed, download the sent photo import { downloadFile, getFile } from "@/app/helpers/tg";

export async function POST(request: Request) {
  ...
  let photo = reqData.message.photo[reqData.message.photo.length - 1];

  let file = await getFile(photo.file_id);
  console.log("file", file);

  let data = await downloadFile(file.result.file_path);

  return ok();
} 6.8 Save to IPFS. ...
import { uploadFile } from "@/app/helpers/ipfs";
...
export async function POST(request: Request) {
  ...
  const respNft = await uploadFile("image", data);
  console.log("respNft", respNft);

  const respMetadata = await uploadFile(
    "metadata.json",
    new Blob(
      [
        JSON.stringify({
          name: reqData.message.caption,
          image: `ipfs://${respNft.Hash}`,
        }),
      ],
      { type: "application/json" },
    ),
  );

  return ok();
} 6.9 mint users NFT. After we save all data into IPFS, we can mint NFT. const nftAbi =
  require("@/artifacts/contracts/TelegramBot.sol/TelegramBot.json").abi;

export async function POST(request: Request) {
  ...

  const nftContract = new ethers.Contract(
    process.env.NEXT_NFT_ADDRESS as string,
    nftAbi,
    signer,
  );

  const mint = await nftContract.safeMint(
    address,
    `ipfs://${respMetadata.Hash}`,
  );

  console.log("mint", mint);

  const respMint = await sendMessage(
    reqData.message.chat.id,
    `tx hash: ${mint.tx_hash}`,
  );
  console.log("resp mint", respMint);

  return ok();
} Done =) 7. Conclusion This is the simplest possible implementation, which has some usability problems but is enough to understand the principles of operation. There are plans to make a web version using Metamask, which NEXT was used for. I tried not to use libraries to communicate with Telegram and IPFS so that there would be more understanding of how it works and you can install the library very quickly. I hope this will be enough to understand the principles of operation. The source code is on . GitHub

Dive into Web3 Contracts with Hardhat and Node.js Vol.3 

I've been writing software for over 20 years, and with every day that goes by I grow more certain that strong static typing is not just a good idea, but also almost always the right choice. There are definitely uses for untyped languages (or language variants), for example, they are much nicer when using a REPL, or for throwaway scripts in environments that are already hopelessly untyped (e.g. the shell). In almost every other case, however, strong typing is strongly preferred. There are advantages to not using types, such as a faster development speed, but they pale in comparison to all of the advantages. To that, I say: Writing software without types lets you go at full speed. Full speed towards the cliff. The question around strong static typing is simple: would you rather work a bit more and get invariants checked at compile-time (or type-checking time for non-compiled languages), or work a bit less and have them be enforced at runtime, or even worse not enforced even at runtime (JavaScript, I'm looking at you... ). 1 + "2" == 12 Getting errors at runtime is a terrible idea. First, it means that you won't always catch them during development. Second, when you do catch them, it will happen in a customer-facing manner. Yes, tests help, but writing tests for every possible mistyped function parameter is impossible given the endless possibilities. Even if you could, having types is much easier than testing for wrong types. Types lead to fewer bugs Types also offer annotations to code that benefit both humans and machines. Having types is a way to more strictly define the contract between different pieces of code. Consider the following four examples. They all do exactly the same thing just with varying levels of contract definition. // Params: Name (a string) and age (a number).
function birthdayGreeting1(...params) {
    return `${params[0]} is ${params[1]}!`;
}

// Params: Name (a string) and age (a number).
function birthdayGreeting2(name, age) {
    return `${name} is ${age}!`;
}

function birthdayGreeting3(name: string, age: number): string {
    return `${name} is ${age}!`;
} The first one doesn't even define the number of parameters, so it's hard to know what it does without reading the docs. I believe most people will agree the first one is an abomination and wouldn't write code like that. Though it's a very similar idea to typing, it's about defining the contract between the caller and the callee. As for the second and the third, because of the typing, the third will need less documentation. The code is simpler, but admittedly, the advantages are fairly limited. Well, until you actually change this function... In both the second and the third functions, the author assumes that age is a number. So it is absolutely fine to change the code as below: // Params: Name (a string) and age (a number).
function birthdayGreeting2(name, age) {
    return `${name} will turn ${age + 1} next year!`;
}

function birthdayGreeting3(name: string, age: number): string {
    return `${name} will turn ${age + 1} next year!`;
} The problem is that some of the places that use this code accept user input which was collected from an input (so always a string). Which will result in: HTML > birthdayGreeting2("John", "20")
"John will turn 201 next year!" While the typed version will correctly fail to compile because this function excepts age to be a number, not a string. Having the contract between a caller and callee is important for a codebase, so that callers can know when callees change. This is especially important for an open source library, where the callers and the callees are not written by the same group of people. Without this contract it's impossible to know how things change when they do. Types lead to a better development experience Typing can also be used by I s and other development tools to vastly improve the development experience. You get notified as you code if any of your expectations are wrong. This significantly reduces cognitive load. You no longer need to remember the types of all the variables and the function in the context. The compiler will be there with you and tell you when something is wrong. DE This also leads to a very nice additional benefit: easier refactoring. You can trust the compiler to let you know whether a change you make (e.g. the change in our example above) will break assumptions made elsewhere in the code or not. Types also make it much easier to onboard new engineers to a codebase or library: They can follow the type definitions to understand where things are used. It's much easier to tinker with things as changes will trigger a compile error. Let's consider the following changes to our above code: class Person {
  name: string;
  age: number;
}

function birthdayGreeting2(person) {
    return `${person.name} will turn ${person.age + 1} next year!`;
}

function birthdayGreeting3(person: Person): string {
    return `${person.name} will turn ${person.age + 1} next year!`;
}

function main() {
  const person: Person = { name: "Hello", age: 12 };

  birthdayGreeting2(person);

  birthdayGreeting3(person);
} It's very easy to see (or use your IDE to find) all the places where is used. You can see it's initiated in and you can see it's used by . However, in order to know it's used in , you'd need to read the entire codebase. Person main birthdayGreeting3 birthdayGreeting2 The flip side of this is also that when looking at , it's hard to know that it expects a as a parameter. Some of these things can be solved by exhaustive documentation, but: (1) why bother if you can achieve more with types? (2) documentation goes stale, here the code is the documentation. birthdayGreeting2 Person It's very similar to how you wouldn't write code like: // a is a person
function birthdayGreeting2(a) {
    b = a.name;
    c = a.age;
    return `${b} will turn ${c + 1} next year!`;
} You would want to use useful variable names. Typing is the same, it's just variable names on steroids. We encode everything in the type system At Svix we love types. In fact, we try to encode as much information as we possibly can in the type system, so that all of the errors that can be caught at compile time will be caught at compile time; and also to squeeze that extra mileage of developer experience improvements. For example, is a string-based protocol with no inherent typing. We use Redis for caching (among other things). The problem is that all of our nice typing benefits will be lost at the Redis layer, and bugs can happen. Redis Consider the following piece of code: pub struct Person {
    pub id: String,
    pub name: String,
    pub age: u16,
}

pub struct Pet {
    pub id: String,
    pub owner: String,
}


let id = "p123";
let person = Person::new("John", 20);
cache.set(format!("person-{id}"), person);
// ...
let pet: Pet = cache.get(format!("preson-{id}")); There are a couple of bugs in the snippet: There's a typo in the second key name. We are trying to load a person into a pet type. To avoid such issues we do two things at Svix. The first is that we require the key to be of a certain type (not a generic string), and to create this type you need to call a specific fuction. The second thing we do, is force pairing a key to a value. So the above example would look something like: pub struct PersonCacheKey(String);

impl PersonCacheKey {
    fn new(id: &str) -> Self { ... }
}

pub struct Person {
    pub id: String,
    pub name: String,
    pub age: u16,
}

pub struct PetCacheKey;

pub struct Pet {
    pub id: String,
    pub owner: String,
}


let id = "p123";
let person = Person::new(id, "John", 20);
cache.set(PersonCacheKey::new(id), person);
// ...
// Compilation will fail on the next line
let pet: Pet = cache.get(PersonCacheKey::new(id)); This is already much better, and makes it impossible to get either of the previously mentioned bugs. Though we can do even better! Consider the following function: pub fn do_something(id: String) {
    let person: Person = cache.get(PersonCacheKey::new(id));
    // ...
} There are a couple of problems with it. The first is that it's not very clear which it should be for. Is it a person? A pet? It's very easy to accidentally call it with the wrong one, like in the following example: id let pet = ...;
do_something(pet.id); // <-- should be pet.owner! The second is that we are losing the discoverability. It's a bit hard to know that a Pet has a relationship to a Person. So at Svix, we have a special type for each to ensure that there are no mistakes. The adjusted code looks something like: id pub struct PersonId(String);
pub struct PetId(String);

pub struct Person {
    pub id: PersonId,
    pub name: String,
    pub age: u16,
}

pub struct Pet {
    pub id: PetId,
    pub owner: PersonId,
} This is indeed much better than our previous example. There is still one issue. If we accept the s from the API, how do we know that they are valid? All of the pet s in Svix, for example, are prefixed with and are then followed by a Ksuid like so: . id id pet_ pet_25SVqQSCVpGZh5SmuV0A7X0E3rw We want to be able to tell our customers that they pass the wrong in the API, e.g. they pass a person when a pet one is expected. One simple solution for this is to validate this (duh...) but it can be easy to forget to validate it everywhere that it's used. id id So we enforce that a can never be created without first being validated. This way we know that all of the code paths that create a first make sure it's valid. This means that when we return a to a customer because a pet isn't found in the database, we can be sure it was actually a valid that wasn't found in the database. If it wasn't a valid , we would have already returned a or when it was passed to the API handlers. PetId PetId 404 Not Found id id 422 400 So why doesn't everyone like types? The main topic of argument against types are: Development speed Learning curve and types complexity The amount of effort and boilerplate required First of all, I'd argue that even if all of the above were true, the advantages mentioned above are well worth the trouble. However, I also don't agree with all of the above. The first one is development speed. Prototyping without types is definitely much faster. You can comment out pieces of the code and won't have a compiler complain to you. You can set the wrong values for some of the fields until you're ready to figure out the right ones, etc. Though like I said above: "Writing software without types lets you go at full speed. Full speed towards the cliff." The problem is that this is just aggressive and unnecessary technical debt. You'll pay it multiple times over when you need to debug why your code doesn't work (either locally, in the test suite, or in production). As for the learning curve: Yes, learning more things takes time. However, I'd say that most people don't need to be typing experts. They can just get by with very simple type expressions, and ask if they ever hit a wall. However, if you keep things simple, you'll probably rarely if ever hit one. Additionally, people are already required to learn how to code, learn frameworks (React, Axum, etc.), and so many other things. I don't think the learning burden is as significant as it's made out to be. Last, but not least, regarding the learning curve: I strongly believe that the benefits of a lessened learning curve by not having to know types, are much less than the benefits of using the type script to onboard on a specific codebase. Especially since learning types is a one time cost. The last point is about the amount of effort and boilerplate required to use types in your codebase. I strongly believe that the amount of effort is actually less than the amount of effort required by not writing types. Not using types requires significant documentation and testing in order to reach even a basic level of sanity. Documentation can go stale, and so can testing; and either way they require more effort than just adding the right types. Reading code with types is also easier, because you get the types inline instead of in the function documentation where it's in an inconsistent format with a lot of added noise. Yes, typing can be a pain in languages that don't support inference, e.g Java can be tedious: It seems that Java has type inference nowadays. Thanks for . Edit: pron the correction on HN Person person1 = newPerson();
Person person2 = newPerson();
Person child = makeChild(person1, person2); while other languages that have inference (like Rust), are much nicer: let person1 = new_person();
let person2 = new_person();
let child = make_child(person1, person2); So having the right tools definitely helps. Speaking of tools, in order to reap the benefits of your typing, you probably need to use a code editor (or IDE) that supports modern code completion that is language-aware. Closing words I can see both side of the arguments on many topics, such as vs. , tabs vs. spaces, and even much more controversial ones. However, in this case, the costs are so low compared to the benefits that I just don't understand why anyone would ever choose not to use types. vim emacs I'd love to know what I'm missing, but until then: Strong typing is a hill I'm willing to die on. Also published here. For more content like this, make sure to follow us on , or for the latest updates for the Svix webhook service, or join the discussion on . Twitter Github RSS our community Slack

Strong Static Typing Is Almost Always the Right Choice

Right now, in this world, there is a young startup entrepreneur out there. They are sitting up at their desk during a late-night coding session, They have one question on their mind: “What service should I use for my apps xxx?” It could be the question of a database service, messaging service, proxy service even security service. Whichever option, they are thinking of purchasing a service for their web-based startup app during their MVP (Most Valued Product) planning and development stages. You know what? It is not just them. Right now, there’s a project manager of a Fortune 500 tech company out there. Staying up late thinking the same thing as the young developer. The only exception being it’s to support their already massive tech base and not a new one. There’s also someone who isn’t part of any startup or company and is simply experimenting and learning programming for the first time. They are all contemplating what services to pay for and use for their experiments and growth. What are these services called? Why does everyone seemingly use them? They are called SaaS and they’re everywhere. What is Saas? SaaS is an abbreviation of Software-as-a-Service. “ ”. This is an effective description given by TechTarget.com .In simpler terms, Saas is when you the end user, pay to rent software solutions. Saas is a software distribution model in which a cloud provider hosts applications and makes them available to end users over the internet. E.g: An independent software vendor (ISV) may contract a third-party cloud provider to host the application What is Iaas? IaaS is an abbreviation of Infrastructure-as-a-Service. “ ”. This is an excellent explanation provided by the company. Infrastructure-as-a-Service, commonly referred to as simply <IaaS> is a form of cloud computing that delivers fundamental computer, network and storage resources to consumers on-demand, over the internet, and on a pay-as-you-go basis IBM To some reading this it might be strange. Doesn’t IaaS seem very similar to Saas? the answer to this is YES! SaaS generalizes to all third-party services which you subscribe to through cloud service providers but IaaS is a of SaaS. With IaaS you subscribe for more specific cloud services. To get the type of cloud services meant for the infrastructure and base of an application. Hence, the name “Infrastructure-as-a-Service”. They are renting out to you the actual infrastructure for your web-based product. Paas (Platform-as-a-Service) and IaaS are both subsets of Saas. They are not on their own. SUBSET Below is a diagram illustrating this: For the sake of brevity of this article, we will not be discussing PaaS but just SaaS and IaaS with a focus on IaaS. IaaS is a type of SaaS. We can see from the diagram above the overall structure of this dynamic. IaaS is very specified to offering the core Infrastructure products that a web-based application will need. Although they also do count as a SaaS people do not usually associate SaaS with IaaS. This is because SaaS is mainly in reference to ready-to-use web application services and not the actual infrastructure like IaaS. The relevance of IaaS can be measured in its industry revenue over time and its use audience flexibility. IaaS is fueling the tech world: You might ask yourself, “How is IaaS fueling the tech world? How is it effective for revenue and long-term usage?” Let’s get down to it. IaaS services by the different IaaS providers are conquering their niche field and monopolizing the tech area. As a result of this monopolization of the market, they can drive innovation and output of their services, reaching more and more tech people and companies in need of IaaS services. In 2021 the top 5 IaaS services grew 41.4% in revenue. This means that divided among those five, they made 91 Billion USD which is a 27 Billion USD jump from their 64 Billion USD profit in 2020 as . The amount of revenue in this tech niche is increasing greatly year by year. As such its influence also increases. reported by Gartner.com In 2022 a study found that 63% of technical professionals or business professionals (from a pool of 750 subjects) “heavily” use the cloud systems offered by IaaS services. This is an increase from 59% in 2021 and in 2021 it was an increase of 53% from 2020, this was presented . 50% a year growth among old and new tech professionals in different areas of tech? That suggests a heavy variety of uses in different tech fields as well. by aag-it.com Those are but a few examples of IaaS and its growth. Which companies are most notable in their IaaS products? Microsoft Google IONOS Alibaba Huawei I will not state the above companies’ revenue collection over the last few years in the IaaS field as we should not compare them, however, one should keep in mind each one is leading in this field and is progressively getting better. That said, let’s use three of the companies as examples and showcase their leading IaaS solutions. This isn’t revenue comparison as much as showcasing just how valuable and relevant IaaS-based solutions are. Google Cloud: By now most people in tech have most definitely heard of Google Cloud by contact with their products. Google’s IaaS services include Google Cloud Storage and Google Compute Engine. Google Cloud Storage: “Cloud Storage is a managed service for storing unstructured data. Store any amount of data and retrieve it as often as you like.” This definition was given In other words, what does this mean? It means that you as an organization/company can treat Google Cloud Storage like your own data center. by Google. Google Compute Engine: “Compute Engine is a customizable compute service that lets you create and run virtual machines on Google’s infrastructure”. This definition was given . Virtual machines are exactly what they sound like. A computer that uses software to mimic a computer and its properties to run programs and deploy apps. For more on virtual machines check . by Google here IONOS Cloud Cubes: To put it simply, is a web hosting and cloud services partner for small and medium-sized businesses. They exclusively offer and specialize in IaaS solutions. IONOS IONOS Cloud Cubes: What are ? They sound complex but simply they are enterprise-grade virtual private servers for businesses. They offer a range of services in the private server space such as; Scalable environments to meet specific software needs, automated instance configurations, and even the ability to run your private cloud cube (server) on a virtual machine. They offer all this and more, as a small to medium-sized company trying to continually scale IONOS is not one to forget. IONOS cloud cubes Microsoft Azure: Microsoft might be mentioned last but not by a stretch does this mean they are the least. Microsoft Azure is part of the Microsoft company which offers . Two products they offer in their IaaS range are Azure Networking and Azure Security. IaaS products Azure Networking: Azure networking has a whole range of sub-products for maximum affordability and necessity for clients. However, they are still all under Azure Networking and features include; Automated load balancing, automated Traffic management to the server, privatized WAN portal, internet traffic routing options, a singular delivery point for global micro-service applications even when running concurrently, etc. For a full list . check here Azure Security: . They are also offered in IaaS. One may ask “Aren’t online security services of all types SaaS?”. Yes, usually, this is true, but remember IaaS are SaaS products but just in a specific niche. In this case, Azure security is specified to an IaaS, why? Azure has made their security features built into their infrastructure and is not necessarily a stand-alone product of its own. IaaS solutions are not just related to storage, hosting or even networking Similar to Azure Networking, Azure Security breaks up the service into tiny bits for more specified options for corporate partners. However, they all still fall under Azure Security. Some of the services included in Azure Security are; the making and storage of crypto-graphically verified tamper-proof ledger, DDoS protection, Cryptographic key vault, built-in web application firewall, email protection, and security management unification for cloud and on-premise protection. IaaS Dominance: The SaaS market globally is growing as a whole. even valued the global SaaS market as a giant 240 Billion USD in 2022. also stated 108 Billion USD was directly from IaaS products in 2022. That is close to half of the total profits of SaaS products and types in 2022. With such a strong growth rate of 14-22% per year (different sources give different growth rates) how can one deny strength in IaaS products? Forbes Business Insight Forbes Business Insight Earlier on in the article, we specified that IaaS is best for companies and not necessarily best for individuals. This is because individuals and very fresh startups are better off buying full SaaS products. Startups and individuals usually have no money to work with or time. They cannot be like medium-sized companies or established small startups who can afford to “splurge” on their own custom application make-up and functions. It is more time effective and cost-efficient to focus on innovating the product and have another company do the grunt work. If you’re an established startup, medium enterprise, or large enterprise then IaaS services are realistic options. If not? Stick to full-on SaaS products and not a SaaS niche like IaaS. Keeping the previous paragraph in mind. It is no secret that IaaS products are widely dominated by some of the biggest tech companies in the world such as Amazon, Google, Microsoft, Huawei etc. Some of these companies are even in the process of monopolizing the IaaS industry further and further. This may act as a deterrent for developers and small-medium businesses. It should not be. Yes, the industry is becoming monopolized, however, this does not mean you cannot enter another niche in the IaaS world or leverage your company to effectively use IaaS products as much as possible to boost your revenue. Innovation is happening within IaaS products and it is growing and strengthening with time. IaaS solutions are the best subset of SaaS, and you know what? the growth we have seen in the last 5 years of its infancy is only the start of innovative cloud service solutions. To know more about me or to get in contact, . find me here

IaaS, the Niche SaaS Power

Digital marketing in Africa might not have started in the days of , but the continent is slowly catching up to the rest of the world. The of email technology by Ray Samuel Tomlison in 1971 helped form the concept of digital marketing today. Ray Samuel Tomlison discovery The coronavirus (COVID-19) pandemic the digital transformation of African businesses. During the pandemic, businesses resorted to using digital marketing to reach out to potential customers, a trend that has been consistent for years now. accelerated This article will serve as a guide to anyone who intends to start a project in, or targeting, Africa. ? What is Digital Marketing Digital marketing is the leveraging of digital channels on the internet for marketing processes. It's simply the promotion of brands to connect with potential customers using the internet and other forms of . digital media Is television a digital marketing channel? Over the years, digital marketers about television being a digital marketing channel. If it was five years back, it would have been difficult to answer that question, but the types of television (smart TVs), and other forms of electronic devices being created today expands digital marketing beyond just online marketing on mobile phones, and computers. The answer to the above question is yes, television is a digital marketing channel. argue Television Ads in Africa Businesses in Africa take pride in running tv campaigns. Companies spend millions, just to get their products and services featured on popular tv programs on the continent. Television remains the market leader when it comes to advertising in Africa. South Africa’s TV advertisement spending alone amounted to in 2021; by 2025, it’s expected to reach $549 million. Nigeria and Morocco’s advertisement expenditure is also forecasted to grow from $197 million to $231 million in the same period. $436 million The growth of the internet in Africa has triggered competition between Television and other media channels. It’s only a matter of time before the gap is closed. Television is the holy grail of advertising in Africa Paid Media In Africa The internet is greatly influencing the digital marketing space in Africa. Businesses no longer depend solely on traditional marketing for advertising. According to the interactive advertising bureau (IAB) on South Africa, the internet revenue generated in 2021, is worth R12.1 billion ($710- million). Paid search grew from 16.8% to 20.4% in 2021, and it is expected to increase further in 2022. reports Influencer Marketing In Africa The entertainment industry in Africa is starting to gain and acceptance. Brands are taking advantage of the current spotlight to gain access to the massive followership of influencers. Some recent notable events are ambassadorial deal with and deal with , a peer-to-peer cross-border payment company in Africa and Europe. global recognition Maison Martel's Davido Blacksheriff’s Chipper Cash Influencer marketing is very effective in Africa. Through influencer marketing, businesses are guaranteed maximum exposure for their products and services. Mobile Marketing In Africa Africa is indeed a “mobile first region”. The rise of increasingly affordable mobile devices, combined with flexible payment options has been a driving force behind the increase in mobile adoption in Africa. Businesses leverage this advantage to reach potential customers through targeted mobile ads.  It is that 51% of the total ad spending will be generated through mobile in 2027. projected Social Media Marketing In Africa The growth of the internet in Africa has influenced the continuous rise in social media usage. The number of African social media users amounts to over , and drives this market in Africa. Meta to the growth of the internet in Africa, and it’s believed that the company is “reaping its benefits” as its products are the in the continent. 384 million Meta contributed most used The covid-19 pandemic also helped change people's perspectives on businesses being conducted online in the continent. It has triggered new buying trends with social media, making it a hub for businesses to acquire new customers. . Digital Marketing Regulations In Africa West African countries maintain for advertising, while in the north and other parts of Africa, digital marketing is heavily influenced by the government. In 2017, the government of Egypt more than 60 websites on allegations of fake news and extremism. global standards censored There are various government agencies that monitor organizations and digital marketing agencies to ensure legal advertisements in Africa. Here are some of them: The Competition Authority of Kenya ( ) CAK Advertising Practitioners Council of Nigeria ( ) APCON Marketing  Association of South Africa ( ) MASA The Advertising Association of Ghana ( ). AAG National Telecommunication Regulatory Authority ( ). NTRA The Future of Digital Marketing In Africa Digital marketing is still a growing industry in Africa. Despite this growth, there are still challenges that will prevent the continent from evolving in this fast-changing digital era. One of the major challenges facing the industry is the low adoption of new technologies. The discovery of technologies like artificial intelligence and the metaverse will influence the global digital marketing space. Industry giants (Google and Meta) are already leveraging this technology to better user experience, but will the African market keep up? Underdeveloped technology is still a worrying concern in Africa. Businesses and digital agencies will prefer to do things the old way, either because of the technical know-how, or poor infrastructural development. Despite all these, digital marketing is still having a "bull run" in the continent. Digital ad spending is expected to reach $3.19bn this year, and the sub-saharan region remains the driving force behind that growth. As we continue to witness the growth of the internet in Africa, the continent will continue to experience tremendous growth through its digital economy and the digital marketing industry will be a major driver of that growth.

Stories, News & Mentions about AAG

Aag’s Stories on HackerNoon