The global computerized maintenance management system (CMMS) market is anticipated to showcase promising growth over the assessment period by registering a CAGR of 9.1% from 2023 to 2033. The global market revenue totaled US$ 1,

Global Computerized Maintenance Management System (CMMS) Market Poised for a Thrilling US$ 4,215.1 Million by 2033

About TuMeke Ergonomics TuMeke is on a mission to eliminate workplace musculoskeletal injuries. This next-generation ergonomic risk assessment platform has been created by a team of engineers, ergonomists, academics, and problem solvers that are striving to maximize the safety and sustainability of work environments in a cost-effective way.

TuMeke Ergonomics Expands Leadership Team Amid Growing Adoption of Computer Vision AI for Workplace Ergonomic Applications

Explore the top requirements management tools to manage your project requirements. Compare features and find the best tool for your needs.

Best Requirements Management Tools and Software of 2023

Advanced Micro Devices (AMD) and Korean telco KT are among the investors of Moreh, which builds an AI software tool that optimizes and creates AI models. Moreh says its flagship AI software, called the MoAI,

AMD and Korean telco KT back AI software developer Moreh in $22M Series B

Are you searching for the perfect facility management software? Finding the ideal software solution can make a significant impact on your company’s operations. However, it’s crucial to remember that the effectiveness of facility management software depends on several factors,

How to Choose the Best Facility Management Software For Your Facility?

In this article, I will delve into whether artificial intelligence (AI), particularly the emergence of tools like generative AI (GenAI), will replace classical software outsourcing as we know it.

AI vs software outsourcing: An opportunity or a threat?

Windows 11 just got a lot of new features, and 2023's big update isn’t just about AI taking over your desktop. There are lots of other updates to check out, including the return of many users' favorite taskbar option. (I know many people who are very excited.)

10 new Windows 11 features in the October 2023 update to try now

The warning was issued by GitHub after the software development platform recently disclosed the existence of a memory corruption flaw in the libcue library which parses cue sheets. It’s being ...

This software relic from the CD era could put your entire PC at risk

To specifically create a 32-bit environment in the folder “~/.wine32” for older Windows software ... as a whole or transferred to another Linux computer running Wine, because the Wine prefix ...

How to use Windows software in Linux

PC hardware is nice, but it’s not much use without innovative software. I’ve been reviewing software for PCMag since 2008, and I still get a kick out of seeing what's new in video and photo ...

The Best Photo Editing Software for 2023

Knoema

knoema

“ .” - My father points out every time we drive by there. That shopping mall you’re seeing was built on the land I refused to buy for a thousand bucks a few years ago There is nothing any of us could do to turn the tables of time. I think many of you can resonate with this situation in your own lives. Sorry for taking you to the past, but let’s learn the lesson of what life has taught us. Never wait for years to invest in something meaningful to regret it later. The right time is today. By no means, this statement means that you should make decisions in haste and put all your money at risk. Research opportunities, research again and . This article will help you begin your journey with cryptocurrency exchanges. invest wisely Opportunities With Cryptocurrency It’s painstaking to thoroughly understand the dynamics of crypto for young adults. No one is 100% certain about the future of crypto, but one thing is for sure, and that is that the future is online. With conventional investments not providing scalable returns, it makes sense for one to explore and identify investment opportunities online. With a plethora of crypto investment options emerging online, it requires research and understanding of the market to invest better and reap returns. Image source: knoema The above image is enough proof that the future of Cryptocurrency is on the up and so are the fortunes of cryptocurrency traders. Keep reading and explore places where you can shop and check : bitcoin price Top Cryptocurrency Exchanges of 2021 WazirX Started in 2017, WazirX has crossed the landmark of 6.5 million investors in India. Global Cryptocurrency Giant Binance Holdings recently acquired the cryptocurrency platform. Users can buy and sell cryptocurrencies from the comfort of their homes using their Mac, Windows, iOS and Android devices. The company has a solid user base, which is essential when you are based in the second most populated country on earth. CoinDCX Founded in 2018, CoinDCX has a strong user base of close to 4 million investors registered on its platform. The Mumbai-based crypto exchange deals in 200 plus cryptocurrencies with zero fees on amount deposit and withdrawal. Investors love CoinDCX for its user-friendly approach to crypto trading with Minimal trading fee charges. UPI & IMPS payments are also accepted here. Moreover, the company offers a wide variety of products and services that helps traders with financial advisory. CoinSwitch Kuber CoinSwitch is another trading option for cryptocurrency geeks in India. This platform is ideal for beginners; it is a haven for traders who want a clean user interface to keep them motivated. Since its inception in 2017, it has carved a small niche for itself with its user-friendly trading mechanism. CoinSwitch allows its 3 million registered users to sell and buy stakes in more than 100 cryptocurrencies. They are very aggressive in marketing and onboarded many high ticket advertisers like the Indian Premier League (IPL) to boost their visibility. How to Open an Account The process of opening a Crypto account is the same on almost all exchanges. For reference, let’s take the example of WazirX: Download the WazirX app or visit the official website of WazirX. Go to the sign-up option and click it. Enter your email id and choose a strong password. Check your email account and click on the activation link. Go through the terms and conditions and press the checkbox. Click on the Sign-up button to finish. Secure Your Account Image source: pinterest Make sure you enable 2-factor authorization for your account. Download the Google Authenticator app and connect your account to add an extra layer of security. KYC Verification Last but not least is KYC verification. KYC is compulsory for everyone who wants to trade crypto online. Here are the steps: Go to the profile tab and click on profile verification. Fill in all the details and upload scan copies of your identification proof. Provide your bank details for adding and withdrawing money. Upload other documents like PAN card, Aadhar and your recent photograph. The crypto exchange will verify your details before approving your account. Once your account is approved, you can start transacting. Image source: Pinterest Make sure you have a thorough understanding of processes and g cryptocurrency investments. hidden costs for acquirin The Advent of NFTs NFT is a short-form for non-fungible tokens that represent real-world objects. These are digital assets that are coded in the same manner as cryptocurrency. The only but stark difference between crypto and NFT lies in their consistently inconsistent value. NFTs To put it in simple words, bitcoins and dogecoins can be exchanged for one another but not NFTs. The disparity happens because 1 Bitcoin will be equivalent to 1 Bitcoin in every place in this world but not NFTs. NFTs represent unique real-world objects and hence can’t be replaced by one another. Launch of Secondary Market for NFTs Not all cryptocurrency exchanges deal in NFTs, but some do; WazirX is the one leading. Since the inception of NFTs a few years back, it has been on the radar of many trading platforms. WazirX has taken an early lead at the top as one of India's most prominent NFT markets. The company claims to have already sold over 1200 digital collectables from an extensive array of fields. NFT marketplaces provide the creators with a great way to capitalize on unique assets, engage with their fans, and potentially generate revenue while staying ahead of the curve and keeping pace with innovations in commerce and technology." Introducing a secondary market increases NFT availability and the introduction of royalties for indie or independent local creators that won't obtain the exposure they deserve any other way. The Future of NFTs It remains to be seen how users will respond to NFTs. Furthermore, it's also unknown how much growth the NFT Marketplaces will enjoy in the long run. However, this move marks a significant shift in attitude by the Indian population and the country. The successful introduction of an NFT market by a developing economy like India shows the importance of crypto in modern times. To sum up: To invest or not to invest was never the question. Those who are passionate about crypto are keener in research and understanding the risks involved before making an informed decision. before starting out dumping money. Do your research before investing. Get hold of basics of crypto investing

Top Cryptocurrency Exchanges in India to Spoil Rotten With Your Hard Earned Paper 

Best Public Datasets for Machine Learning and Data Science: Sources and Advice on the Choice

According to , the Global Knowledge Partnership on Migration and Development, remittances from migrants to their home communities—are projected to increase from US$791 billion in 2021 to US$840 billion by the end of 2023. This trend underscores the vital role remittances play in global finance, particularly for Low and Middle-Income Countries (LMICs), excluding China. KNOMAD Developing Economies Benefit the Most from Remittance In 2022, the countries for remittance inflow were: top five recipient India (US$111 billion), Mexico (US$61 billion), China (US$51 billion), Philippines (US$38 billion), and Pakistan (US$30 billion). While remittances are primarily private funds and not a substitute for public spending, they do benefit the economy by enabling recipients to actively participate in the consumer market. After all, when people spend these funds for domestic consumption, it serves as a significant boost to the national economy. The Traditional Remittance Landscape The World Bank calculates the received as a segment of a country's GDP, clearly establishing that personal remittances do, in fact, comprise a noteworthy portion of many nations' GDP. percentage share of personal remittances Albania sources more than 9% of its GDP from personal remittances, whereas, in Armenia’s case, the figure is more than 10%. In El Salvador, remittances constitute almost 27% of the country’s GDP, and for Georgia, it's nearly 17%. Given remittance’s role in uplifting the standards of living of a large segment of the global population, it must happen seamlessly. However, the traditional modes of remittances do not always ensure so. This is due to several key challenges, such as high transaction costs, low speed, limited access to financial services, and lack of transparency. Fixing these loopholes is crucial for the growth and efficiency of the global remittance market. High Transaction Fees In November 2022, the IMF revealing how high transaction costs in remittances negatively affect recipients. published a study As per the study, the global average of remittance transaction fees - as a share of a US$200 remittance - has been nearly US$7.5 worldwide. But in many Southern African countries, such as Angola, Botswana, and Namibia, the fees are 2.5 times the sample average, owing to high exchange rate margins. Apart from an existing imbalance, some countries witnessed a widening of the gap as well. Remittance transaction fees increased by more than 40 percent in countries like Gambia, Afghanistan, and the Kyrgyz Republic between 2016 and 2020. Overall, there is significant heterogeneity in remittance transaction fees globally, as many countries pay a lot more to receive funds from outside than the global average. Yet, high fees aren't the only challenge affecting remittance flows. Transaction Delays Delays in overseas fund transfers also pose challenges to those on the receiving end of remittances. However, factors contributing to these delays are often beyond the control of the beneficiaries. For example, banks have cut-off times for transactions, a factor further complicated by the varying public holidays observed in different regions. Moreover, the methods for sending funds can vary by country, with financial institutions requiring extra time for anti-fraud and anti-money laundering checks. What further exacerbates these delays is often a lack of clear information, introducing another layer of complexity: a lack of transparency. Lack of Transparency The World Bank that sending remittances is unnecessarily confusing, with several independent researchers backing the claim. acknowledged One such shows that 55% of American consumers understand the costs of sending money abroad, but only 18% can correctly identify exchange rates as one of those costs. Echoing this, the World Bank identifies a lack of transparency as the single most important factor leading to high remittance prices. The components of these prices are multifaceted, involving variables like upfront fees and FX margins. research Unbanked, Underbanked Population & Their Plight While transaction delays, high costs, and lack of transparency are mostly infrastructural pitfalls, a large chunk of the global population is bereft of the basic minimum access to banking. According to a World Bank published in July 2022, nearly 1.4 billion adults worldwide remain unbanked. Alarmingly, these adults are usually women, poorer, less educated, and live in rural areas. report Cryptocurrencies: A Potential Game-Changer From the outset, cryptocurrencies have been designed to achieve financial inclusion. They utilize blockchain-enabled smart contracts to facilitate peer-to-peer transactions with minimal need for intermediaries. This not only reduces transaction costs but also accelerates the process. Smart contracts further enable direct loan agreements between lenders and beneficiaries, while asset holders can efficiently invest their idle assets for returns. Collectively, these automated applications represent a transformative shift in the financial sector. Similarly, blockchain and cryptocurrency-based systems have democratically restructured financial transactions. By eliminating the need for centralized, cost-bearing authorities, they have made financial systems more decentralized, inclusive, and equitable. Decentralization Through Blockchain: Impact on the Remittance Market Blockchain-enabled, intermediary-free peer-to-peer transfers can significantly lower transaction costs. In fact, data shows that these crypto transactions can cost as little as 0.01% to 0.10% of the total amount, making them up to than traditional methods. 127 times cheaper To understand the greater economic ramifications, let us take the case of Kenya, for . example Kenya: A Case Study for Remittance Benefits In Kenya, where the average cost to send $200 is over 8.7%, remittances made up 3.5% of the GDP in 2021, totaling $3.7 billion. Lowering these costs to around 2% could have saved the country over US$200 million, equivalent to 0.22% of its GDP. But it's not just about economic savings - crypto remittances also offer significantly better speed. Moreover, since crypto transactions do not require banking institutions to mediate, they can spread to regions with very limited banking infrastructure. All one needs is access to a healthy internet system. This benefit is particularly relevant considering that global banking network distribution is not at all homogeneous. Against this backdrop of unequal banking access, low cost of remittance transactions, better speed, and improved accessibility & inclusion make cryptocurrencies a compelling solution. As a testament to its growing relevance in remittance, crypto adoption is visibly on the rise in many countries worldwide. Real-World Applications and Case Studies Latin America Remittance payments are fueling crypto adoption in Latin America, leading to a 40% surge in value, which reached $562 billion from July 2021 to June 2022. This adoption is further driven by regional economic factors, such as high inflation rates and weakening national currencies. In response, crypto users in the region are increasingly turning to stablecoins—cryptocurrencies pegged to the price of stable currencies like the USD—as a practical solution. Africa’s Growing Cryptocurrency Remittance Market Africa has significantly adopted cross-border blockchain remittance, driven in part by limited access to formal banking systems and poor financial inclusion. This has led to rapid growth in the cryptocurrency remittance market across the continent. Supporting this trend, the International Monetary Fund reports that Africa is one of the fastest-growing crypto markets globally, with transactions reaching US$20 billion per month in 2021. This growth is most evident in countries like Kenya, Nigeria, and South Africa, which boast the highest number of users among African nations. Crypto Remittance Scenario in Asia Pacific In the Pacific, has gained significant traction as a crypto-based solution in Australia. This success is not just anecdotal, as remittance has emerged as a vital use case in Australian digital asset markets, where Ripple's XRP often leads trading volumes on some of the country's top exchanges. Ripple remittance Shifting the focus to Asia, digital fund transfer services are also on the rise here. Strike, for instance, has partnered with a bunch of local businesses that connect Bitcoin’s Lightning Network to local banking services, including Pouch in the Philippines and GetBit in Vietnam. These collaborations underscore the growing fusion of traditional financial systems with cryptocurrencies across Asia. Crypto Remittance Using Blockchain at a Global Level: Challenges and Considerations While crypto remittance has successfully emerged as an alternative to traditional modes of international money transfer, it faces challenges, such as volatility, regulatory pressures, and the need for increased awareness, particularly in low and middle-income countries. Volatility Concerns In some countries like Venezuela, the national currency, such as the Bolivar, has proven even more volatile than Bitcoin. Here, the crypto-economy, with solutions such as stablecoins, has managed to offer far lower volatility levels. Yet volatility is a hurdle in most countries, as even the Bitcoin prices - the representative asset of the crypto-economy have been a topsy-turvy ride over the past year and more. Regulatory Pressure Regulatory pressures pose another significant barrier to adoption. For instance, around 20% of sub-Saharan African countries have banned crypto assets—countries that would, ironically, benefit the most from crypto remittance. Lack of Crypto Awareness Finally, crypto education is not yet up to the mark to encourage a significant segment of the global population to adopt digital assets as a means of international fund transfer. In fact, even among those who have adopted crypto, many are doubtful of its safety and reliability. The Future of Global Remittances In a realm where global remittances could surpass by 2023, cryptocurrencies are emerging as the technological marvel poised to reform conventional money transfers, particularly benefiting developing economies. This stands in sharp contrast to existing systems, which have been hamstrung by a plethora of challenges, including costly fees, sluggish transactions, and obscurity, not to mention the millions without access to basic financial services. $840 billion As blockchain-backed digital currencies promise to slash fees, expedite transactions, and enhance transparency, their real-world utility in remittance services is becoming evident in various regions, from Latin America and Africa to the Asia-Pacific. However, this positive trajectory comes with its own set of barriers like market volatility, regulatory constraints, and limited public familiarity. Despite these challenges, upcoming tech innovations are poised to further simplify and enhance crypto-based remittances, putting the market on track for substantial growth. This signals a tangible leap toward better efficiency, affordability, and financial inclusion globally, but one that will still necessitate a concerted effort among policymakers, regulators, and the crypto industry to overcome lingering obstacles. Also published . here

How Cryptocurrencies Transform the Global Remittance Landscape 

Welcome to other chapters of Let’s Understand Chrome V8 In this article, I will talk about how the Parse, AST, and Token work together, and walk you through the compilation as well as watch and see the detail. Specifically, you will see how to scan tokens, and how Parse consumes tokens for generating an AST tree. 1. Parse_Info Below is the Parse_Info class. It’s the kernel class of the Parser, that manages JavaScript source code and an AST tree. Simply, the input of the Parser is JavaScript code and the output is an AST tree. But note that from the moment V8 loaded the JavaScript source code, the code has been encoded as UTF-16 already. Let’s step into the Parse_Info. 1.  // A container for the inputs, configuration options, and outputs of parsing.
2.  class V8_EXPORT_PRIVATE ParseInfo {
3.  public:
4.  //omit...
5.  AstValueFactory* ast_value_factory() const {
6.    DCHECK(ast_value_factory_.get());
7.    return ast_value_factory_.get();
8.  }
9.  const AstRawString* function_name() const { return function_name_; }
10.  void set_function_name(const AstRawString* function_name) {
11.    function_name_ = function_name;
12.  }
13.  FunctionLiteral* literal() const { return literal_; }
14.  void set_literal(FunctionLiteral* literal) { literal_ = literal; }
15.  private:
16.   //------------- Inputs to parsing and scope analysis -----------------------
17.   const UnoptimizedCompileFlags flags_;
18.   UnoptimizedCompileState* state_;
19.   std::unique_ptr<Zone> zone_;
20.     v8::Extension* extension_;
21.     DeclarationScope* script_scope_;
22.     uintptr_t stack_limit_;
23.     int parameters_end_pos_;
24.     int max_function_literal_id_;
25.     //----------- Inputs+Outputs of parsing and scope analysis -----------------
26.     std::unique_ptr<Utf16CharacterStream> character_stream_;
27.     std::unique_ptr<ConsumedPreparseData> consumed_preparse_data_;
28.     std::unique_ptr<AstValueFactory> ast_value_factory_;
29.     const AstRawString* function_name_;
30.     RuntimeCallStats* runtime_call_stats_;
31.     SourceRangeMap* source_range_map_;  // Used when block coverage is enabled.
32.     //----------- Output of parsing and scope analysis ------------------------
33.     FunctionLiteral* literal_;
34.     bool allow_eval_cache_ : 1;
35.   #if V8_ENABLE_WEBASSEMBLY
36.     bool contains_asm_module_ : 1;
37.   #endif  // V8_ENABLE_WEBASSEMBLY
38.     LanguageMode language_mode_ : 1;
39.   }; In the above code, line 5 is the AST factory method; Line 13 the literal returns the AST tree; Line 17 the flags_ shows the reason why the function is not optimized; Line 33 the literal_ is responsible for holding the completed AST tree. As I mentioned the AST is an output of the parser, so if you want to watch the workflow of the parser in detail, you just debug it and keep watching the member variable literal_, in this way you are going to see the AST generation and how the factory method is called. 2. AST Tree As I mentioned above, the variable literal_ represents an AST tree, which its declaration class is the FunctionLiteral. 1.  class FunctionLiteral final : public Expression {
2.   public:
3.    template <typename IsolateT>//省略很多代码...............
4.    MaybeHandle<String> GetName(IsolateT* isolate) const {  }
5.    const AstConsString* raw_name() const { return raw_name_; }
6.    DeclarationScope* scope() const { return scope_; }
7.    ZonePtrList<Statement>* body() { return &body_; }
8.    bool is_anonymous_expression() const {
9.      return syntax_kind() == FunctionSyntaxKind::kAnonymousExpression;
10.    }
11.    V8_EXPORT_PRIVATE LanguageMode language_mode() const;
12.    void add_expected_properties(int number_properties) {}
13.    std::unique_ptr<char[]> GetDebugName() const;
14.    Handle<String> GetInferredName(Isolate* isolate) {  }
15.    Handle<String> GetInferredName(LocalIsolate* isolate) const {}
16.    const AstConsString* raw_inferred_name() { return raw_inferred_name_; }
17.    FunctionSyntaxKind syntax_kind() const {}
18.    FunctionKind kind() const;
19.    bool IsAnonymousFunctionDefinition() const {  }
20.    int suspend_count() { return suspend_count_; }
21.    int function_literal_id() const { return function_literal_id_; }
22.    void set_function_literal_id(int function_literal_id) {  }
23.   private:
24.    const AstConsString* raw_name_;
25.    DeclarationScope* scope_;
26.    ZonePtrList<Statement> body_;
27.    AstConsString* raw_inferred_name_;
28.    Handle<String> inferred_name_;
29.    ProducedPreparseData* produced_preparse_data_;
30.  }; I would emphasize that the AST granularity is one function, in other words, a JavaScript function corresponds to only one AST tree. In the above code, line 26 member variable body_ holds the AST body, go through the body_ if you wonder about the details. Lines 4–15 set language mode as strict or sloppy. Let’s look more at line 18 FunctionKind. 1.  enum FunctionKind : uint8_t {
2.    // BEGIN constructable functions
3.    kNormalFunction,kModule,kAsyncModule,kBaseConstructor,kDefaultBaseConstructor,
4.    kDefaultDerivedConstructor,
5.    kDerivedConstructor,
6.  //omit....
7.    kLastFunctionKind = kClassStaticInitializerFunction,
8.  }; You should see that the function kinds are not the types in the JavaScript books because the function kinds just represent the function kinds in a compiler. See compiler books for details. 3. AST Node Type The following macro templates are non-exhaustive node type lists. 1.  #define DECLARATION_NODE_LIST(V) \
2.    V(VariableDeclaration)         \
3.    V(FunctionDeclaration)
4.  #define ITERATION_NODE_LIST(V) \
5.    V(DoWhileStatement)          \
6.    V(WhileStatement)            \
7.    V(ForStatement)              \
8.    V(ForInStatement)            \
9.    V(ForOfStatement)
10.  #define BREAKABLE_NODE_LIST(V) \
11.    V(Block)                     \
12.    V(SwitchStatement)
13.  #define STATEMENT_NODE_LIST(V)       \
14.    ITERATION_NODE_LIST(V)             \
15.    BREAKABLE_NODE_LIST(V)             \
16.    V(ExpressionStatement)             \
17.    V(EmptyStatement)                  \
18.    V(SloppyBlockFunctionStatement)    \
19.    V(IfStatement)                     \
20.    V(InitializeClassStaticElementsStatement)//omit
21.  #define LITERAL_NODE_LIST(V) \
22.    V(RegExpLiteral)           \
23.    V(ObjectLiteral)           \
24.    V(ArrayLiteral)
25.  #define EXPRESSION_NODE_LIST(V) \
26.    LITERAL_NODE_LIST(V)          \
27.    V(Assignment)                 \
28.    V(Await)                      \
29.    V(BinaryOperation)            \
30.    V(NaryOperation)              \
31.    V(Call)                       \
32.    V(YieldStar)//omit
33.  #define FAILURE_NODE_LIST(V) V(FailureExpression)
34.  #define AST_NODE_LIST(V)                        \
35.    DECLARATION_NODE_LIST(V)                      \
36.    STATEMENT_NODE_LIST(V)                        \
37.    EXPRESSION_NODE_LIST(V) In the above code, see line 34, it organizes all the templates together to generate an AST tree for your JavaScript function in the parser which is a part of the compiler pipeline. By the macro AST_NODE_LIST, we should see that there are three types in an AST, and every type also has more subtypes. All of these types correspond to our JavaScript code and represent semantics accurately. 4. Token Type The following macro templates are non-exhaustive token lists. 1.  #define TOKEN_LIST(T, K)                                           \
2.    T(TEMPLATE_SPAN, nullptr, 0)                                     \
3.    T(TEMPLATE_TAIL, nullptr, 0)                                     \
4.    /* BEGIN Property */                                             \
5.    T(PERIOD, ".", 0)                                                \
6.    T(LBRACK, "[", 0)                                                \
7.    /* END Property */                                               \
8.    /* END Member */                                                 \
9.    T(QUESTION_PERIOD, "?.", 0)                                      \
10.    T(LPAREN, "(", 0)                                                \
11.    /* END PropertyOrCall */                                         \
12.    T(RPAREN, ")", 0)                                                \
13.    T(RBRACK, "]", 0)                                                \
14.    T(LBRACE, "{", 0)                                                \
15.    T(COLON, ":", 0)                                                 \
16.    T(ELLIPSIS, "...", 0)                                            \
17.    T(CONDITIONAL, "?", 3)                                           \
18.  //omit. The token is used in the scanner which is a part of the V8 compiler, the scanner is responsible for converting the JavaScript code to tokens. Let’s say a simple example, see line 5, the token type is PERIOD and corresponds to the dot in JavaScript code, which means that the scanner will convert every dot that it sees to a PERIOD token. Samely, lines 10 and 12 are light paren and right paren, which are used to describe the and in JavaScript code. So in every line, in every macro which starts with a T, the first parameter is the token type, the second is lexical corresponding to the type, and the last number is the token priority, the number is smaller, the token is higher, and will be converted early. ( ) 5. Finite-state Automation In most compilers, the lexer and parser use the FSA(finite-state automation) to analyze the source code. In V8, it uses the switch-case to implement the FSA, let’s have a look at the lexer FSA, namely the token scanner. 1.  V8_INLINE Token::Value Scanner::ScanSingleToken() {
2.   Token::Value token;
3.   do {
4.     next().location.beg_pos = source_pos();
5.     if (V8_LIKELY(static_cast<unsigned>(c0_) <= kMaxAscii)) {
6.       token = one_char_tokens[c0_];
7.       switch (token) {
8.         case Token::LPAREN:
9.         case Token::RPAREN:
10.          case Token::LBRACE:
11.          case Token::RBRACE:
12.          case Token::LBRACK:
13.          case Token::RBRACK:
14.          case Token::COLON:
15.          case Token::SEMICOLON:
16.          case Token::COMMA:
17.          case Token::BIT_NOT:
18.          case Token::ILLEGAL:
19.            // One character tokens.
20.            return Select(token);
21.          case Token::CONDITIONAL:
22.            // ? ?. ?? ??=
23.            Advance();
24.            if (c0_ == '.') {
25.              Advance();
26.              if (!IsDecimalDigit(c0_)) return Token::QUESTION_PERIOD;
27.              PushBack('.');
28.            } else if (c0_ == '?') {
29.              return Select('=', Token::ASSIGN_NULLISH, Token::NULLISH);
30.            }
31.            return Token::CONDITIONAL;
32.  //omit
33.          case Token::WHITESPACE:
34.            token = SkipWhiteSpace();
35.            continue;
36.          case Token::NUMBER:
37.            return ScanNumber(false);
38.          case Token::IDENTIFIER:
39.            return ScanIdentifierOrKeyword();
40.          default:
41.            UNREACHABLE();
42.        }
43.      }
44.      if (IsIdentifierStart(c0_) ||
45.          (CombineSurrogatePair() && IsIdentifierStart(c0_))) {
46.        return ScanIdentifierOrKeyword();
47.      }
48.    } while (token == Token::WHITESPACE);
49.    return token;
50.  } The ScanSingleToken() is responsible for generating a token. In lines 8–40, every case is a token. The following code is the parser FSA, which consumes tokens and generates nodes for an AST tree. 1.  ParserBase<Impl>::ParseStatementListItem() {
2.    switch (peek()) {
3.      case Token::FUNCTION:
4.        return ParseHoistableDeclaration(nullptr, false);
5.      case Token::CLASS:
6.        Consume(Token::CLASS);
7.        return ParseClassDeclaration(nullptr, false);
8.      case Token::VAR:
9.      case Token::CONST:
10.        return ParseVariableStatement(kStatementListItem, nullptr);
11.      case Token::LET:
12.        if (IsNextLetKeyword()) {
13.          return ParseVariableStatement(kStatementListItem, nullptr);
14.        }
15.        break;
16.      case Token::ASYNC:
17.        if (PeekAhead() == Token::FUNCTION &&
18.            !scanner()->HasLineTerminatorAfterNext()) {
19.          Consume(Token::ASYNC);
20.          return ParseAsyncFunctionDeclaration(nullptr, false);
21.        }
22.        break;
23.      default:
24.        break;
25.    }
26.    return ParseStatement(nullptr, nullptr, kAllowLabelledFunctionStatement);
27.  } In end, I would argue that FSA is an important fundamental in a compiler, which is worth examining in a little more depth. 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 : WeChat Email v8blink@outlook.com This story was first published here.

Understaning Chrome V8 - Chapter 23:  Compiler Workflow Parse, AST, and Token 

Welcome to other chapters of Let’s Understand Chrome V8 In the past articles, we talked a lot about the JavaScript compiler of V8. The parser, the scanner, and the bytecode, as well as their fundamentals, kernel code, and key structure, were all we covered. In the next articles, we will walk through the compiler workflow, and watch how V8 transforms the JavaScript code into bytecode step by step. Figure 1 shows the workflow, it starts from the JavaScript code you wrote, goes through the scanner and parser, and finally generates bytecodes. In this article, I use d8.exe instead of v8.exe, since d8.exe can print out to the terminal directly as well as the d8 is very light versus v8. Note: 1. Read JavaScript code Below is our test case： function ignition(s) {
    this.slogan=s;
	this.start=function(){eval('console.log(this.slogan);')}
}
worker = new ignition("here we go!");
worker.start(); Below is the Execute() that is responsible for executing the JavaScript code. Quite simply, it first reads the JavaScript code from a file, then compiles and executes the code. 1.  bool SourceGroup::Execute(Isolate* isolate) {
2.  //............omit..................
3.      // Use all other arguments as names of files to load and run.
4.      HandleScope handle_scope(isolate);
5.      Local<String> file_name =
6.          String::NewFromUtf8(isolate, arg, NewStringType::kNormal)
7.              .ToLocalChecked();
8.      Local<String> source = ReadFile(isolate, arg);
9.      if (source.IsEmpty()) {
10.        printf("Error reading '%s'\n", arg);
11.        base::OS::ExitProcess(1);
12.      }
13.      Shell::set_script_executed();
14.      if (!Shell::ExecuteString(isolate, source, file_name, Shell::kNoPrintResult,
15.                                Shell::kReportExceptions,
16.                                Shell::kProcessMessageQueue)) {
17.        success = false;
18.        break;
19.      }
20.    }
21.    return success;
22.  } In line 5, the NewFromUtf8 gets the file name which is our case. In line 8, the ReadFile gets file content which is our case actually. 1.  Local<String> Shell::ReadFile(Isolate* isolate, const char* name) {
2.  //only the most important parts...............................
3.    char* chars = static_cast<char*>(file->memory());
4.    Local<String> result;
5.    if (i::FLAG_use_external_strings && i::String::IsAscii(chars, size)) {
6.      String::ExternalOneByteStringResource* resource =
7.          new ExternalOwningOneByteStringResource(std::move(file));
8.      result = String::NewExternalOneByte(isolate, resource).ToLocalChecked();
9.    } else {
10.      result = String::NewFromUtf8(isolate, chars, NewStringType::kNormal, size)
11.                   .ToLocalChecked();
12.    }
13.    return result;
14.  } Line 8 and line 10 return the JavaScript code depending on the type is ExternalOneByte or UTF8. Here, our case is UTF8, regarding String::ExternalOneByteStringResource, we will talk about it in the future. Back to SourceGroup::Execute(), and step into Shell::ExecuteString at line 14, its source is given below: 1.  bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
2.                      Local<Value> name, PrintResult print_result,
3.                      ReportExceptions report_exceptions,
4.                      ProcessMessageQueue process_message_queue) {
5.  	//omit............................
6.  bool success = true;
7.  {
8.    if (options.compile_options == ScriptCompiler::kConsumeCodeCache) {
9.  	//omit............................
10.       } else if (options.stress_background_compile) {
11.  	//omit............................
12.       } else {
13.         ScriptCompiler::Source script_source(source, origin);
14.         maybe_script = ScriptCompiler::Compile(context, &script_source,
15.                                                options.compile_options);
16.       }
17.       Local<Script> script;
18.       if (!maybe_script.ToLocal(&script)) {
19.         // Print errors that happened during compilation.
20.         if (report_exceptions) ReportException(isolate, &try_catch);
21.         return false;
22.       }
23.       if (options.code_cache_options ==
24.           ShellOptions::CodeCacheOptions::kProduceCache) {
25.  	//omit............................
26.       }
27.       maybe_result = script->Run(realm);//here is executing bytecode.
28.  }
29.  } In line 13, our JavaScript is wrapped into a variable script_source which includes the line and column offset. Since V8 only compiles the JavaScript function that is executing exactly not the full JavaScript code, the variable script_source help the compiler record the compilation information. In line 14, start to compile JavaScript. 2. Parser initialization In the workflow, the first part is the scanner, the second is the parser. Actually, the scanner is passive and the parser is active, this means that the parser takes out a token from the compilation cache actively, and the scanner is waked up by the parser once the cache miss, and to generate tokens and fill the cache. Below is CompileUnboundInternal() called by ScriptCompiler::Compile that at above line 14. 1.  MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
2.      Isolate* v8_isolate, Source* source, CompileOptions options,
3.      NoCacheReason no_cache_reason) {
4.  //omit...............
5.    i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
6.    i::Handle<i::SharedFunctionInfo> result;
7.    i::Compiler::ScriptDetails script_details = GetScriptDetails(
8.        isolate, source->resource_name, source->resource_line_offset,
9.        source->resource_column_offset, source->source_map_url,
10.        source->host_defined_options);
11.    i::MaybeHandle<i::SharedFunctionInfo> maybe_function_info =
12.        i::Compiler::GetSharedFunctionInfoForScript(
13.            isolate, str, script_details, source->resource_options, nullptr,
14.            script_data, options, no_cache_reason, i::NOT_NATIVES_CODE);
15.    if (options == kConsumeCodeCache) {
16.      source->cached_data->rejected = script_data->rejected();
17.    }
18.    delete script_data;
19.    has_pending_exception = !maybe_function_info.ToHandle(&result);
20.    RETURN_ON_FAILED_EXECUTION(UnboundScript);
21.    RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
22.  } The above function generates the UnboundInternal stuff, the line 11 tells us that the stuff is just a Sharedfunction actually. But, what is Bind? A Sharedfunction cannot be executed directly, V8 needs to match a context to the Sharedfunction, the “match” is just the bing. Let’s step into GetSharedFunctionInfoForScript. 1.  MaybeHandle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
2.      Isolate* isolate, Handle<String> source,
3.      const Compiler::ScriptDetails& script_details,
4.   .................) {
5.  //omit.........................
6.  		{
7.      maybe_result = compilation_cache->LookupScript(
8.          source, script_details.name_obj, script_details.line_offset,
9.          script_details.column_offset, origin_options, isolate->native_context(),
10.          language_mode);
11.    }
12.    if (maybe_result.is_null()) {
13.      ParseInfo parse_info(isolate);
14.      // No cache entry found compile the script.
15.      NewScript(isolate, &parse_info, source, script_details, origin_options,
16.                natives);
17.      // Compile the function and add it to the isolate cache.
18.      if (origin_options.IsModule()) parse_info.set_module();
19.      parse_info.set_extension(extension);
20.      parse_info.set_eager(compile_options == ScriptCompiler::kEagerCompile);
21.      parse_info.set_language_mode(
22.          stricter_language_mode(parse_info.language_mode(), language_mode));
23.      maybe_result = CompileToplevel(&parse_info, isolate, &is_compiled_scope);
24.      Handle<SharedFunctionInfo> result;
25.      if (extension == nullptr && maybe_result.ToHandle(&result)) {
26.        DCHECK(is_compiled_scope.is_compiled());
27.        compilation_cache->PutScript(source, isolate->native_context(),
28.                                     language_mode, result);
29.      } else if (maybe_result.is_null() && natives != EXTENSION_CODE) {
30.        isolate->ReportPendingMessages();
31.      }
32.    }
33.    return maybe_result;
34.  } Line 7 is looking up the compilation cache, that I mentioned in the last article. Line 13, the parse_info is a wrapper for Parser, like the variable script_source mentioned upfront. Line 15, the Parser_info initialization, code is given below: 1.  Handle<Script> NewScript(Isolate* isolate, ParseInfo* parse_info,
2.                           Handle<String> source,
3.                           Compiler::ScriptDetails script_details,
4.                           ScriptOriginOptions origin_options,
5.                           NativesFlag natives) {
6.    Handle<Script> script =
7.        parse_info->CreateScript(isolate, source, origin_options, natives);
8.    Handle<Object> script_name;
9.    if (script_details.name_obj.ToHandle(&script_name)) {
10.      script->set_name(*script_name);
11.      script->set_line_offset(script_details.line_offset);
12.      script->set_column_offset(script_details.column_offset);
13.    }
14.    Handle<Object> source_map_url;
15.    if (script_details.source_map_url.ToHandle(&source_map_url)) {
16.      script->set_source_mapping_url(*source_map_url);
17.    }
18.    Handle<FixedArray> host_defined_options;
19.    if (script_details.host_defined_options.ToHandle(&host_defined_options)) {
20.      script->set_host_defined_options(*host_defined_options);
21.    }
22.    return script;
23.  } From line 6 to line 12 wrap the JavaScript code that is our case into the variable script, then initialize the line_offset and column_offset. It is like the script_source really as I said. Back to Compiler::GetSharedFunctionInfoForScript(), and step into CompileToplevel() at line 23. 1.  MaybeHandle<SharedFunctionInfo> CompileToplevel(
2.      ParseInfo* parse_info, Isolate* isolate,
3.      IsCompiledScope* is_compiled_scope) {
4.  //omit.......................
5.    if (parse_info->literal() == nullptr &&
6.        !parsing::ParseProgram(parse_info, isolate)) {
7.      return MaybeHandle<SharedFunctionInfo>();
8.    }
9.  //omit........................
10.    MaybeHandle<SharedFunctionInfo> shared_info =
11.        GenerateUnoptimizedCodeForToplevel(
12.            isolate, parse_info, isolate->allocator(), is_compiled_scope);
13.    if (shared_info.is_null()) {
14.      FailWithPendingException(isolate, parse_info,
15.                               Compiler::ClearExceptionFlag::KEEP_EXCEPTION);
16.      return MaybeHandle<SharedFunctionInfo>();
17.    }
18.    FinalizeScriptCompilation(isolate, parse_info);
19.    return shared_info;
20.  } In line 5, the literal() returns the abstract syntax tree(AST), and V8 starts up the compiler to generate AST if is nullptr. The first time, the AST is null, and steps into ParseProgram. 1.  bool ParseProgram(ParseInfo* info, Isolate* isolate,
2.                    ReportErrorsAndStatisticsMode mode) {
3.  //omit............................
4.    Parser parser(info);
5.    FunctionLiteral* result = nullptr;
6.    result = parser.ParseProgram(isolate, info);
7.    info->set_literal(result);
8.    if (result) {
9.      info->set_language_mode(info->literal()->language_mode());
10.      if (info->is_eval()) {
11.        info->set_allow_eval_cache(parser.allow_eval_cache());
12.      }
13.    }
14.    if (mode == ReportErrorsAndStatisticsMode::kYes) {
15.  //omit.............................
16.    }
17.    return (result != nullptr);
18.  } In line 5, create the parser, namely, parser initialization. 1.  Parser::Parser(ParseInfo* info)
2.      : ParserBase<Parser>(info->zone(), &scanner_, info->stack_limit(),
3.                           info->extension(), info->GetOrCreateAstValueFactory(),
4.                           info->pending_error_handler(),
5.                           info->runtime_call_stats(), info->logger(),
6.                           info->script().is_null() ? -1 : info->script()->id(),
7.                           info->is_module(), true),
8.        info_(info),
9.        scanner_(info->character_stream(), info->is_module()),
10.        preparser_zone_(info->zone()->allocator(), ZONE_NAME),
11.        reusable_preparser_(nullptr),
12.        mode_(PARSE_EAGERLY),  // Lazy mode must be set explicitly.
13.        source_range_map_(info->source_range_map()),
14.        target_stack_(nullptr),
15.        total_preparse_skipped_(0),
16.        consumed_preparse_data_(info->consumed_preparse_data()),
17.        preparse_data_buffer_(),
18.        parameters_end_pos_(info->parameters_end_pos()) {
19.    bool can_compile_lazily = info->allow_lazy_compile() && !info->is_eager();
20.    set_default_eager_compile_hint(can_compile_lazily
21.                                       ? FunctionLiteral::kShouldLazyCompile
22.                                       : FunctionLiteral::kShouldEagerCompile);
23.    allow_lazy_ = info->allow_lazy_compile() && info->allow_lazy_parsing() &&
24.                  info->extension() == nullptr && can_compile_lazily;
25.    set_allow_natives(info->allow_natives_syntax());
26.    set_allow_harmony_dynamic_import(info->allow_harmony_dynamic_import());
27.    set_allow_harmony_import_meta(info->allow_harmony_import_meta());
28.    set_allow_harmony_nullish(info->allow_harmony_nullish());
29.    set_allow_harmony_optional_chaining(info->allow_harmony_optional_chaining());
30.    set_allow_harmony_private_methods(info->allow_harmony_private_methods());
31.    for (int feature = 0; feature < v8::Isolate::kUseCounterFeatureCount;
32.         ++feature) {
33.      use_counts_[feature] = 0;
34.    }
35.  } From line 8 to line 18, take out the compilation information, such as scanner, and compilation mode. From line 9 to line 23, the important stuff is can_compile_lazily. Line 25 enables the native commands that start with %. Summary V8 uses UTF16 to encode JavaScript source code; V8 uses v8::internal::source to manage our JavaScript code; First, look up the compilation cache, then start up the compiler if the cache miss; The scanner is passive and the parser is active. 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 : WeChat Email v8blink@outlook.com Also Published here

Understanding Chrome V8 - Chapter 20: How Compilers and Parsers Work

Welcome to other chapters of Let’s Understand Chrome V8 In this article, we’ll talk about the source code and important data structures of V8’s JS parser. Our test case is the same as in . Chapter 4 1. Parser In V8, the parser is the next stage of the scanner, and the token output by the scanner is the input of the parser. During compiling JS, the parser will frequently call the scanner to generate the token. With the help of our case, let’s analyze the code of the parser. The following is DoParseProgram which is our start. The 6th line defines a result, which will save the AST tree. After DoParseProgram() exit, the AST is generated. In our use case, the following method will be called. ParseStatementList() starts parsing program statements. In the third line of code, peek() takes out the type of the token word. For our case, the type obtained by the peek is Token::FUNCTION, so the result of while is false, and then jumps to line 22 and executes ParseStatementListItem(), which is defined below. Line 3, Consume() is the token cache we mentioned in the third article. It takes out a token from the cache, and when the cache is missing, it calls the Scanner to generate tokens. For our case, after knowing that the token type is a function, we need to determine which FunctionKind the function is. The specific code of FunctionKind is as follows: Don’t confuse FunctionKind with Token::FUNCTION, the token is stuff in compilation technology, but FunctionKind belongs to ECMA specification. In our case, the FunctionKind of the function is KnormalFunction, so the parser will analyze the Token::IDENTIFIER of this function, the code is below. Note: CurrentSymbol judges whether it is single-byte or double-byte. In our case, JsPrint is a single byte. Figure 1 is the call stack of CurrentSymbol. At this point, Parse is complete. In our case, the three most important things Parse does: In the JS source code, when Parser meets the function token, it will know that the next token is a function; Judging FunctionKind, is it asynchronous or something else? Our case is kNormalFunction. Take out the next token JsPrint, and parse it. 2. Lazy Parser What is a delay parser? It is an optimization technique in V8, that is, the code is not parsed until it is executed. As we all know, because of control conditions, not all code will be executed. Based on this, V8 uses a delay parser and delay compilation to improve efficiency. In our case, the JsPrint’s type is kNormalFunction, which is the function to be executed immediately, so we need to parse it immediately. After analyzing the function name (JsPrint), ParseFunctionLiteral will be called, which is responsible for parsing the function body. Figure 2 is the case, you can see that JsPrint will not be executed immediately, meeting the delay parse condition. We can also get the same conclusion from the JS code: console.log() is executed first, and then console.log() calls JsPrint, so it satisfies the delay parse condition. Debugging the program is the best way to verify the above conclusions. By debugging the ParseFunctionLiteral(), and watching the is_lazy and is_top_level members, you will also agree with the above conclusion. Figure 3 is the ParseFunctionLiteral’s call stack. Figure 4 is the abstract syntax tree of JsPrint. 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 This article was first published here.

Let’s Understand Chrome V8 — Chapter 5: Compilation Parser

Today, I want to talk to you about the life of information and how that fundamentally impacts remote working. Over these last few weeks, we were caught up with all that's happening in the world, and my email newsletters have, of course, been speaking to that topic. I realised way too much content on the net is floating around the same and you probably have had enough of it. So, from here on out, I'm going to talk only about core remote working concepts. OK, let's get to this week's discussion. Knowledge decays You would have probably heard a lot of people say that we are living in the 'Information Age'. Data is everywhere and is key to succeed, be it for individuals or organisations. At the same time though, information or knowledge rapidly becomes outdated, irrelevant or disproven. This is a very pertinent problem organisations face since there are many factors that accelerate the decay of knowledge - employees leaving, improper documentation, 1-on-1 knowledge sharing, among others. For remote teams, knowledge decay is more concerning since there are added constraints of timezone issues, lack of shoulder taps, in-person knowledge transfers etc. So, it's important that we are aware of this knowledge decay, the contributing factors and how we can possibly prevent or extend the decay. Half-life of knowledge In nuclear physics, the half-life of a radioactive substance refers to the amount of time taken for it to reduce (decay) to half. Similarly, , information or facts refers to the amount of time needed for half of the knowledge to become irrelevant or outdated. half-life of knowledge The half-life of knowledge or half-life of facts is the amount of time that has to elapse before half of the knowledge or facts in a particular area is superseded or shown to be untrue. These coined terms belong to the field of quantitative analysis of science known as scientometrics. ( wikipedia ) Let me use a few examples to explain this. A company's press release, or an investor update, will typically have a half-life of a couple of weeks. On the other hand, your company's wiki, or your SOPs, will have a half-life of ~0.5-1 years. Types of knowledge categorises knowledge into 3 discrete forms: This article - Knowledge that employees actively use but may not be consciously aware of (e.g. a particular way of using a tool or a specific workflow) Unconscious Knowledge - Methods, processes, SOPs etc. that employees know Conscious Knowledge - Everything that's captured in an accessible and tangible form Recorded Knowledge You would have already guessed that recorded knowledge will have the highest half-life while unconscious knowledge will have the lowest. Efficient knowledge transfer and increasing the half-life of knowledge Our aim, therefore, should be to facilitate the flow or transfer of knowledge, primarily from unconscious to recorded. In effect, this will increase the half-life of knowledge and ensure that your company's information stays relevant and updated for long. Here are just a few things you can implement right away to do so: Default to asynchronous Instant messages or chats typically have a shorter half-life, ~5-10 mins whereas long-form messages have half-lives of at least a few hours. Also, when you default to asynchronous long-form conversations, you in turn encourage more thoughtful responses and reduce back & forth. Share knowledge across teams This is the very first step towards expanding your company's recorded knowledge. Individual teams often have a lot of data and insights with them, which if shared across the company, can help build a solid knowledge base. Start building a learning organisation Going a step further, you should aim towards building a culture of learning in your organisation. beautifully explains what a learning organisation is and how it facilitates continuous learning of your employees. This HBR article Use a collaborative work management tool Instant messaging tools like Slack are great and an essential part of your stack. However, you should also invest in collaborative work management tools like Notion or Slite to store, maintain, prioritise and share knowledge. Remote Working Chronicles - ' ' Related: A self-taught programmer and travel-holic who adores the flexibility of remote work Joe Barbour is a self-taught programmer and is now the CTO of Knoma.io, a fintech startup based in London. His journey is full of twists and turns which starts with his fascination for computers at a very early age to publish a popular iOS app (10K downloads before it was taken down). Instead of pursuing a formal education in computer science, he went to study film in London and also dropped off early on. Shortly after, Joe decided to pursue his passion of travelling and joined a remote travel group for a 6-month tour. This was the inflection point in his career, post which he has travelled 30 countries till date. Joe's journey is compelling, doesn't shy away from mistakes and teaches us important lessons in remote working. Intrigued to know the details? Read the full story here . As always, here are our : ✔️ helps you plan, organise & track clients, tasks, projects etc. ✔️ is a tool for organising creative projects ✔️ is a communication tool with infinite level task structure ✔️ is a Chrome extension for screen & camera recording ✔️ is a tool for pair programming top-picks of remote-first products Lumeer Milanote Tangish Clapboard CodeTogether Want this in your inbox every Wednesday? Subscribe here .

Using Efficient Knowledge Transfer to Increase Information's Half-Life: Remote Weekly #26 📝

Introduction According to Smart Insights, 63% of customers expect companies to provide customer service across all their social media channels and to use social networks to connect with brands. 42% of customers expect a response to their posts or messages within one hour. Businesses can invite customers to join them in a safer, cheaper channel, one with richer experiences and one that is convenient for users by publishing links that call for action and conversations. By adopting a multi-channel approach to marketing, sales, and customer service, businesses can create an integrated and coherent customer experience wherever they go. You can use built-in text, voice, social and instant messaging channels to provide customers with a seamless experience. For example, customers can move from their desktop or phone to a physical store to experience similar services, but the ultimate goal of omnichannel customer service is to integrate all public relations methods into a board, thereby avoiding tacit engagement. Why Adopt an Omnichannel Approach? What are the Benefits? With an omnichannel approach, companies can operate across a single channel and deliver a high-quality customer experience across all touchpoints. Simply put, it allows customers to start their brand experience on one channel and continue across all channels. An omnichannel customer experience means that your customers interact with your business through multiple channels such as ; it also plays a part in a seamless customer journey. knowledge base software Omnichannel means going one step further and delivering your customers with a consistent communication journey, with a conversation history and context that moves with them from channel to channel. The purpose of an Omnichannel experience is to enable your customers with ease and fluidity to interact directly with your brand by switching channels at their own will. When companies use an omnichannel approach to customer experience, they end up with a silent conversation that combines all channels and the customer context that comes from all channels into a single source of truth. For customer service staff, this little thing called ''Omnichannel customer experience'' enables them to support the same customer no matter what channel or mix they use. Businesses can retrieve user data from their various channels (websites, social media, email, sales channels) to take their customer service to the next level. Based on these insights, you can create a process for providing support across all the right customer service channels: self-service portals, chatbots, live chats, visual engagement tools, etc. Creating a Sturdy Omnichannel Strategy To ensure great omnichannel customer service, companies need to train their customer-focused teams to understand different customer data points and interactions. A well-designed omnichannel strategy ensures that your team can deliver personalized and consistent service across all channels, with the company-wide goal of increasing customer satisfaction. The customer service software you use to build your omnichannel experience lets you know which areas are performing well and which require improvement. Omnichannel Customer Experience is the way that customers interact with your brand through the channels of their choice, also known as Omnichannel Experience or Omnichannel Customer Service. It is one of the most consistent brand channels in all phases of the customer journey - including advertising - search engine results - social brand presence - website - the shopping experience itself, email verification - order confirmation - product shipment - receipt - support - products and customer service. Omnichannel customer service integrates text, social media, email, and instant messaging to provide a unified brand experience where customers can switch between multiple channels and experience quality service. On the other hand, the Omnichannel experience involves a multi-channel approach to sales, customer service, and marketing. Social media channels for omnichannel customer experiences include your website, lead flow, sales process, and customer service. What the best omnichannel experiences have in common is that they create a coherent journey for the customer while they cycle through the channels. Whether the customer calls, sends an email or SMS, or communicates with others via incoming digital channels, the agent can see the entire business trip and react quickly and effectively to solve problems. Omni-channel service interactions are effortless and lead to better customer experience, higher customer ratings, and a stronger brand reputation by following customers from channel to channel and collecting data on the go. Multi-channel services can be taken to the next level with an omnichannel solution that is integrated across channels to provide a consistent customer experience. If you look at Accenture's statistics, which show that 89% of consumers are frustrated when they have to repeat their questions to multiple customer service representatives, you can see the value of perfect omnichannel integration. Omni-Customer Service defines a synchronized operating model in which all communication channels are aligned to provide consistent support. Conclusion It requires a company to define an omnichannel customer service strategy that creates a better experience for customers, agents, and other teams within the company. The omnichannel solution includes personal and online reviews as well as phone, mobile and social media engagement with your customers to give you a holistic view of customer experience, ensure consistency across all your channels and provide guidance to improve your omnichannel strategy. It means businesses are changing with technology and starting to deliver more omnichannel customer service experiences. Companies that create omnichannel customer experiences use a multi-channel approach that combines sales, marketing, and customer service platforms. Bank of America is taking a similar approach to an omnichannel experience, while Walgreens is giving customers access to its services through multiple devices in their own time. Whether we're thinking about desktop experiences, mobile experiences, tablet experiences, or Apple Watch experiences, we need to take a holistic approach to omnichannel experiences so that customers can use what they want.

Using an Omnichannel Approach for Exceptional Customer Experience

Marketing was a one-way communication until not very long ago. Consumers were only passive participants with the media forms limited to audio-visual formats. The advent of smartphones and computers has made marketing a two-way communication with active consumer participation. Before understanding Customer Engagement's impact on Customer Experience, we need to get a clear picture of the two. is the metric of customer interaction in any form with a brand; it could be in the form of social media likes, follows, reshares, or be more direct like customer support or messages. Decision trees for contact centers help to Increase Customer Engagement and awareness of a brand. Customer Engagement has become a focus area for companies in recent years with a boom in digital marketing. Engagement also displays the connection and a level of trust between a brand and its customers. Customer Engagement is a holistic brand perception that covers all aspects from marketing and sales to support. Any interaction between a customer and a brand adds to the overall customer experience. Customer Experience is a deciding factor for retaining customers. Customer Experience is multi-dimensional, with aspects like the longevity of engagement, repetitive engagement and the volume of engagement affects the overall customer experience score. Customer Experience · Customer Engagement v/s Customer Experience Customer engagement values users as active participants in the process, while in customer experience, the customer is an active recipient and less of a participant. · How Customer Engagement and Customer Experience Go Hand in Hand Customer Engagement and focus more on enhancing brand awareness and keeping the existing customers occupied. When more and more people engage with a brand, they tend to use the product and service more, leading to increased feedback. Suppose the product or service stands tall to the consumers' expectations and the organization successfully follows up with a healthy engagement on digital and offline platforms. In that case, the customer experience is bound to go up. A good customer experience is vital for good customer satisfaction scores. · Customer Engagement - An Enabler for Exemplary CX Customer engagement is a precursor for Customer Experience. Healthy engagement influences a good CX score. There are countless ways to empower customer engagement, and every little bit adds up to a quality customer experience. Let's go through a few ways to enhance your customer engagement. · Unique Style and Personality Customers love relatable content, which makes them feel connected on a deeper level. Having a unique digital or offline presence and offering customers something different helps increase engagement and audience retention. Publishing content that does not just revolve around the product or service but adds value to the consumer's lives is vastly appreciated. · Feedback and Appreciation Indulging in and seeking constant feedback on the experience helps the organization be on track and alter things that might not be working. Thanking customers regularly and offering them a personalized feel also goes a long way in implementing a good customer experience. · Research and Analysis Constantly analyzing how digital media is evolving and adapting a specific strategy after thoroughly studying user behavior has long-term gains. Delivering on changing consumer demands and offering something which captures their imagination helps in greater engagement. · Innovation and Experimentation Constantly updating and innovating on existing ways of interaction and coming out with unique experiences for users could reap huge rewards. Rapid technological advancements have made it possible to tinker with existing methods of consumer engagement. Conclusion The approach for a spectacular Customer Experience depends on many variables starting from the specific industry to the target audience. A happy user who isn't engaging with the company might be ready to do so given the proper and conducive invitation. Regular engagement activities bring immediate support for Customer Experience. Loyalty Programs and online competitions are a great way to keep in touch with the existing audience. An engagement endeavor should never be forced on a consumer; it should come naturally. It is important to remember that the objective of engagement and, subsequently, a good customer experience, should arrive on the consumers' terms. Customer Experience Management (CEM) accommodates customers, knowledge segmentation, customer journey mapping, brand identity, customer satisfaction, and loyalty measurements. Tools integrated into customer support software guide support agents to connect with customers on their preferred touchpoints. Customer experience management helps in: Personalizing brand experience and influencing decisions from purchasing to the rating. Creating an agile, productive, and flexible environment through which support agents solve queries quickly. Keeping knowledge in categories that increase the findability experience during resolutions, saving support agents from getting into complex situations. The plays a vital role in implementing the above ideas into digital techniques and helps companies stay relevant in a rapidly changing digital space. Customer service software could be a breakthrough implementation for an organization looking to revitalize its Customer Experience. knowledge base for customer service

Customer Engagement is the Key to Achieving Better CX

, here I will explain you how Loud Love Jewelry company successfully designs Monitoring and Evaluation (M&E) System and what are the steps to learn from previous strategies. Before launching into the detail, please note that the development of a M&E system is a participatory exercise. Loud Love Jewelry, LLC is a fine Jewelry company Staff at different levels of the organisation like who will be expected to maintain or use the new M&E system should always be consulted. This might include staff at head offices as well as secretariats, staff in regional or country offices, and staff at programmer or project level. Loud Love Jewelry Define the scope and purpose This step involves identifying the evaluation audience and the purpose of the M&E system.  M&E purposes include supporting management and decision-making, learning, accountability and stakeholder engagements. Will the M&E be done mostly for learning purposes with less emphasis on accountability?  If this is the case, then the M&E system would be designed in such a way as to promote ongoing reflection for continuous program improvement. If the emphasis is more on accountability, then the M&E system could then collect and analyse data with more rigor and  to coincide with the reporting calendar of a donor. It is important that the M&E scope and purpose be defined beforehand, so that the appropriate M&E system is designed. It is of no use to have a M&E system that collects mostly qualitative data on an annual basis while your ‘evaluation audience’ (read: 'donor') is keen to see the quantitative results of Randomised Controlled Trials (RCTs) twice a year. 'Be on the same page as the ‘evaluation audience'' Define the evaluation questions Evaluation questions should be developed up-front and in collaboration with the primary audience(s) and other stakeholders who you intend to report to. Evaluation questions go beyond measurements to ask the higher order questions such as whether the intervention is worth it or if it could have been achieved in another way (see examples below). Identify the monitoring questions For example, for an evaluation question pertaining to 'Learnings', such as "What worked and what did not?" you may have several monitoring questions such as "Did the workshops lead to increased knowledge on energy efficiency in the home?" or "Did the participants have any issues with the training materials?". The monitoring questions will ideally be answered through the collection of quantitative and qualitative data. It is important to not start collecting data without thinking about the evaluation and monitoring questions.  This may lead to collecting data just for the sake of collecting data (that provides no relevant information to the program). Identify the indicators and data sources In this step you identify what information is needed to answer your monitoring questions and where this information will come from (data sources). It is important to consider data collection in terms of the type of data and any types of research design. Data sources could be from primary sources, like from participant themselves or from secondary sources like existing literature. You can then decide on the most appropriate method to collect the data from each data source. For getting the better sense of effective code review reporting you must learn in order to identify the indicators and data sources. best practices for code review “Data, data and more data” Identify who is responsible for data collection, data storage, reporting, budget and timelines It is advisable to assign responsibility for the data collection and reporting  so that everyone is clear of their roles and responsibilities. Loud Love Jewelry collection of monitoring data may occur regularly over short intervals, or less regularly, such as half-yearly or annually. Likewise the timing of evaluations (internal and external) should be noted. You may also want to note any requirements that are needed to collect the data (staff, budget etc.). It is advisable to have some idea of the cost associated with monitoring, as you may have great ideas to collect a lot of information, only to find out that you cannot afford it all. Identify who will evaluate the data and how it will be reported In most programmes there will be an internal and an independent evaluation (conducted by an external consultant). For an evaluation to be used (and therefore useful) it is important to present the findings in a format that is appropriate to the audience. A 'Marketing and Dissemination Strategy’ for the reporting of evaluation results should be designed as part of the M&E system. ‘Have a strategy to prevent persons from falling asleep during the presentation of evaluation findings’ Decide on standard forms and procedures Once the M&E system is designed there will be a need for planning templates, designing or adapting information collection and analysis tools, developing organisational indicators, developing protocols or methodologies for service-user participation, designing report templates, developing protocols for when and how evaluations and impact assessments are carried out, developing learning mechanisms, designing databases. However, there is no need to re-invent the wheel. There may already be examples of best practice within an organisation that could be exported to different locations or replicated more widely. This leads to step 9. Use the information derived from Steps 1- 7 above to fill in the 'M&E System'template You can choose from any of the templates presented in this article to capture the information. Remember, they are templates, not cast in stone. Feel free to add extra columns or categories as you see fit. Integrate the M&E system horizontally and vertically Where possible, integrate the M&E system horizontally (with other organisational systems and processes) and vertically (with the needs and requirements of other agencies).  Simister, 2009 Try as much as possible to align the M&E system with existing planning systems, reporting systems, financial or administrative monitoring systems, management information systems, human resources systems or any other systems that might influence (or be influenced by) the M&E system. Pilot and then roll-out the system Once everything is in place, the M&E system may be first rolled out on a small scale, perhaps just at the Country Office level. This will give the opportunity for feedback and for the ‘kinks to be ironed out’ before a full scale launch. Staff at every levels be should be aware of the overall purpose(s), general overview and the key focus areas of the M&E system. It is also good to inform persons on which areas they are free to develop their own solutions and in which areas they are not. People will need detailed information and guidance in the areas of the system where everyone is expected to do the same thing, or carry out M&E work consistently. This could include guides, training manuals, mentoring approaches, staff exchanges, interactive media, training days or workshops. Final Thoughts In conclusion, my view is that a good M&E system should be robust enough to answer the evaluation questions, promote learning and satisfy accountability needs without being so rigid and inflexible that it stifles the emergence of unexpected (and surprising!) results. Thanks for reading.

Stories, News & Mentions about KNOEMA

Knoema’s Stories on HackerNoon

Knoema's News & Mentions