We believe every author should have an equal opportunity to succeed. Therefore, our mission is to discover hidden talents and turn them into globally successful authors. Inkitt is a pioneer at the forefront of Data Driven Publishing. Using an analytic and objective approach, we’ve discovered hundreds of talented authors around the world with over 50% of our published authors achieving $100,000+ in sales. We have forever changed the traditional publishing model by inventing an algorithm which analyzes users' reading behavior to identify hits, in turn removing subjectivity from the equation. This gives Inkitt the unique ability to discover hidden talents that might otherwise have gone unnoticed. Hits that are identified by our algorithm, are then licensed to and distributed on our Galatea app where we systematically generate blockbusters by A/B testing the content of our stories. This process is our own unique creation, and something which has never before been done in the entertainment industry. At present, we are an international team of 85 passionate and dedicated inventors and entrepreneurs and we are growing quickly. We are proud that our mission has persuaded early investors in Google and Spotify to back us, as well as attracted talents from Netflix, Activision Blizzard, DeliveryHero, Babbel, and N26 to join us. We invent new solutions to problems we encounter, as opposed to simply iterating upon existing solutions. Join us to build the Disney of the 21st Century! FT1000: #8 Fastest-Growing Company in Europe 2023

Inkitt

Before the invention of the printing press, most of the world existed in an information vacuum. News primarily relied on human narrators, and it could take many days, months, and even years until the latest information was delivered to remote towns and villages. But of course, by that time, it was no longer “the latest.” The situation changed when a German goldsmith Johannes Gutenberg came up with . He wasn’t the first to come up with the idea–the first movable type printing had been used in Asia hundreds of years earlier. But Gutenberg’s invention had an advantage thanks to the proximity to major shipping hubs of that time. Particularly Venice. a movable type printing press in 1436 Why and How the Printing Press Changed the Game In the 15th century, Venice was one of the driving forces of and the central shipping hub of the Mediterranean. Local printers sold four-page news pamphlets to sailors, who would take them to distant parts of the world, where they were copied and delivered to even more distant villages, where people would read them in public. the Italian Renaissance Several factors made the printing press such a great invention–cost-efficiency, time to produce, and freedom of church monopoly on books. Before the printing press, the church was the only book-making authority that provided scribes, materials, and distribution networks. Making a book was a costly process that involved long hours and multiple people working just on a single copy of a book. So it’s no wonder books were a luxury only few could afford, and libraries were something one could see only in a big monastery or on royal premises. Gutenberg’s invention allowed bookmakers to cut the cost and time of book production from months to days–the first print-run of the Bible, for example, required around one month to make five copies–unimaginable speed for that time. As a result, books became more affordable, making their way to libraries of medium-sized towns and private collections, contributing to the information exchange and literacy of the general population. And because bookmaking was no longer under the control of the church, more authors were able to reach their readers, preparing the revolution in science, religion, philosophy, politics, and entertainment. Are We About To See the Next Printing Press? Now, some five hundred years after the invention of the printing press, it feels like we’re standing at the door of another technological revolution that might radically change the information exchange. However, the world we live in is more complex and advanced than the one Gutenberg lived and worked in. Advancements in AI, blockchain and the entertainment world will probably play a significant role in the next iteration of publishing (the last one being book publishers adopting digital format). There are many factors at play, and trying to predict where the next revolution in publishing will come from is difficult. However, several trends can define the future of publishing, becoming the next “printing press.” These trends are social media, AI-assisted writing, data-driven publishing, and crypto content creation. Is Social Media the Next Printing Press? There is no doubt that social media has changed how information is exchanged and published. In the same way, as the printing press put an end to the church’s monopoly on knowledge sharing, social media has eliminated the go-between from the publishing process, making it possible for every voice to be heard. Thanks to the widespread use of mobile devices and the Internet, (with Facebook, Twitter, YouTube, Snapchat, and Instagram topping the list) instead of traditional media. They democratized the publishing process and made it possible to share information with billions of people in just a couple of clicks. social media has become the primary source of news online Social media comes at a cost, however. From privacy issues to unprecedented levels of to to , social media companies receive heavy criticism, making many people quit them altogether. But despite all the negativity, they still provide a powerful platform for people to connect and share important news and information. misinformation online rage information overload Social media are on their rise now, and they will develop, favoring faster and simpler sharing mechanisms, involving more and more people into the never-ending circle of content creation. So, it is very likely that they earn the “Next Printing Press” badge or play a crucial role in its making. Are AI Writing Assistants the Next Printing Press? have introduced the world to various technologies that automate many mechanic tasks. From image recognition and classification to , machine learning algorithms reduce human labor and human error, reducing the cost in the long run. Rapid changes in artificial intelligence research abusive language detection One of the most groundbreaking products involving deep learning and natural language processing is , presented in spring 2020. Trained on more than 175 billion parameters, GPT-3 is the most prominent language model to date capable of generating texts that are indistinguishable from human-written copy. GPT-3 Many companies offer access to the GPT-3 engine through that, employing the engine’s API, generate texts on a given topic for a given domain. Using AI writing assistants can drastically reduce the time from the idea to publishing, thus providing an edge to its users over competitors who don’t use this technology. writing assistants The output generated by AI writing tools is still not perfect and heavily depends on the quality of user input. Besides, these tools are pretty bad when it comes to fact-checking. So, perhaps, in the next couple of years, the technology will most likely be used by copyeditors whose texts are not fact-heavy. Regardless, AI writing assistants will shape the publishing industry’s future in the coming years because they offer incredible value to authors (e.g., removing writer’s block and generating ideas) for a reasonable price, which is likely to go down. Is Data-Driven Publishing the Next Printing Press? Just like many content creation companies opt-in for AI writing assistants, more and more publishing companies are starting to explore the concept of . The main difference between data-driven publishing and AI writing assistants is that while the latter aims to automate the entire process, the former focuses on reaching the optimal message to the audience. data-driven publishing (DDP) At its core, data-driven publishing is concerned with a better understanding of how readers interact with the stories they read. For example, where readers spend the most time, which text snippets they share with friends, or how far they go before giving up on a book. Attaching readers’ stats to each published piece, be it an article or a novel, may help publishers adapt their content marketing strategies and uncover the hidden gems and the next best-selling authors. Some companies, like , already use machine learning methods to find the potential bestsellers in a pool of pre-published novels that everyone can read. Books that receive the highest engagement from the readers in the reading app get published and marketed. Medium, an online publishing platform, employs a similar approach recommending stories with the highest reader engagement to other readers, helping writers gain a following and earn income. Inkitt Perhaps, the most significant difference between AI writing assistants and data-driven publishing is that DDP offers real value to the readers, allowing them to see more high-quality content and less low-quality content. This may not revolutionize the way we consume stories, but it can change the game for many creators who could not find their readers via traditional publishers. Is Crypto Content Creation the Next Printing Press? Blockchain and cryptocurrency are on the rise. The hype around and is at its highest, and it doesn’t look like it will go away any time soon, especially given recent speculation about . , and Jack Dorsey, a former Twitter CEO, . NFTs Web 3.0 Metaverse Elon Musk has already called Web3 a “bs” expressed his concerns that Web3 will be under the control of the VC industry Both Musk and Dorsey may be right. But it doesn’t mean that the changes the next iteration of the Web will bring won’t offer any value. We have already seen how independent (and well-known) artists , and many believe that NFTs will change the way we produce, share, and profit from art forever. profited from NFTs The same way artists get recognition for their work and receive royalty fees every time their art is sold, indie authors and small publishers could benefit from NFTs by fingerprinting their work, crowdsourcing the patronage, and removing an intermediary from the publication process. One example of such an approach to content sharing is , aiming to change the way authors connect with their audience. The platform built on Ethereum has already received and is now open to everyone this year. Mirror allows authors to create original content and mint it as an NFT that later can be sold. Mirror investment at a $100 million valuation It is still early to say how exactly Web3 and crypto content creation will change publishing. However, some indie authors and small publishers will likely benefit from it. In any case, given the trajectory of blockchain development, we will probably learn more about this recent trend in 2022. How Publishing Will Evolve The printing press did not change the world overnight. It took years for the technology to take over the world and lay a foundation for the publishing industry, which, although changed operationally, hasn’t changed conceptually. The fix is the same: an authority with a printing press decides what this machine will print and where the print-outs will go. The Internet has driven a wedge into this formula, with self-publishing giving a possibility for everyone to find their audience. But these changes cannot cancel the fact that even self-publishing is subject to a middleman’s consent and a fee, be it Amazon or any other online publisher. Blockchain technology development could be the most disruptive trend to change this power dynamic, giving indie authors a platform to take complete control of their content, both in finance and ownership. However, it is unlikely that these changes will render traditional publishing obsolete. When the first e-books appeared, many people thought that paper books would disappear in the next twenty years. Yet, printed books are still there; they just no longer exist in a paper format only. As such, we can expect a mixture of the above-listed trends from future publishing, with both traditional and indie publishers co-existing in shared Internet space, be it Metaverse, cyberspace, or Web3, and using as many tools for promoting their work as possible. This will include social media, data-driven publishing, AI assistants, and blockchain backing. So, in this sense, the next printing press will most likely be a combination of several trends and technologies. And even though we can’t say for sure how exactly the publishing industry will look like in twenty years, one thing is certain–it will be damn complicated.

What is The Next Printing Press?

My second hackathon was on the Flow chain. You might ask why I specifically chose Flow and not any other hackathon. The answer is quite simple. I was part of the community from the very beginning; during the ICO, when I first heard about the project, and invested in Flow at 60 cents per coin. It was a good deal, especially when Flow’s cost rose up to $40 per coin. At that time, all the coins were locked, making it impossible for ICO investors to sell any. I was only able to sell them at $17, which, in my opinion, was great. Since then, I’ve actively followed the community. I wanted to participate in Hackathon season 1 but was busy with several other projects. So, when I heard about the upcoming hackathon season 2, I was very excited to participate in it with my idea for a charity that had been sitting in my mind for a long time. Before diving any deeper, you can try the project yourself by visiting https://prayforua.com Flow: Cadence, FCL Official Guide Since it was my first time working with the Flow ecosystem, I decided to use the official guide to learn Cadence and , which we will talk about later. FCL - Flow Client Library The official guide helped me understand Cadence better, guiding me through the most common use cases. Although very useful, I found it a bit verbose, with many articles written so that readers could jump in at any point. This led to repetition and made it seem clunky. Other than that, it took me around 6-8 hours to finish, leading to a basic understanding of the language principles and architecture of blockchain projects using the Flow ecosystem. Both Cadence and FCL were developed by DapperLabs, providing a consistent developer experience. Their API also seemed mature to me, even tho It’s a new language and API might change in the future, covering almost everything a developer might need, it might ever work for an enterprise-sized project. My project was smaller, but it still required a lot of smart contracts, I’ll describe that in the Architecture section. Cadence Compared to Other Languages For those who don’t know, Cadence is a new programming language for smart contracts written by Dapper Labs. I was very curious to try Cadence, having heard about this language some time ago, with its resource-oriented nature akin to . I also wanted to compare it with the well-established Solidity that I’ve used. Rust Resource-Oriented Nature One of the standout features of Cadence is its resource-oriented nature, drawing parallels with the programming language Rust. Rust gained prominence for its efficient resource allocation mechanism, centered around borrowing and lending. Similarly, Cadence employs a similar principle: resources can exist in only one location at a time. This fundamental concept guarantees resource safety, particularly for tokens and other critical resources within the smart contract ecosystem. This design choice not only enhances security but also contributes to the predictability and reliability of smart contracts. Enhanced Security Cadence’s resource-oriented approach inherently addresses some of the security concerns that plagued Solidity-based contracts. By preventing resource duplication and enforcing strict ownership rules, Cadence minimizes the potential for vulnerabilities such as reentrancy attacks and unauthorized token transfers. This focus on security aligns with Dapper Lab’s vision of providing a robust platform for building decentralized applications without compromising on safety. On the other hand, Solidity’s design allowed for pitfalls such as reentrancy attacks, which posed a significant security threat. My Hackathon Project Let’s briefly examine the app architecture and the main concept of my hackathon project. Tooling For my own projects, Svelte is a no-brainer, so: for speed. pnmp as js framework. Svelte as an application framework. (For those unfamiliar with SvelteKit, you might think of it as similar to Next.js) SvelteKit - For quick prototyping. (TailwindCSS for styles and the Tailwind library of mixed styles DaisyUI for even more styles on top of tailwind shugar for basic components like buttons, ranges, etc.) TailwindCSS/DaisyUI //package.json
{
...,
"devDependencies": {
"@sveltejs/adapter-vercel": "^3.0.2",
"@sveltejs/kit": "^1.22.1",
"autoprefixer": "^10.4.14",
"daisyui": "^3.1.11",
"eslint": "^8.44.0",
"eslint-config-prettier": "^8.8.0",
"eslint-plugin-svelte": "^2.32.2",
"postcss": "^8.4.25",
"prettier": "^3.0.0",
"prettier-plugin-svelte": "^2.10.1",
"svelte": "^4.0.5",
"tailwindcss": "^3.3.2",
"vite": "^4.4.2"
},
"dependencies": {
"@onflow/fcl": "^1.4.1",
"firebase": "^10.0.0",
"nanoid": "^4.0.2",
"ramda": "^0.29.0"
}
} As you can see, I’m using 4 client libs: fcl - flow client api firebase - my user data storage solution + db real-time updates onSnapshot nanoid - gen random id ramda - like lodash, but functional style library of utilities (Ramda helped take advantage of utility functions like pipe, combine, etc.) Because Svelte is a in the first place, there is no real difference between devDependencies and dependencies, but I’m adding client libs as dependencies for the sake of concept separation, so it’s easier to read. compiler Svelte store firebase simplified implementation You might want to see simple svelte store firebase api wrapper with localStorage sync import {getFirestore, doc, setDoc, getDoc} from 'firebase/firestore';
import {initializeApp} from 'firebase/app';
import {writable} from 'svelte/store';
import {browser} from '$app/environment';
import {firebaseKeys} from '$lib/firebase/config';

const initialState = {};

function createDb(key) {
  const initialValue =
    browser && localStorage.getItem(key)
      ? JSON.parse(localStorage.getItem(key))
      : initialState;

  const {subscribe, set, update} = writable(initialValue);
  const ini = initializeApp(firebaseKeys);
  const db = getFirestore(ini);

  return {
    set,
    update,
    subscribe,
    getDbRef: () => db,
    getDoc: async (path, id) => {
      const docRef = doc(db, path, id);
      return await getDoc(docRef);
    },
    setDoc: async (path, id, payload) => {
      try {
        const docRef = doc(db, path, id);
        await setDoc(docRef, {...payload}, {merge: true});
        console.warn('Document added to Firestore:', document);
      } catch (error) {
        console.error('Error adding document to Firestore:', error);
      }
    },
    useLocalStorage: () => {
      subscribe((current) => {
        if (browser) {
          localStorage.setItem(key, JSON.stringify(current));
        }
      });
    }
  };
}

export const db = createDb('app-db'); I wrote this wrapper to simplify the usage of Firebase API across the app. The might look a bit complex, but the logic is similar to zustand. Project store Svelte and cadence integration One aspect I love the most is the ability to integrate smart contract transactions and scripts using FCL, very handy for creating a serverless app. For example, transfering tokens be like: ...
export const transferFlow = async (amount, addr, cid) => {
  let transactionId = false;
  initTransactionState();

  try {
    transactionId = await fcl.mutate({
      cadence: `
        import FungibleToken from 0x9a0766d93b6608b7
        import FlowToken from 0x7e60df042a9c0868

        transaction(amount: UFix64, to: Address) {

           // The Vault resource that holds the tokens that are being transferred
           let sentVault: @FungibleToken.Vault

           prepare(signer: AuthAccount) {

               // Get a reference to the signer's stored vault
               let vaultRef = signer.borrow<&FlowToken.Vault>(from: /storage/flowTokenVault)
            ?? panic("Could not borrow reference to the owner's Vault!")

               // Withdraw tokens from the signer's stored vault
               self.sentVault <- vaultRef.withdraw(amount: amount)
           }

           execute {

               // Get a reference to the recipient's Receiver
               let receiverRef =  getAccount(to)
                   .getCapability(/public/flowTokenReceiver)
                   .borrow<&{FungibleToken.Receiver}>()
                    ?? panic("Could not borrow receiver reference to the recipient's Vault")

               // Deposit the withdrawn tokens in the recipient's receiver
               receiverRef.deposit(from: <-self.sentVault)
           }
        }
      `,
      args: (arg, t) => [arg(amount, t.UFix64), arg(addr, t.Address)],
      payer: fcl.authz,
      proposer: fcl.authz,
      authorizations: [fcl.authz],
      limit: 50
    });

    // store method
    txId.set(transactionId);

    // subscribe to svelte transactions
    fcl.tx(transactionId).subscribe((res) => {
      transactionStatus.set(res.status);
      if (res.status) {
        if (res.status === 4) {
          getAccountBalance(addr, cid);
          auth.addFlowTransaction({
            txId: transactionId,
            event: `${amount} Flow transferred to ${addr} at`,
            status: res.status,
            timestamp: new Date().getTime()
          });
          setTimeout(() => transactionInProgress.set(false), 2000);
        }
      }
    });
  } catch (e) {
    transactionStatus.set(99);
    console.warn(e);
  }
};
... Here method receiving an object with key and value will be valid cadence code, and this way you can write transactions and scripts easily from your js files. See more examples of flc actions in github. fcl.mutate cadence Conclusion Even tho I didn’t win, the Flow ecosystem fullstack development was an interesting experience. It seems more concise and simplified to work with when compared to the Ethereum ecosystem, which is not bad at all but I definitely like cadence more than solidity. However, to be fair, the last time I used the Solidity ecosystem was more than three years ago, so things might have changed, although I doubt it. 🥲 Outro I appreciate your engagement thus far. 🙏 Whether you’re a startup or an established enterprise, I’m here to help you build and enhance your digital products by offering my services. You can reach me by email at or find more contact information at glazer.nicholas@gmail.com https://nicholasglazer.com/man/ng Also published here.

My Journey With Flow: From ICO to Blockchain Hackathon Season 2

The following tutorial builds upon the Startup Name Generator app outlined in the tutorial on . If you haven’t yet, it is recommended to follow that tutorial first. Write your first Flutter app Flutter’s codelab Overview In the base tutorial, we created an app that randomly generates names that could be used for a startup. In this tutorial, we are going to log user selections and add an experiment that will show an Emoji icon as a possible start logo in the hopes that this will drive user engagement. To do this, we will be using Statsig via the . Statsig Dart SDK Installing Statsig First off, we will need to add the Statsig SDK to our app. In a terminal window, run the following: flutter pub add statsig This will install the latest version of the SDK. Initializing the SDK Statsig requires an async call that hits the network to fetch all the values for the given user. This async call must be completed before checking any gates or experiments. There are a number of places we could put this call (See ), but we’ll just stick it in an async main function. Flutter async void main() async { // <- added async
  final user = StatsigUser(userId: "a-user");
  final options = StatsigOptions(initTimeout: 1);
  await Statsig.initialize("client-xxxx", user, options);
  runApp(const MyApp());
} Now when our app is launched, Statsig will make a network call and fetch all the values for our given user. Logging the Event To drive user engagement, we must first have some way of measuring an engaged user. This could be a metric that counts how long a user spends in the app or the number of times a user returns to the app. In this tutorial, we are going to opt for a simple event to fire when the user engages by selecting a startup name from the list. Let’s add an onTap action to be fired whenever a user taps on a ListTile in our ListView: final name = _suggestions[index].asPascalCase; // moved out of title: Text(

return ListTile(
	// -- New
  onTap: () {
    Statsig.logEvent("selected_name", stringValue: name);
  },
	// --
  title: Text(
    name,
    style: _biggerFont,
  ),
  trailing: trailing,
); Now if we run our app, we can select a name from the list, and an event will be fired to Statsig. We can verify this is working in real time by going to our and checking the metrics page. Statsig console Setting up an Experiment Now that we have a metric for an engaged user let’s create an experiment to drive this metric. Let’s update our UI to display the emoji as our startup logo. Similar to how the name suggestions work, we’ll create a list of emojis as strings: class _RandomWordsState extends State<RandomWords> {
  final _suggestions = <WordPair>[];
  final _emojis = <String>[]; // <-- New
	... Then in our build method, we will check the experiment and populate the list. Widget build(BuildContext context) {
    return ListView.builder(
      padding: const EdgeInsets.all(16.0),
      itemBuilder: (context, i) {
        ...

		// -- New
        Text? trailing;
        var emoji = "";
		    var experiment = Statsig.getExperiment("emoji_logos_experiment");
        if (experiment.get("should_display_emojis", false) == true) {
          while (_emojis.length <= i) {
            const minHex = 0x1F300;
            const maxHex = 0x1F3F0;
            var random = (Random().nextInt((maxHex - minHex).abs() + 1) +
                    min(minHex, maxHex))
                .toInt();

            _emojis.add(String.fromCharCode(random));
          }

          emoji = _emojis[i];

          trailing = Text(
            emoji,
            style: _massiveFont,
          );
        }
		// -- 

        final name = _suggestions[index].asPascalCase;

        return ListTile(
          title: Text(
            name,
            style: _biggerFont,
          ),
          trailing: trailing, // <-- New
        );
      },
    );
  } Here is what the experiment setup looks like on the Statsig console. For more information on how to set up an experiment, see Statsig’s . documentation Running the Experiment And that’s it! If we put this code in front of our users, 50% will see the Emojis (Test), and 50% will not (Control). After a few days of running, we should see results from our experiment, hopefully showing that adding emojis increased our “selected_name” metric. The completed tutorial project can be found . here Also published . here

A/B Testing In Flutter With Statsig

Isomorphic TypeScript APIs are a Gamechanger, Blurring the Line Between Client & Server

Welcome to other chapters of Let’s Understand Chrome V8 From the view of implementation: the builtins are implemented by Runtime, Torque (CodeStubAssembler), JavaScript, and ASM. Below is the official description of the V8: V8’s builtins can be implemented using a number of different methods (each with different trade-offs): Platform-dependent assembly language: can be highly efficient, but need manual ports to all platforms and are difficult to maintain. C++: very similar in style to runtime functions and has access to V8’s powerful runtime functionality, but usually not suited to performance-sensitive areas. JavaScript: concise and readable code, access to fast intrinsics, but frequent usage of slow runtime calls, subject to unpredictable performance through type pollution, and subtle issues around (complicated and non-obvious) JS semantics. CodeStubAssembler: provides efficient low-level functionality that is very close to assembly language while remaining platform-independent and preserving readability. What is Runtime? It is a method for implementing V8 builtins. Why is it important? If you understand it means that you know the design and implementation of the quarter of the builtins. In this article, I will talk about the initialization and call of Runtime. By learning them, we will have a comprehensive understanding of the workflow of Runtime. 1. Initialization Runtime is the foundation component of V8, which is initialized during the V8 startup and is managed by the ExternalReferenceTable which is a pointer array for holding external resources. The below Init() is responsible for the initialization of ExternalReferenceTable. 1.   bool Isolate::Init(ReadOnlyDeserializer* read_only_deserializer,
2.                      StartupDeserializer* startup_deserializer) {
3.     TRACE_ISOLATE(init);
4.     const bool create_heap_objects = (read_only_deserializer == nullptr);
5.     // We either have both or neither.
6.     DCHECK_EQ(create_heap_objects, startup_deserializer == nullptr);
7.     base::ElapsedTimer timer;
8.    //omit...........................
9.      handle_scope_implementer_ = new HandleScopeImplementer(this);
10.      load_stub_cache_ = new StubCache(this);
11.      store_stub_cache_ = new StubCache(this);
12.      materialized_object_store_ = new MaterializedObjectStore(this);
13.      regexp_stack_ = new RegExpStack();
14.      regexp_stack_->isolate_ = this;
15.      date_cache_ = new DateCache();
16.      heap_profiler_ = new HeapProfiler(heap());
17.      interpreter_ = new interpreter::Interpreter(this);
18.      compiler_dispatcher_ =
19.          new CompilerDispatcher(this, V8::GetCurrentPlatform(), FLAG_stack_size);
20.      // Enable logging before setting up the heap
21.      logger_->SetUp(this);
22.      {  // NOLINT
23.        ExecutionAccess lock(this);
24.        stack_guard()->InitThread(lock);
25.      }
26.      // SetUp the object heap.
27.      DCHECK(!heap_.HasBeenSetUp());
28.      heap_.SetUp();
29.      ReadOnlyHeap::SetUp(this, read_only_deserializer);
30.      heap_.SetUpSpaces();
31.      isolate_data_.external_reference_table()->Init(this);
32.      //omit...............
33.    } In the above code, lines 10~20 include the initialization of many foundation components, such as Interpreter and compiler_dispatcher. Line 31 is the ExternalReferenceTable that holds Runtime, see below. 1.  void ExternalReferenceTable::Init(Isolate* isolate) {
2.    int index = 0;
3.    // kNullAddress is preserved through serialization/deserialization.
4.    Add(kNullAddress, &index);
5.    AddReferences(isolate, &index);
6.    AddBuiltins(&index);
7.    AddRuntimeFunctions(&index);
8.    AddIsolateAddresses(isolate, &index);
9.    AddAccessors(&index);
10.    AddStubCache(isolate, &index);
11.    AddNativeCodeStatsCounters(isolate, &index);
12.    is_initialized_ = static_cast<uint32_t>(true);
13.    CHECK_EQ(kSize, index);
14.  } In the above code, the 7th line is the initialization of the Runtime AddRuntimeFunctions where is below. 1.  void ExternalReferenceTable::AddRuntimeFunctions(int* index) {
2.    CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
3.                 kBuiltinsReferenceCount,
4.             *index);
5.    static constexpr Runtime::FunctionId runtime_functions[] = {
6.  #define RUNTIME_ENTRY(name, ...) Runtime::k##name,
7.        FOR_EACH_INTRINSIC(RUNTIME_ENTRY)
8.  #undef RUNTIME_ENTRY
9.    };
10.    for (Runtime::FunctionId fId : runtime_functions) {
11.      Add(ExternalReference::Create(fId).address(), index);
12.    }
13.    CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
14.                 kBuiltinsReferenceCount + kRuntimeReferenceCount,
15.             *index);
16.  } The AddRuntimeFunctions has a parameter index. In my V8, there are 468 runtime functions, the first function is at ExternalReferenceTable[index =430], the last one is at ExternalReferenceTable[430+468–1]. As mentioned above, the ExternalReferenceTable is a pointer array, which is not only to hold the Runtime but also other stuff. We will talk about the stuff in the future. Figure 1 is adding a Runtime function into the ExternalReferenceTable and gives you a chance to watch runtime_functions in the local variable window. The 11th line Create() creates an entry according to the Runtime ID and finally stores it into the ExternalReferenceTable, see below. 1.  ExternalReference ExternalReference::Create(Runtime::FunctionId id) {
2.    return Create(Runtime::FunctionForId(id));
3.  }
4.  //separation........................
5.  const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
6.    return &(kIntrinsicFunctions[static_cast<int>(id)]);
7.  }
8.  //separation.......................
9.  ExternalReference ExternalReference::Create(const Runtime::Function* f) {
10.    return ExternalReference(
11.        Redirect(f->entry, BuiltinCallTypeForResultSize(f->result_size)));
12.  } The Create() calls the FunctionForId() to return a kIntrinsicFunctions which is defined in below. #define FUNCTION_ADDR(f) (reinterpret_cast<v8::internal::Address>(f))
#define F(name, number_of_args, result_size)                                  \
  {                                                                           \
    Runtime::k##name, Runtime::RUNTIME, #name, FUNCTION_ADDR(Runtime_##name), \
        number_of_args, result_size                                           \
  }                                                                           \
  ,


#define I(name, number_of_args, result_size)                       \
  {                                                                \
    Runtime::kInline##name, Runtime::INLINE, "_" #name,            \
        FUNCTION_ADDR(Runtime_##name), number_of_args, result_size \
  }                                                                \
  ,

static const Runtime::Function kIntrinsicFunctions[] = {
    FOR_EACH_INTRINSIC(F) FOR_EACH_INLINE_INTRINSIC(I)};

#undef I
#undef F What is the kIntrinsicFunctions? Actually, it is an array in which every element is a 6-tuple. In the below 6-tuple, the first is a unique enum ID, the third is a mnemonic which does not help much, the fourth is the function address, and the last two are parameter counter and return counter. As you see, it is adding the Runtime DebugPrint, namely Initialization. kIntrinsicFunctions []={
  //.....................
  {                                                                           
    Runtime::kDebugPrint, Runtime::RUNTIME, "DebugPrint", (reinterpret_cast<v8::internal::Address>(Runtime_DebugPrint)), 
        1, 1 
  },
  //..................... Let’s look at the ExternalReferenceTable. 1.  class ExternalReferenceTable {
2.   public:
3.    static constexpr int kSpecialReferenceCount = 1;
4.    static constexpr int kExternalReferenceCount =
5.        ExternalReference::kExternalReferenceCount;
6.    static constexpr int kBuiltinsReferenceCount =
7.  #define COUNT_C_BUILTIN(...) +1
8.        BUILTIN_LIST_C(COUNT_C_BUILTIN);
9.  #undef COUNT_C_BUILTIN
10.     static constexpr int kRuntimeReferenceCount =
11.         Runtime::kNumFunctions -
12.         Runtime::kNumInlineFunctions;  // Don't count dupe kInline... functions.
13.     static constexpr int kIsolateAddressReferenceCount = kIsolateAddressCount;
14.     static constexpr int kAccessorReferenceCount =
15.         Accessors::kAccessorInfoCount + Accessors::kAccessorSetterCount;
16.     static constexpr int kStubCacheReferenceCount = 12;
17.     static constexpr int kStatsCountersReferenceCount =
18.   #define SC(...) +1
19.         STATS_COUNTER_NATIVE_CODE_LIST(SC);
20.   #undef SC
21.   //...........omit.........................
22.     ExternalReferenceTable() = default;
23.     void Init(Isolate* isolate);
24.    private:
25.     void Add(Address address, int* index);
26.     void AddReferences(Isolate* isolate, int* index);
27.     void AddBuiltins(int* index);
28.     void AddRuntimeFunctions(int* index);
29.     void AddIsolateAddresses(Isolate* isolate, int* index);
30.     void AddAccessors(int* index);
31.     void AddStubCache(Isolate* isolate, int* index);
32.     Address GetStatsCounterAddress(StatsCounter* counter);
33.     void AddNativeCodeStatsCounters(Isolate* isolate, int* index);
34.     STATIC_ASSERT(sizeof(Address) == kEntrySize);
35.     Address ref_addr_[kSize];
36.     static const char* const ref_name_[kSize];
37.     uint32_t is_initialized_ = 0;
38.     uint32_t dummy_stats_counter_ = 0;
39.     DISALLOW_COPY_AND_ASSIGN(ExternalReferenceTable);
40.   }; Line 7–17 defines all Builtins managed by ExternalReferenceTable, namely all Runtimes. Line 25–35 defines all private methods of ExternalReferenceTable. Take a look at line 35, it’s the array that holds the Runtime address. The Address is ‘using Address = uintptr_t’. Figure 2 gives three important points, first is the function Add(); second, helps you to watch the variable ref_addr_; last is the call stack which can help you to debug this code. 2. Calling Runtime In the last article, I wrote a Runtime function — MyRunctimeFunction, and also described Runtime’s definition. Here, I’ll talk about the CallRuntime which is common usage in bytecodes and which can help you to understand the interaction between bytecode and runtime. 1.   template <class... TArgs>
2.   TNode<Object> CallRuntime(Runtime::FunctionId function,
3.                             SloppyTNode<Object> context, TArgs... args) {
4.     return CallRuntimeImpl(function, context,
5.                            {implicit_cast<SloppyTNode<Object>>(args)...});
6.   }
7.  //.....separation.........................
8.   TNode<Object> CodeAssembler::CallRuntimeImpl(
9.       Runtime::FunctionId function, TNode<Object> context,
10.        std::initializer_list<TNode<Object>> args) {
11.      int result_size = Runtime::FunctionForId(function)->result_size;
12.      TNode<Code> centry =
13.          HeapConstant(CodeFactory::RuntimeCEntry(isolate(), result_size));
14.      return CallRuntimeWithCEntryImpl(function, centry, context, args);
15.    }
16.  //.....separation.........................
17.    TNode<Type> HeapConstant(Handle<Type> object) {
18.        return UncheckedCast<Type>(UntypedHeapConstant(object));
19.      }
20.  //...separation.........................
21.  TNode<Object> CodeAssembler::CallRuntimeWithCEntryImpl(
22.        Runtime::FunctionId function, TNode<Code> centry, TNode<Object> context,
23.        std::initializer_list<TNode<Object>> args) {
24.      constexpr size_t kMaxNumArgs = 6;
25.      DCHECK_GE(kMaxNumArgs, args.size());
26.      int argc = static_cast<int>(args.size());
27         auto call_descriptor = Linkage::GetRuntimeCallDescriptor(zone(), function, argc, Operator::kNoProperties,
                      Runtime::MayAllocate(function) ? CallDescriptor::kNoFlags
                                     : CallDescriptor::kNoAllocate);
28.      for (auto arg : args) inputs.Add(arg);
29.      inputs.Add(ref);
30.      inputs.Add(arity);
31.      inputs.Add(context);
32.      CallPrologue();
33.      Node* return_value =
34.          raw_assembler()->CallN(call_descriptor, inputs.size(), inputs.data());
35.      HandleException(return_value);
36.      CallEpilogue();
37.      return UncheckedCast<Object>(return_value);
38.    } In line 2, the first parameter is FunctionID which is the enum ID motioned above; the second is the current context that will be explained in the future; the last is an args list passed to a specific Runtime function. In CallRuntimeImpl, line 11 takes out the result size where is stored in the kIntrinsicFunctions; line14 calls CallRuntimeWithCEntryImpl. In CallRuntimeWithCEntryImpl, line 26 counts the arguments; line 28–31 adds the arguments and context to the inputs array; line 33 calls the specific Runtime. Sea of Nodes is the prerequisite knowledge if you want to fully understand the principle of CallRuntimeImpl. Note: Debugging CallRuntimeImpl can only be done in the assembly environment, I have some experience and skills but is boring and complicated, if you want to know, plz contact me. Okay, that wraps it up for this share. I’ll see you guys next time, take care! Please reach out to me if you have any issues. : qq9123013 : v8blink@outlook.com WeChat Email

Let’s Understand Chrome V8 — Chapter 16: What is Runtime? Why is it important?

I dare say there are two types of people in this world: people who love Toy Story and people who have not watched it. Well, this is just the opinion of a huge fan of the animation film. When I was a child, I always dreamed of having toys that could move and play with me, like my own Buzz Lightyear. Thanks to a fancy technique called rigging, I can now bring my toys to life, albeit I'm probably too old for them now. What Is Rigging in 3D Animation and Why Do We Need It? Put simply, rigging is a process whereby a skeleton is created for a 3D model to make it move. In other words, rigging creates a set of connected virtual bones that are used to control a 3D model. It paves the way for animation because it enables a model to be deformed, making it moveable, which is the very reason that rigging is necessary for 3D animation. What Is Auto Rigging 3D animation has been adopted by mobile apps in a number of fields (gaming, e-commerce, video, and more), to achieve more realistic animations than 2D. However, this graphic technique has daunted many developers (like me) because rigging, one of its major prerequisites, is difficult and time-consuming for people who are unfamiliar with modeling. Specifically speaking, most high-performing rigging solutions have many requirements. An example of this is that the input model should be in a standard position, seven or eight key skeletal points should be added, as well as inverse kinematics which must be added to the bones, and more. Luckily, there are solutions that can automatically complete rigging, such as the solution from HMS Core 3D Modeling Kit. auto rigging This capability delivers a wholly automated rigging process, requiring just a biped humanoid model that is generated using images taken from a mobile phone camera. After the model is input, auto rigging uses AI algorithms for limb rigging and generates the model skeleton and skin weights (which determine the degree to which a bone can influence a part of the mesh). Then, the capability changes the orientation and position of the skeleton so that the model can perform a range of preset actions, like walking, running, and jumping. Besides, the rigged model can also be moved according to an action generated by using motion capture technology or be imported into major 3D engines for animation. Lower requirements do not compromise rigging accuracy. Auto rigging is built upon hundreds of thousands of 3D model rigging data records. Thanks to some fine-tuned data records, the capability delivers ideal algorithm accuracy and generalization. I know that words alone are no proof, so check out the animated model I've created using the capability. The movement is smooth, making the cute panda move almost like a real one. Now I'd like to show you how I created this model and how I integrated auto rigging into my demo app. Integration Procedure Preparations Before moving on to the real integration work, make necessary preparations, which include: configuring app information in AppGallery Connect, integrating the HMS Core SDK with the app project, which includes Maven repository address configuration, configuring obfuscation scripts, and declaring necessary permissions. Capability Integration Set an access token or API key — which can be found in — during app initialization for app authentication. agconnect-services.json Using the access token: Call to set an access token. This task is required only once during app initialization. setAccessToken ReconstructApplication.getInstance().setAccessToken("your AccessToken"); Using the API key: Call to set an API key. This key does not need to be set again. setApiKey ReconstructApplication.getInstance().setApiKey("your api_key"); The access token is recommended. And if you prefer the API key, it is assigned to the app when it is created in AppGallery Connect. Create a 3D object reconstruction engine and initialize it. Then, create an auto rigging configurator. // Create a 3D object reconstruction engine.
Modeling3dReconstructEngine modeling3dReconstructEngine = Modeling3dReconstructEngine.getInstance(context); 
// Create an auto rigging configurator.
Modeling3dReconstructSetting setting = new Modeling3dReconstructSetting.Factory() 
    // Set the working mode of the engine to PICTURE.
    .setReconstructMode(Modeling3dReconstructConstants.ReconstructMode.PICTURE) 
    // Set the task type to auto rigging.
    .setTaskType(Modeling3dReconstructConstants.TaskType.AUTO_RIGGING) 
    .create(); Create a listener for the result of uploading images of an object. private Modeling3dReconstructUploadListener uploadListener = new Modeling3dReconstructUploadListener() { 
    @Override 
    public void onUploadProgress(String taskId, double progress, Object ext) { 
         // Callback when the upload progress is received.
    } 
    @Override 
    public void onResult(String taskId, Modeling3dReconstructUploadResult result, Object ext) { 
         // Callback when the upload is successful. 
    } 
    @Override 
    public void onError(String taskId, int errorCode, String message) { 
        // Callback when the upload failed.
    } 
}; Use a 3D object reconstruction configurator to initialize the task, set an upload listener for the engine created in step 1, and upload images. // Use the configurator to initialize the task, which should be done in a sub-thread.
Modeling3dReconstructInitResult modeling3dReconstructInitResult = modeling3dReconstructEngine.initTask(setting); 
String taskId = modeling3dReconstructInitResult.getTaskId(); 
// Set an upload listener.
modeling3dReconstructEngine.setReconstructUploadListener(uploadListener); 
// Call the uploadFile API of the 3D object reconstruction engine to upload images.
modeling3dReconstructEngine.uploadFile(taskId, filePath); Query the status of the auto rigging task. // Initialize the task processing class.
Modeling3dReconstructTaskUtils modeling3dReconstructTaskUtils = Modeling3dReconstructTaskUtils.getInstance(context); 
// Call queryTask in a sub-thread to query the task status.
Modeling3dReconstructQueryResult queryResult = modeling3dReconstructTaskUtils.queryTask(taskId); 
// Obtain the task status.
int status = queryResult.getStatus(); Create a listener for the result of the model file download. private Modeling3dReconstructDownloadListener modeling3dReconstructDownloadListener = new Modeling3dReconstructDownloadListener() { 
    @Override 
    public void onDownloadProgress(String taskId, double progress, Object ext) { 
        // Callback when download progress is received.
    }     
    @Override 
    public void onResult(String taskId, Modeling3dReconstructDownloadResult result, Object ext) { 
        // Callback when download is successful.
    } 
    @Override 
    public void onError(String taskId, int errorCode, String message) { 
        // Callback when download failed.
    } 
}; Pass the download listener to the 3D object reconstruction engine, to download the rigged model. // Set download configurations.
Modeling3dReconstructDownloadConfig downloadConfig = new Modeling3dReconstructDownloadConfig.Factory() 
    // Set the model file format to OBJ or glTF.
    .setModelFormat(Modeling3dReconstructConstants.ModelFormat.OBJ) 
    // Set the texture map mode to normal mode or PBR mode.
    .setTextureMode(Modeling3dReconstructConstants.TextureMode.PBR) 
    .create(); 
// Set the download listener.
modeling3dReconstructEngine.setReconstructDownloadListener(modeling3dReconstructDownloadListener); 
// Call downloadModelWithConfig, passing the task ID, path to which the downloaded file will be saved, and download configurations, to download the rigged model.
modeling3dReconstructEngine.downloadModelWithConfig(taskId, fileSavePath, downloadConfig); Where to Use Auto rigging is used in many scenarios, for example: The most direct way of using auto rigging is to create moveable characters in a 3D game. Or, I think we can combine it with AR to create animated models that can appear on the camera display of a mobile device, which will interact with users. Gaming: We can use auto rigging to animate 3D models of popular toys and liven them up with dance moves, voice-overs, and nursery rhymes to create educational videos. These models can be used in educational videos to appeal to kids more. Online education: Anime figurines look rather plain compared to how they behave in animes. To spice up the figurines, we can use auto rigging to animate 3D models that will look more engaging and dynamic. E-commerce: Conclusion 3D animation is widely used in mobile apps because it presents objects in a more fun and interactive way. A key technique for creating great 3D animations is rigging. Conventional rigging requires modeling know-how and expertise, which puts off many amateur modelers. Auto rigging is the perfect solution to this challenge because its full-automated rigging process can produce highly accurate rigged models that can be easily animated using major engines available on the market. Auto rigging not only lowers the costs and requirements of 3D model generation and animation but also helps 3D models look more appealing.

Streamlining 3D Animation Creation via Rigging

In 2021, hosted the first-ever awards!! HackerNoon Startup of the Year The goal of this campaign was to give recognition to the hardworking startups who pulled through the pandemic -- growing and thriving (despite all of the challenges). More than 44,000 startups were nominated all across the globe! They were selected from over 4,553 cities, with a total number of * cough * “4 billion” votes. Insane, right? To see who is a winner in each respective city, visit and pick a city. The name at the top of the list is the winner. (Awards, with compromised reviews, are under review.) startups.hackernoon.com The will announce the winners per region in their respective cities. Startups Winners Announcement Series Apparently, South America startups did incredibly well in that regard. With so many, until now, uncrowned jewels, it’s time we present to you... * drumroll* 🥳 The South America Startups of the Year Winners! Santiago, Chile Chile is known for being the most stable country to do business in Latin America, ranking 13th in The Economist’s Business Environment Index. Moreover, according to the Global Innovation Index, Chile ranks first in Latin America for innovation and is recognised as Chilean Silicon Valley with Santiago being the central city. The winner is…. QCObjects It is the 1st world class open-source framework made in Latin-America. São Paulo, Brazil And the winner of Brazil’s vibrant financial center is... Innvo Digital Their mission is to create the best ecosystem for a technology professional to work and undertake while sharing it with our customers and society. São Carlos The absolute leader of Sao Carlos seems to be: Predify Predify is an online software for optimizing pricing proccess and improving profits with AI and Big Data Analytics. Belo Horizonte, Brazil With a more than noble goal, Belo Horizone’s winner is: CM Tecnologia CM Tecnologia is an online scheduling system for healthcare providers in Brazil. Porto Alegre, Brazil With the focus on data protection, Porto Alegre, Brazil’s winner is…. Privacy Tools Privacy compliance platform, based on AI/Blockchain, which helps global companies to keep compliant with the data protection requirements. Brasil, Brazil With the focus on EdTech, Brasil is bringing us: Awari Awari is a YC-W21 company focusing on education for the Tech Industry. The company is growing at a fast pace and has gathered experts from all leading tech companies into a full education experience to prepare the next cohort of tech talent. Quito The capital of Ecuador, and also the closest capital to the actual equator, as the winner brings us: Agrodemanda The most comprehensive agricultural directory in Ecuador. Rio De Janeiro, Brazil Rio de Janeiro has more than 300 startups and is ranked 3rd in Brazil in terms of startup ecosystem development. The city is famous for the startups in the spheres of education, energy & environment and foodtech. Their winner is…. Bybrand Bybrand is the simplest way to save time and avoid frustration when managing your employee's email signatures. Buenos Aires, Argentina Buenos Aires, Argentina is not only the cosmopolitan capital with a vibrant history. It’s also Latin America’s most important port. Which makes their winner actually a very logical choice. Please meet: Liftit Liftit is the leading technology platform to automate and execute last-mile truck deliveries across Latin America. Curitiba, Brazil With a more noble mission and sustainability in mind, Curitiba, Brazil, as the winner brings us... Discrepante is the marketplace for a more human and sustainable economy Discrepante.com Florianópolis, Brazil Would you really be surprised one of the Brazil’s winners is related to football training? We neither. Please meet... Fútbol Fit Club Football FitClub® is a fitness training firm that gives fitness training to improve like a professional football player. Medellín, Colombia And the first Colombian Startup Winner is is a data intelligence solution powered by a high quality team. Meet... LogComex Market intelligence for international trade in Latin America Montevideo, Uruguay The host of inaugural FIFA world cup of 1930 comes through when it comes to innovation even in 2021. I’d like to introduce you to: Drop Technologies First electronic hand antiperspirant device Lima, Peru Lima, Peru, has in 2021 delivered some amazing results when it comes to blockchain technology. Their winner is very well deserved: RSK Labs RSK is the first open-source smart contract platform São Carlos Do Pinhal Well this is a unique case. The absolute unanimous winner of São Carlos Do Pinhal is: brain4care brain4care solution enables monitoring intracranial compliance noninvasively anywhere Blumenau, Brazil We’re sensing a theme here. Another stellar EdTech winner is coming from Blumenau, Brazil. Please meet... Uniasselvi Uniasselvi is a Brazilian distance-learning company that offers more than 60 undergraduate and postgraduate courses, in person and distance. Bogotá, Colombia Startups of Bogotá, Colombia definitely showed they’re not to be underestimated. With a very noble mission, let me introduce you to: Risü Risü is an online platform that links online consumption to donation to social institutions. Campina, Brazil If there’s one typo of business we’d single out as taking the biggest hit out of the pandemic, it would have to be small businesses. Thankfully, the winner of Campina, Brazil, operates with small businesses in mind Superlógica Tecnologias Ltda. Superlogica is a management system company created for small service businesses. Cerqueira César, Brazil Swooping half the points from the entire City, this year’s winners of Cerqueira César are InfoPrice INFOPRICE is a business intelligence company focused on physical retail pricing. Governador Valadares, Brazil The same can be said for the winners here. Let’s hear it for: Grupo KPG Saas, Payment, Manufacture, Pharmaceutical, E-commerce, Marketplace, Logistics Caxias Do Sul Known for wine making and Italian cultural influence, Caxias Do Sul brings as an interesting winner. Studio 360 Studio 360 is a proptech focused on easing the purchase experience for real state companies, brokers, and costumers. Sorocaba From Sorocaba, we have an interesting concept coming. Looking forward to seeing it further develop. Let’s meet: Quinto Quinto is a social network that represents the collective opinion of society—to help democracy evolve through technology Viña Del Mar To be a venue-oriented business and survive through the pandemic definitely deserves some recognition. In the name of that, let’s meet: SonicPollen SonicPollen, based in Chile, is a web-based booking platform that connects bands with venues and organizers. Lages Learn more about high-growth startups in Lages, South America. and the winner is…. Qualiall Qualiall develops technologies for training in operational processes such as work security, equipment maintenance, and more. Córdoba, Argentina Another gem from Argentina brings us unique agricultural solutions. Please meet: Kilimo Kilimo is a Big Data solution for water management in agriculture. São José Dos Campos, Brazil Another great agricultural solution comes this time from Brasil. Meet São José Dos Campos Startup winner: TerraMagna TerraMagna is a fintech company that focuses on risk mitigation for agribusinesses. São Leopoldo, Brazil Event-oriented businesses that have survived in the previous years should definitely bottle their perseverance and start selling it. One of those is definitely this winner: Wedy Wedy offers a one-stop-social marketplace for weddings. Pelotas, Brazil Medical scheduling platforms are definitely something we need to see more of. So glad Pelotos winner comes from this particular niche. Fácil Consulta Fácil Consulta is a booking platform that allows people to schedule an appointment with a Specialist Physician in their area. Santa Maria Could you believe how versatile the startups of South America are when we are only now coming across a game development studio? Let’s meet them Imgnation Studios Imgnation Studios is a game development studio that focuses on virtual reality. Asunción, Paraguay A FinTech solution coming from Paraguay. Meet Asunción Startup of the Year winner Vision Banco Vision Banco is a solid and growing financial institution serving the financial needs of the micro, small and medium enterprises. Caracas Venezualan food delivery app that seemed to have your heart. Meet Caracas Startup of the Year winner Yummy Inc. First Food Delivery App in Venezuela Recife A suitable combo between gaming and education, Recife Startup of the Year winner brings revolutionary solutions. Let’s meet them. Joy Street Joy Street offers develops video games focused on educational needs. Rosario, Argentina The winner of Rosario Startup of the Year award for 2021 is... Gbot Gbot is an autonomous robot that controls weeds without using agrochemicals. We also collect data in fields and generate precision maps. Vila Olímpia, Brazil The winner of Vila Olímpia Startup of the Year award for 2021 is... Seekr Seekr operates in the Information Technology sector, providing tools for managing and monitoring of brands. Barueri The winner of Barueri Startup of the Year award for 2021 is.... Glic Brazilian mhealth (web/app) platform for diabetes management Brasília The winner of Brasília Startup of the Year award for 2021 is... Ticies Ticies is a social network that helps people plan where to go with their friends, relatives and acquaintances, in all cities of the world. Juiz De Fora The winner of Juiz De Fora Startup of the Year award for 2021 is... Qranio Qranio is a gamified mobile learning platform for enterprises that rewards learning and stimulates users to engage with educational content. La Paz The winner of La Paz Startup of the Year award for 2021 is... Jukumari Advice 360 photo based market place for responsible tour operators Temuco The winner of Temuco Startup of the Year award for 2021 is... GoFeels GoFeels is the first independent hospitality network in the world. We promote collaborative work among hotels around the world. Vitacura The winner of Vitacura Startup of the Year award for 2021 is... MeatMe MeatMe delivers meats and accessories to have a culinary experience. Barranquilla The winner of Barranquilla Startup of the Year award for 2021 is... Mandaos Mandaos is a digital platform that connects companies and people with a network of independent messengers Ceará The winner of Ceará Startup of the Year award for 2021 is... Caroá Caroá is a cooperative that sells 34 varieties of vegetables, organic fruits, and vegetables. Chapecó The winner of Chapecó Startup of the Year award for 2021 is... HortiAgro HortiAgro is a seed and fertilizer market. Chile Chico The winner of Chile Chico Startup of the Year award for 2021 is... Gleengo Gleengo connects children with their favorite toys, through a tiny device and an application based on text-to-voice. Goiânia The winner of Goiânia Startup of the Year award for 2021 is... Auvo Auvo is an external teams management software. Itá The winner of Itá Startup of the Year award for 2021 is... TISSUELAB Tissuelab is a research and development center focused on biotechnology, and systems for reconstructive musculoskeletal surgery. Jardim Paulista The winner of Jardim Paulista Startup of the Year award for 2021 is... DiviCom DiviCom is a digital video networking company that designs, integrates, and markets complete systems. João Pessoa The winner of João Pessoa Startup of the Year award for 2021 is... YupiPlay YupiPlay develops and offers an educational gaming platform. La Reina The winner of La Reina Startup of the Year award for 2021 is... INTI-TECH INTI-TECH is the fastest growing renewable energy in Chile and the world's leading unconventional source. Leme The winner of Leme Startup of the Year award for 2021 is... EcoStart EcoStart focuses on manufacturing sustainable electric bicycles, fans, and accessories. Loja The winner of Loja Startup of the Year award for 2021 is... Enerwi Corporation Keeping people connected and secured through wireless charging novel solutions Manizales The winner of Manizales Startup of the Year award for 2021 is... Porter Metrics Porter Metrics has developed an automated solution for generating social media reports in minutes. Nova Lima The winner of Nova Lima Startup of the Year award for 2021 is... Biomimetic Solutions Biomimetic Solutions is an innovative tissue engineering company. Paraná The winner of Paraná Startup of the Year award for 2021 is... Laura Laura is a provider of artificial intelligence and predictive analytics platform for hospitala and clinics to prevent damage & reduce costs. Salvador The winner of Salvador Startup of the Year award for 2021 is... Sanar Sanar is a platform that focuses on being the doctor's guide and support, offering specialized content that helps in their development. Santa Catarina The winner of Santa Catarina Startup of the Year award for 2021 is... DrPOCKET Sunchales The winner of Sunchales Startup of the Year award for 2021 is... Eolo Pharma Eolo Pharma focuses on developing drugs targeting the molecular and cellular basis of inflammation-related diseases Valparaiso The winner of Valparaiso Startup of the Year award for 2021 is... Invitta Invitta transforms plastic waste into a high-performance construction material for manufacturing sustainable urban furniture. Vila Velha The winner of Vila Velha Startup of the Year award for 2021 is... OneGrid OneGrid is a developer of hardware and software solutions focused on energy management. Indaiatuba The winner of Indaiatuba Startup of the Year award for 2021 is... DWUL Energy Renewable Energy Campinas, Brazil The winner of Campinas Startup of the Year award for 2021 is... Ativy Ativy is an IT company specialized in cloud computing, data centers, IT outsourcing, service desk, and IT management. Las Condes, Chile The winner of Las Condes Startup of the Year award for 2021 is... # MuvPass Subscription services that allows it's users unlimited access to fitness classes in the best gyms and studios in Latin America. Pinheiros, Brazil The winner of Pinheiros Startup of the Year award for 2021 is... GuiaBolso GuiaBolso is a personal finance platform that empowers people to take control of financial well-being. Rio, Brazil The winner of Rio Startup of the Year award for 2021 is... EmCasa EmCasa is a vertically-integrated platform that helps customers buy and sell a home in Latin America, starting in Brazil. Guayaquil The winner of Guayaquil Startup of the Year award for 2021 is... Sabroso Online platform for LatAm's enterprises to order low-cost meals Jundiaí The winner of Jundiaí Startup of the Year award for 2021 is... Sintecsys Sintecsys offers a fast and effective detection, reducing losses and costs with fire brigades. Minas Gerais The winner of Minas Gerais Startup of the Year award for 2021 is... Rizoflora Biotechnology Rizoflora Biotechnology is a producer of biological product designed for nematodes control. São Caetano Do Sul The winner of São Caetano Do Sul Startup of the Year award for 2021 is... Wevo 1 iPaaS in Latam - Enabling companies to be truly digital companies with APIs, systems and data integrated into a single platform Canoas The winner of Canoas Startup of the Year award for 2021 is... ContaÁgil ContaÁgil facilitates and reduces bureaucracy in accounting routines of companies. Chile The winner of Chile Startup of the Year award for 2021 is... Unight Unight is the future of nightlife social media. Israelândia The winner of Israelândia Startup of the Year award for 2021 is... Matchpool Matchpool is a platform that creates human connections. La Plata The winner of La Plata Startup of the Year award for 2021 is... Pixivus Pixivus offers a community-based application that enables its users to collect, store, and share pictures of events. Novo Hamburgo The winner of Novo Hamburgo Startup of the Year award for 2021 is... Devorando Devorando offers an online food ordering system and menus available in restaurants based in Brazil. Pernambuco The winner of Pernambuco Startup of the Year award for 2021 is... Redu Redu is a distant learning platform which is built on a social networking structure. Providencia The winner of Providencia Startup of the Year award for 2021 is... # TrainFES TrainFES is a medical Devices for the rehabilitation of people with paralysis. Ribeirão Prêto The winner of Ribeirão Prêto Startup of the Year award for 2021 is... AllyHub Ally is a sales distribution channel technology that connects Schools and Service Providers with Education Agencies. Santa Cruz De La Sierra The winner of Santa Cruz De La Sierra Startup of the Year award for 2021 is... Mobi Latam Mobi Latam is a clean energy startup that focuses on transportation systems based on electric mobility. Santana De Parnaíba The winner of Santana De Parnaíba Startup of the Year award for 2021 is... MercadoLivre.com is an e-commerce technology company providing solutions to individuals and companies buying, selling, and more online. MercandoLivre.com More Information If you’re a winner, please answer ! If you’re a reader, participant, just a curious individual, consider answering one of our interviews . this interview here Read the FAQs about or . Startups here here To see all of the winners you may visit , pick any city and view the name that appears at the top. this site If you’re interested in partnering with us, we invite you to look through some of these or reach out to our business department. unique sponsorship options Perhaps creating your very own tickles your fancy or maybe you have a whole new idea for how we can partner! writing contest Thank you to all of our sponsors! We truly appreciate your contribution to the tech world and thus the future! The Startups Awards are sponsored by: , , , , , , , , , , Blockster Brex FreeCodeCamp LaunchDarkly Coil Udacity Udemy Vercel Asia Pacific Transgender Network Bybit Everscale Network This post was written/compiled by Shreya Kundu and Katarina Andrejević! If you have any questions or concerns or would like to report a discrepancy please email ellen@hackernoon.com.

Meet the Winners of Startups in South America

Integration tests are challenging in a standard application. They're even more challenging in a decoupled, asynchronous environment. If you're running them in a pipeline, you have to figure out all of the resource ARNs and make sure you have permission to access each of them. Also, what happens if your integration tests fail? Do you send a notification so someone can manually redeploy the previous version? Running integration tests in a CloudFormation custom resource simplifies a few of these issues. You can use references to other resources in the stack to get the required ARNs. You can use those same references to build execution rules for the integration test. Finally, if the integration tests fail, then CloudFormation will automatically roll back the deployment. An example project can be found in the GitHub project theBenForce/cdk-integration-tests How does it work? The idea came from the article . Essentially it comes down to leveraging two features of CloudFormation: and automatic rollbacks. Instead of creating an actual resource with your custom resource handler, you're going to execute your integration tests. Testing the Async Cloud with AWS CDK CustomResources CloudFormation Custom Resources A custom resource is an escape hatch in CloudFormation that allows you to manage external resources from your IaC template. The custom resource accepts the ARN of a lambda to be called, and any properties that you want to pass in. At deployment time, CloudFormation calls your lambda with all of the parameters supplied in the template and a few additional properties supplied by CloudFormation. The extra properties include the action to take (create, update, or delete) and a presigned S3 URL. When your function has finished execution, it needs to upload its result to the presigned URL that CloudFormation passed in. In addition to the final status, your lambda can add any output parameters that you want to reference within your CloudFormation template. UVU Test Runner The UVU test runner is a good library for running your integration tests in a lambda. It's lightweight and simple to use. It doesn't currently provide a programmatic interface for running tests, but that is being actively developed. Since all you need from the test runner is to know if the tests passed or failed, you won't need anything that advanced. The looks like a good alternative if you want to try something different. zora testing library Building a CDK construct Now that you know how the tests will work, you'll create a CDK construct that you can reuse throughout your project. Even if you aren't using the CDK, the process should be pretty easy to replicate in CloudFormation or Terraform. Custom Resource Lambda Handler Start by creating a new folder for your construct, call it . You're going to create the actual construct inside an index file later. Before you start working on that you'll create the handler lambda. IntegrationTests Install the package in your project. It provides some helper methods to make creating the custom resource handler easier. Once it's installed, create a file called inside of the directory. Add the following code to the file to handle basic custom resource interactions. cfn-lambda handlerLambda.ts IntegrationTests import CfnLambda from "cfn-lambda";

export const handler = CfnLambda({ 
	async AsyncCreate(properties) {
		return {
      FnGetAttrsDataObj: {
        TestPassed: true,
        Finished: new Date().toISOString(),
      },
    };
	},
	async AsyncUpdate(physicalId, properties) {
		return {
      FnGetAttrsDataObj: {
        TestPassed: true,
        Finished: new Date().toISOString(),
      },
    };
	},
	async AsyncDelete(physicalId, properties) {
		return {};
	}
}); Next, you need to create a method called that runs the test file that is passed into the construct. You'll add the test code to the lambda by doing a lazy import of an environment variable. You'll provide the value of the environment variable at build time, which will be able to see when it's bundling the lambda's source. runTests esbuild import {exec, suite} from 'uvu';

...

const runTests = async (properties: unknown) => {
    const {default: initTests} = await import(process.env.TEST_FILE!);
}; The method will need to accept a uvu test suite as its only parameter. You'll pass the custom resource's properties into the test suite's context so they can be accessed during runtime. You'll also need to call the test suite's method to make sure it's added to the list of tests to be executed. initTests run const runTests = async (properties: unknown) => {
    const {default: initTests} = await import(process.env.TEST_FILE!);

    const test = suite('Integration Test', properties);
    initTests(test);
    test.run();
}; Now you need to tell uvu to run all of the tests, then check the result. Unfortunately, uvu doesn't fully support the programmatic execution of tests, so you need to use a workaround to get the test results. Check to see if was set to 1, which means at least one of the tests failed. If you throw an exception, will pick it up and mark your custom resource's deployment as a failure. process.exitCode cfn-lambda const runTests = async (properties: unknown) => {
		...

    const result = await exec();

    if (process.exitCode) {
      throw new Error(`Tests Failed`);
    }
}; Now that you have the method, you need to call it from the create and update handlers. You can optionally return an object with set if you want to reference some values in your CloudFormation template. runTest FnGetAttrsDataObj async AsyncCreate(properties) {
  await runTests(properties);

  return {
    FnGetAttrsDataObj: {
      TestPassed: true,
      Finished: new Date().toISOString(),
    },
  };
},
async AsyncUpdate(physicalId, properties) {
  await runTests(properties);
  return {
    FnGetAttrsDataObj: {
      TestPassed: true,
      Finished: new Date().toISOString(),
    },
  };
}, That's all there is to the lambda. Really it's just a uvu test runner. Now you need to create the construct that deploys it and any tests that need to be executed. Creating the Resource Create an file in the directory. Add the following code to get started. index.ts IntegrationTests import * as cdk from "@aws-cdk/core";
import * as nodeLambda from "@aws-cdk/aws-lambda-nodejs";
import * as lambda from '@aws-cdk/aws-lambda';

interface IntegrationTestsProps {
  testEntry: string;
  timeout: cdk.Duration;

  /** These values will be passed into the context of your tests */
  properties?: Record<string, string>;
}

export class IntegrationTests extends cdk.Construct {
	private handler: lambda.IFunction;

	constructor(scope: cdk.Construct, id: string, props: IntegrationTestsProps) {
		super(scope, id);
	}
} You can see there are three properties that your construct will accept. The property accepts a path to the file that will be injected into the lambda handler that you created in the previous step. specifies the maximum amount of time that your lambda can spend running the integration tests. Finally, allows you to pass values into the custom resource that will be available when the tests execute. testEntry timeout properties Next, create the handler lambda. The only complicated part of this is injecting the property into your source code. You're going to use to take care of that. testEntry esbuild The construct uses to bundle lambda sources. It allows you to customize the build process using the property. NodejsFunction esbuild bundling The bundling parameter that you're going to use , which tells to replace global values with a constant. This replacement will happen before bundling, so when sees your import statement it will bundle the source code found at the provided path. is define esbuild esbuild this.handler = new nodeLambda.NodejsFunction(this, 'TestRunner', {
	entry: require.resolve('./handlerLambda.ts'),
	timeout: props.timeout,
	runtime: lambda.Runtime.NODEJS_14_X,
	bundling: {
		define: {
      "process.env.TEST_FILE": `"${props.testEntry}"`,
    },
	}
}); Now that the lambda is created, you can create a custom resource. Pass the lambda's ARN into the parameter. Also, provide a property that will change each deployment to ensure the test will be executed every time. serviceToken new cdk.CustomResource(this, 'IntegrationTests', {
	serviceToken: this.handler.functionArn,
	properties: {
		...props.properties,
		Version: new Date().toISOString(),
	}
}); Granting Permissions Your construct is all set up to execute any test that you pass into it. More than likely most of those tests will require access to an AWS resource. To make the process of granting permissions to your lambda simpler, change your construct to implement the interface. IntegrationTests iam.IGrantable export class IntegrationTests extends cdk.Construct implements iam.IGrantable { The interface only has one property: . This property is used with the methods of CDK constructs. For example, your function has the method that will give a principal permission to invoke it. IGrantable grantPrincipal grant* handler grantInvoke Since the handler lambda requires any permissions granted to your integration tests, simply return its property. grantPrincipal get grantPrincipal(): iam.IPrincipal {
      return this.handler.grantPrincipal;
    } Running some tests Now that you've finished building the construct, it's time to test it out. Create an empty stack and add an instance of the construct to it. IntegrationTests import * as cdk from '@aws-cdk/core';
    
    import { IntegrationTests } from '../constructs/integrationTests';
    
    export class TestStack extends cdk.Stack {
      constructor(scope: cdk.Construct, id: string, props: cdk.StackProps = {}) {
        super(scope, id, props);
        
        new IntegrationTests(this, `IntegrationTests`, {
          testEntry: require.resolve("./tests.ts"),
          timeout: cdk.Duration.seconds(5),
          properties: {
            Foo: "Bar"
          }
        });
      }
    } Creating some tests The property that you passed into the construct points to a file called in the same directory as . Create that file and add the following code to it. testEntry IntegrationTests tests.ts TestStack import {Test} from 'uvu';
import * as assert from 'uvu/assert';

interface TestContext {
    Foo: string;
}

export default (test: Test<TestContext>) => {
    test('First test', async (context) => {
        assert.equal(context.Foo, 'Bar', 'Foo should be Bar');
    });
}; This code adds a single test that makes sure the property passed into is equal to . Foo IntegrationTests Bar Testing it Everything is set up now, you can run from your project's root directory and it should deploy successfully. npx cdk deploy To validate that your tests will actually roll back the stack when they fail, change the property that you passed into from to . Now deploy your stack again. This time it should fail, and if you open up the CloudFormation console you'll see a status of . Foo IntegrationTests Bar Fighters UPDATE_ROLLBACK_COMPLETE Summary In this tutorial, you've seen how to create a lambda-backed custom resource, how to inject code into a lambda using , and how to roll back deployments by throwing an error inside a custom resource handler. esbuild Cover Photo by on Scott Graham Unsplash Previously published . here

Inkitt

inkitt.com

51-200 employees

Since 2014

COMPANY RANKING

INKITT

EVERGREEN INDEX #5882

Inkitt WIKI

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

Inkitt

inkitt.com

51-200 employees

Since 2014

COMPANY RANKING

INKITT

EVERGREEN INDEX #5882

RELATED COMPANIESRANK

STORIES ABOUT INKITT

Inkitt WIKI

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