NomadHer has a mission of empowering women through travelling

NomadHer

nomadher

Real-world data show lower levels of in the newer patients as compared to the clinical trials. Medication adherence is affected by a wide variety of factors, including health disparities, the nature of the disease, treatment complexities, and more. Declining levels of adversely impact patient outcomes and product performance alike. patient adherence patient adherence Research shows that medication nonadherence affects as many as 40% to 50% of patients suffering from chronic illnesses¹. Most pharma companies are focusing on and exploiting , in particular, to explore and understand the factors hindering patient adherence. data analytics pharma analytics, Using pharma analytics to study the factors affecting patient adherence Analyses of huge volumes of diverse datasets across geographies, diseases, and other factors helped in the understanding of what factors impact . Some of them include: patient adherence Financial burden The economic distress that the patient faces due to the expensive dosages of medicines can lead to missed doses or even complete medication drop-offs. This is particularly common in patients of low-income groups suffering from rare diseases like cancer which involve expensive therapies and ongoing treatment at substantial out-of-pocket costs. Patients usually do cost-benefit analyses and decide to stop the treatment owing to excessive costs. Physicians When a drug is relatively new or has poor safety profiles, it becomes difficult for physicians to work confidently with such medications. In addition, a physician’s lack of exposure to certain therapies may also affect their ability in handling patients with high-risk illnesses. Patient Analyses indicate that prolonged tests, consultations, and various therapies put a strain on the patient and result in them getting disengaged. Conditions like polypharmacy which requires patients to remember multiple medications, could gradually lead to forgetfulness, disinterest, and eventually an overall deterioration in the patient outcomes. Brand Complexities in drug administration, such as ease of intake (oral Vs intravenous) and additional instructions on the medications (crushing tablets, opening or closing capsules, etc.), also are responsible for improving patient adherence to medication. Analyses show that medication’s tolerability profile and side effects that it results in are primary factors in the patient’s decision towards medication regimens. Social Determinants of Health Insights point to the fact that social determinants play a key role in creating awareness about the immediate care and treatment available to patients. In the case of certain populations, including low-income groups, underprivileged sections of the community, elderly people, and others, there’s a lot of hardship in dealing with the complexities of the treatment procedures and undergoing continuous medication. Role of data analytics in improving patient adherence By incorporating diverse datasets ( such as claims data , EHR etc ) , patient drug fill days, and therapy durations, along with the use of predictive analytics we could pave the way for improving patient medication adherence. — An insight obtained from analytics on patient demographics can help healthcare providers plan better and also create customized intervention strategies. Understanding patient demographics — While patient adherence might be adversely affected due to the financial burden on patients, prior analysis and ascertaining appropriate cost-sharing options can prepare them and improve medication adherence. Analyzing patient copays — Using data-driven insights, the purchasing cycle for patient prescription medications can be planned well in advance to ensure smoother availability of the medications in required dosages. Arranging patient prescription supply Data analytics, including machine learning and plays a vital role in understanding the patient adherence factors and thereby taking measures towards improving them. Taking into consideration the below factors could considerably enhance patient adherence: pharma analytics, Use diverse datasets Analyses produce meaningful insights only when performed with high-quality data. Predictive analytics and machine learning techniques also yield accurate results only when superior data is used. Investing in master data management and big data capabilities can ensure richer data quality and diversity. Working with third-party vendors to gather data and using non-conventional datasets like Census, Bureau of Labor Statistics , pharmacy and medical claims , EHR etc. provides better and more reliable results. Automate your predictive analytics The traditional methods used in predictive analytics are highly time-consuming and demand a lot of expertise. Using the modern techniques of and automation capabilities in modeling proves easier and produces more accurate outcomes. machine learning in healthcare Converting outputs to strategy Extensive datasets and advanced modeling techniques will be truly useful only when used in conjunction with industry expertise. Translating the complex modeling results and statistical conclusions into an intervention strategy that helps non-data science stakeholders get a clear picture is recommended. This would, in turn, increase the shareholders’ trust and pave the way for newer dimensions. Final Thoughts plays a significant role in analyzing and interpreting the causes associated with levels. In addition, also gives actionable insights into the impact of medication adherence on sales and marketing functions. Data analytics patient adherence commercial analytics References [1] Fred Kleinsinger , ( Jul. 2018 ), The Permanente Journal The Unmet Challenge of Medication Nonadherence [2] Brody JE. New York, NY: The New York Times; 2017. The cost of not taking your medication [Internet] [3] Peterson AM, Takiya L, Finley R. Meta-analysis of interventions to improve medication adherence. 2003 Apr 1;60(7):657–65. Am J Health Syst Pharm. [4] Wu JR, Moser DK. Medication adherence mediates the relationship between heart failure symptoms and cardiac event-free survival in patients with heart failure. 2018 J Cardiovasc Nurs. [5] Kleinsinger F. Working with the noncompliant patient. 2010 Spring Perm J.

Leveraging Data Analytics to Improve Patient Adherence

245 Tools & Resources for Travelers and Digital Nomads

Poverty, corruption, inflation, and high unemployment levels are some of the problems that are common to developing countries around the world. Years of political instability and poor governance has plunged some nations into devastating economic crisis. With the fast-paced nature of growth and advancements in other more developed parts of the world, the prospects sometimes do seem bleak for these developing nations. However, the emergence of blockchain technology and cryptocurrency has brought renewed enthusiasm about the prospects of a revival in these countries. The focus of this article is to examine possible answers to the big question of how cryptocurrency can be of use to these countries. Reduce Remittance Cost The global remittance system is based almost entirely on the activities of citizens of developing countries who are immigrants in the developed world. From time to time, these individuals have to send money back home. In order to do so, they have to rely on intermediary services like Western Union, Money Gram, Uni Transfer etc. These platforms collect fees and charges which considerably increase the cost of such transactions. According to figures released by the , the recorded remittance to developing countries in 2016 was about $441 billion, more than half of the total recorded global remittance. The figures also revealed that global remittance fee for Sub-Saharan was an average of $20 per $200 which was the highest in the world. World Bank in 2017 With cryptocurrency, the cost of remittance can be drastically reduced as well as the hassle required to receive the international money transfer. Already, there are a number of platforms in Africa and Southeast Asia that are offering such services. , a Nigerian based blockchain-powered remittance system that will offer zero-cost, cross-border transactions launched their ICO in January 2018. In the Philippines, there is a platform called which offers more efficient remittance services. Users of the Rebit platform can send money at a much lower than rate than conventional money transfer services. SureRemit Rebit 2. Improve Financial Inclusion Lack of financial inclusion is a massive problem in many low-income countries around the world. According to the , there are more than 2 billion unbanked people worldwide. The majority of this number live in developing countries around the world. In countries like Pakistan, Chad, Burundi, Niger, Yemen, and Cameroon, less than 15 percent of the adult population have bank accounts. Even the ones that do have bank accounts are said to be underbanked meaning that they don’t have access to premium banking services. This lack of access to banking instruments precludes them from being able to participate in global commerce. World Bank With cryptocurrency services like and , millions of unbanked people can finally get access to banking services and financial instruments through cryptocurrency. These platforms are offering cryptocurrency banking services through mobile phone apps. Telecommunications has been able to achieve a much greater market penetration than banking services. These crypto banking platforms are using the reach of telecoms to take financial emancipation to the doorsteps of the unbanked and underbanked. The end result is greater financial inclusion. MPesa BitPesa There is also the added incentive of empowering small and medium-scale businesses. Local merchants can begin to think global in terms of imports and exports. Banks in developing countries like Nigeria are notorious for their unwillingness to give loans to small-scale businesses even when suitable collaterals are provided. With cryptocurrency, platforms like Mpesa, BitPesa, and Nebeus can offer crypto-backed loans to small-scale and medium-scale merchants. This will go a long way in getting them started in the import and export business which is a fundamental part of national commerce. Another aspect of financial inclusion that many places in Africa and the rest of the developing world lack is access to international payment systems. Global commerce is largely denominated in the US Dollar and it requires specialized systems for payments and receipts. This is often a challenge for many merchants in developing countries as they have no access to foreign exchange as well as the means to pay and receive money in foreign currency. BitPesa is leading the charge in providing solutions to these problems, especially in Sub-Saharan Africa. In Indonesia, there is a service called TenX that provides a digital wallet which allows users to receive Visa card payments. 3. Fight Against Corruption Corruption is one of the major banes of low-income countries around the world. Lack of economic democratization and corrupt government officials have evinced a design that has left the collective commonwealth of these countries in the hands of a few people. The middle-class has all but disappeared and more than 70 percent of the population live below the poverty line. In developing nations, misappropriation of state funds by corrupt government officials is a big problem. Nonadherence to project contracting best practices results in capital projects being handled by cabals who divert state funds for their own personal interests. The use of cryptocurrencies, especially those built upon smart contract protocol will allow for a more transparent contract system. With records on the blockchain being public, citizens will be able to monitor the way in which state funds are being utilized. Another area of interest in the fight against corruption by cryptocurrencies in developing countries is in the election process. One trademark of the political landscape of the less developed nations is the fact that electoral bodies are largely partisan and hardly ever neutral. As such, elections are fraught with discrepancies that undermine the fidelity of the process. Cryptocurrency and blockchain technology can be used to make elections in these countries to become free and fair to the citizens being able to freely exercise their franchise. These are just some of the ways in which cryptocurrencies could be of benefit to developing nations around the world. Cryptocurrency and blockchain technology continues to be at the heart of public consciousness all over the globe. It will surely be interesting to see to what extent developing countries apply cryptocurrency solutions to their problems. Keen to find out more about FundYourselfNow? Join our crowdfunding revolution conversation on our Telegram group, or follow us on Twitter.

How Cryptocurrency Can Help Developing Countries

GM. It's Crypto Player One, the first and only daily newsletter on crypto gaming. Here's what we've got for you today: Daily Trivia. The first web3 sports betting exchange is here. In Other News. Daily Trivia The video game "Fight Night 2004" is based around which sport? Scroll down to find out the answer. The First Fully Licensed Web3 Sports Betting Exchange is Here BetDEX is the first licensed sports betting exchange built on the blockchain. It's now in open beta and will launch on Solana on November 17, at the beginning of the World Cup. Users can place bets on football matches. They won't have to pay any fees for betting on World Cup matches. BetDEX is built on the Monaco protocol and will expand to tennis and cricket next in 2023. The Monaco Protocol is a decentralized liquidity network for exchange-based apps on Solana. Right now, BetDEX is available in Europe, Asia, South America, and Africa. You can play around with the Beta version here. In Other News Immutable has released a tool to help enforce NFT royalties on Ethereum. Answer Boxing Want to Stay On Top of All Things Crypto Gaming and NFTs? Sign up for the daily newsletter - it’s free! Photo by on Travel Nomades Unsplash

🎮 Sports Betting is Finally Entering Web3

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 For performance reasons, V8 uses the compilation cache to hold the SharedFunction which is the compiler result, the cache returns the result directly once the same JavaScript code is compiled again. You may ask why the same code is compiled again. Compile first, then execute — this is the pipeline of V8. Even the exact same code, the same function, still needs to be sent to the compiler, but not always recompiled. Actually, JavaScript code may change during execution, so the first action always is that we get the JavaScript code’s hash-value from the compilation cache, return the SharedFunction if the cache is hit, and recompile the JavaScript conversely. 1. Initialization and Filling The Isolate, which is the V8 virtual machine instance, is responsible for initializing the CompilationCache, isolate::Init as shown below: bool Isolate::Init(ReadOnlyDeserializer* read_only_deserializer,
                   StartupDeserializer* startup_deserializer) {
//omit...................
#define ASSIGN_ELEMENT(CamelName, hacker_name)                  \
  isolate_addresses_[IsolateAddressId::k##CamelName##Address] = \
      reinterpret_cast<Address>(hacker_name##_address());
  FOR_EACH_ISOLATE_ADDRESS_NAME(ASSIGN_ELEMENT)
#undef ASSIGN_ELEMENT

  compilation_cache_ = new CompilationCache(this); The last line is now a CompilationCache, namely, initialization. Let’s dive into it in more depth. 1.  class V8_EXPORT_PRIVATE CompilationCache {
2.   public:
3.    MaybeHandle<SharedFunctionInfo> LookupScript(
4.        Handle<String> source, MaybeHandle<Object> name, int line_offset,
5.        int column_offset, ScriptOriginOptions resource_options,
6.        Handle<Context> native_context, LanguageMode language_mode);
7.    InfoCellPair LookupEval(Handle<String> source,
8.                            Handle<SharedFunctionInfo> outer_info,
9.                            Handle<Context> context, LanguageMode language_mode,
10.                            int position);
11.    MaybeHandle<FixedArray> LookupRegExp(Handle<String> source,
12.                                         JSRegExp::Flags flags);
13.    void PutScript(Handle<String> source, Handle<Context> native_context,
14.                   LanguageMode language_mode,
15.                   Handle<SharedFunctionInfo> function_info);
16.    void PutEval(Handle<String> source, Handle<SharedFunctionInfo> outer_info,
17.                 Handle<Context> context,
18.                 Handle<SharedFunctionInfo> function_info,
19.                 Handle<FeedbackCell> feedback_cell, int position);
20.    void PutRegExp(Handle<String> source, JSRegExp::Flags flags,
21.                   Handle<FixedArray> data);
22.    void Clear();
23.    void Remove(Handle<SharedFunctionInfo> function_info);
24.    void Iterate(RootVisitor* v);
25.    void MarkCompactPrologue();
26.    void Enable();
27.    void Disable();
28.   private:
29.    explicit CompilationCache(Isolate* isolate);
30.    ~CompilationCache() = default;
31.    base::HashMap* EagerOptimizingSet();
32.    static const int kSubCacheCount = 4;
33.    bool IsEnabled() const { return FLAG_compilation_cache && enabled_; }
34.    Isolate* isolate() const { return isolate_; }
35.    Isolate* isolate_;
36.    CompilationCacheScript script_;
37.    CompilationCacheEval eval_global_;
38.    CompilationCacheEval eval_contextual_;
39.    CompilationCacheRegExp reg_exp_;
40.    CompilationSubCache* subcaches_[kSubCacheCount];
41.    bool enabled_;
42.    friend class Isolate;
43.    DISALLOW_COPY_AND_ASSIGN(CompilationCache);
44.  }; There’re three fundamentals of the above function that are important: 1. LookupScript() at line 3. It is used to look up the cache to take out the SharedFunction that holds the bytecodes corresponding to your JavaScript code. If hit, skip compilation into the execution unit directly. 2. PutScript() at line 13. If LookupScript misses, PutScript() puts the hash corresponding to your JavaScript code and the SharedFunciton that the compiler generates into the cache before execution. 3. LookupEval and PutEval at lines 7 and 16. They are the same as LookupScript and PutScript but specialize in the JavaScript eval method because the eval needs not only SharedFunction but also context. Let’s examine LookupScript in a little more depth: 1.  MaybeHandle<SharedFunctionInfo> CompilationCache::LookupScript(
2.      Handle<String> source, MaybeHandle<Object> name, int line_offset,
3.      int column_offset, ScriptOriginOptions resource_options,
4.      Handle<Context> native_context, LanguageMode language_mode) {
5.    if (!IsEnabled()) return MaybeHandle<SharedFunctionInfo>();
6.    return script_.Lookup(source, name, line_offset, column_offset,
7.                          resource_options, native_context, language_mode);
8.  }
9.  //..................separation..........................
10.  //..................separation..........................
11.  MaybeHandle<SharedFunctionInfo> CompilationCacheScript::Lookup(
12.      Handle<String> source, MaybeHandle<Object> name, int line_offset,
13.      int column_offset, ScriptOriginOptions resource_options,
14.      Handle<Context> native_context, LanguageMode language_mode) {
15.    MaybeHandle<SharedFunctionInfo> result;
16.    {
17.      HandleScope scope(isolate());
18.      const int generation = 0;
19.      DCHECK_EQ(generations(), 1);
20.      Handle<CompilationCacheTable> table = GetTable(generation);
21.      MaybeHandle<SharedFunctionInfo> probe = CompilationCacheTable::LookupScript(
22.          table, source, native_context, language_mode);
23.      Handle<SharedFunctionInfo> function_info;
24.      if (probe.ToHandle(&function_info)) {
25.        if (HasOrigin(function_info, name, line_offset, column_offset,
26.                      resource_options)) {
27.          result = scope.CloseAndEscape(function_info);
28.        }
29.      }
30.    }
31.    Handle<SharedFunctionInfo> function_info;
32.    if (result.ToHandle(&function_info)) {
33.  #ifdef DEBUG
34.      DCHECK(HasOrigin(function_info, name, line_offset, column_offset,
35.                       resource_options));
36.  #endif
37.      isolate()->counters()->compilation_cache_hits()->Increment();
38.      LOG(isolate(), CompilationCacheEvent("hit", "script", *function_info));
39.    } else {
40.      isolate()->counters()->compilation_cache_misses()->Increment();
41.    }
42.    return result;
43.  } We can find that the CompilationCache::LookupScript is only the entrance, and the key function, as well as the important code, are all in CompilationCacheScript::Lookup(). 1. In Lookup(), the argument source is the JavaScript that you as developers are actually writing, which is going to be compiled. 2. GetTable at line 20. It is the actual table that holds data into which PutScript put. 3. CompilationCacheTable::LookupScript at line 21. Look up the table for a result in which hit means a SharedFunction or miss is null. 4. In line 25: Check if the SharedFunction is the correct one depending on Origin. Let’s take a glance at HasOrigin. 1.  // We only re-use a cached function for some script source code if the
2.  // script originates from the same place. This is to avoid issues
3.  // when reporting errors, etc.
4.  bool CompilationCacheScript::HasOrigin(Handle<SharedFunctionInfo> function_info,
5.                                         MaybeHandle<Object> maybe_name,
6.                                         int line_offset, int column_offset,
7.                                         ScriptOriginOptions resource_options) {
8.    Handle<Script> script =
9.        Handle<Script>(Script::cast(function_info->script()), isolate());
10.    Handle<Object> name;
11.    if (!maybe_name.ToHandle(&name)) {
12.      return script->name().IsUndefined(isolate());
13.    }
14.    if (line_offset != script->line_offset()) return false;
15.    if (column_offset != script->column_offset()) return false;
16.    if (!name->IsString() || !script->name().IsString()) return false;
17.    if (resource_options.Flags() != script->origin_options().Flags())
18.      return false;
19.    return String::Equals(
20.        isolate(), Handle<String>::cast(name),
21.        Handle<String>(String::cast(script->name()), isolate()));
22.  } From line 1 to line 3, the comments provide the origin check rules. Specifically, the implementation is from line 14 to line 16. Next, let’s go into PutScript. 1.  void CompilationCache::PutScript(Handle<String> source,
2.                                   Handle<Context> native_context,
3.                                   LanguageMode language_mode,
4.                                   Handle<SharedFunctionInfo> function_info) {
5.    if (!IsEnabled()) return;
6.    LOG(isolate(), CompilationCacheEvent("put", "script", *function_info));
7.    script_.Put(source, native_context, language_mode, function_info);
8.  }
9.  //.......................separation............................
10.  void CompilationCacheScript::Put(Handle<String> source,
11.                                   Handle<Context> native_context,
12.                                   LanguageMode language_mode,
13.                                   Handle<SharedFunctionInfo> function_info) {
14.    HandleScope scope(isolate());
15.    Handle<CompilationCacheTable> table = GetFirstTable();
16.    SetFirstTable(CompilationCacheTable::PutScript(table, source, native_context,
17.                                                   language_mode, function_info));
18.  } As same as LookupScript(), the CompilationCache::PutScript is entrance, all important stuff is in CompilationCacheTable::PutScript. In PutScript, I would like to inform you that the cache table will be filling. Below is the CacheTable source code: 1.  // This cache is used in two different variants. For regexp caching, it simply
2.  // maps identifying info of the regexp to the cached regexp object. Scripts and
3.  // eval code only gets cached after a second probe for the code object. To do
4.  // so, on first "put" only a hash identifying the source is entered into the
5.  // cache, mapping it to a lifetime count of the hash. On each call to Age all
6.  // such lifetimes get reduced, and removed once they reach zero. If a second put
7.  // is called while such a hash is live in the cache, the hash gets replaced by
8.  // an actual cache entry. Age also removes stale live entries from the cache.
9.  // Such entries are identified by SharedFunctionInfos pointing to either the
10.  // recompilation stub, or to "old" code. This avoids memory leaks due to
11.  // premature caching of scripts and eval strings that are never needed later.
12.  class CompilationCacheTable
13.      : public HashTable<CompilationCacheTable, CompilationCacheShape> {
14.   public:
15.    NEVER_READ_ONLY_SPACE
16.    static MaybeHandle<SharedFunctionInfo> LookupScript(
17.        Handle<CompilationCacheTable> table, Handle<String> src,
18.        Handle<Context> native_context, LanguageMode language_mode);
19.    static InfoCellPair LookupEval(Handle<CompilationCacheTable> table,
20.                                   Handle<String> src,
21.                                   Handle<SharedFunctionInfo> shared,
22.                                   Handle<Context> native_context,
23.                                   LanguageMode language_mode, int position);
24.    Handle<Object> LookupRegExp(Handle<String> source, JSRegExp::Flags flags);
25.    static Handle<CompilationCacheTable> PutScript(
26.        Handle<CompilationCacheTable> cache, Handle<String> src,
27.        Handle<Context> native_context, LanguageMode language_mode,
28.        Handle<SharedFunctionInfo> value);
29.//omit......................
30.    }; From line 1 to line 11, the comments provide more corresponding explanations enough. Let’s go back to CompilationCacheScript::Put() and ahead to line 16 which is CompilationCacheTable::PutScript(). 1.  Handle<CompilationCacheTable> CompilationCacheTable::PutScript(
2.      Handle<CompilationCacheTable> cache, Handle<String> src,
3.      Handle<Context> native_context, LanguageMode language_mode,
4.      Handle<SharedFunctionInfo> value) {
5.    Isolate* isolate = native_context->GetIsolate();
6.    Handle<SharedFunctionInfo> shared(native_context->empty_function().shared(),
7.                                      isolate);
8.    src = String::Flatten(isolate, src);
9.    StringSharedKey key(src, shared, language_mode, kNoSourcePosition);
10.    Handle<Object> k = key.AsHandle(isolate);
11.    cache = EnsureCapacity(isolate, cache, 1);
12.    int entry = cache->FindInsertionEntry(key.Hash());
13.    cache->set(EntryToIndex(entry), *k);
14.    cache->set(EntryToIndex(entry) + 1, *value);
15.    cache->ElementAdded();
16.    return cache;
17.  } I think the important thing is that PutScript binds the JavaScript source and SharedFuncation as a hash pair as well as puts it into the cache, which the implementations are from line 9 to line 15. 2. Lookup and update Let’s go into Compiler::GetSharedFunctionInfoForScript. 1.   MaybeHandle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
2.       Isolate* isolate, Handle<String> source,
3.       const Compiler::ScriptDetails& script_details,
4.       ScriptOriginOptions origin_options, v8::Extension* extension,
5.       ScriptData* cached_data, ScriptCompiler::CompileOptions compile_options,
6.       ScriptCompiler::NoCacheReason no_cache_reason, NativesFlag natives) {
7.  //omit.....................
8.       if (extension == nullptr) {
9.         bool can_consume_code_cache =
10.             compile_options == ScriptCompiler::kConsumeCodeCache;
11.         if (can_consume_code_cache) {
12.           compile_timer.set_consuming_code_cache();
13.         }
14.         maybe_result = compilation_cache->LookupScript(//lookup is here.
15.             source, script_details.name_obj, script_details.line_offset,
16.             script_details.column_offset, origin_options, isolate->native_context(),
17.             language_mode);
18.         if (!maybe_result.is_null()) {
19.           compile_timer.set_hit_isolate_cache();
20.         } else if (can_consume_code_cache) {
21.  //omit
22.           if (CodeSerializer::Deserialize(isolate, cached_data, source,
23.                                           origin_options)
24.                   .ToHandle(&inner_result) &&
25.               inner_result->is_compiled()) {
26.             is_compiled_scope = inner_result->is_compiled_scope();
27.             DCHECK(is_compiled_scope.is_compiled());
28.     		//filling is here
29.             compilation_cache->PutScript(source, isolate->native_context(),
30.                                          language_mode, inner_result);
31.             Handle<Script> script(Script::cast(inner_result->script()), isolate);
32.             maybe_result = inner_result;
33.           } else {
34.             compile_timer.set_consuming_code_cache_failed();
35.           }
36.         }
37.       }
38.       return maybe_result;
39.     } In line 14, it means that we need to compile the JavaScript code if LookupScript is missing, so we skip to line 21 to perform compilation and generate inner_result. Then at line 29, put the inner_result into the cache. We can find that the innuer_result is just the maybe_result at line 32. Figure 1 shows the call stack. Besides LookupScript and PutScript, there are also LookupEval, PutEval as well as LookupRegExp, PutRegExp in V8. The workflow of them is the same as LookupScript and PutScript, please learn by yourself. 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: Also published . here

Understanding Chrome V8: Chapter 19: Compilation Cache — Make the Compiler Faster

Execution is responsible for executing the bytecode. In this paper, we’ll talk about the workflow from S to E and several kernel functions. Our test case: function JsPrint(a){
	if(a >5){
		return "Debug";
	}
}
console.log(JsPrint(6)); Workflow The GetSharedFunctionInfoForScript() compiles JS source code into bytecodes. 0.  MaybeHandle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
1.      Isolate* isolate, Handle<String> source,
2.      const Compiler::ScriptDetails& script_details,
3.      ScriptOriginOptions origin_options, v8::Extension* extension,
4.      ScriptData* cached_data, ScriptCompiler::CompileOptions compile_options,
5.      ScriptCompiler::NoCacheReason no_cache_reason, NativesFlag natives) {
6.  //.omit.............
7.    // Do a lookup in the compilation cache but not for extensions.
8.    MaybeHandle<SharedFunctionInfo> maybe_result;
9.    IsCompiledScope is_compiled_scope;
10.    if (extension == nullptr) {
11.      bool can_consume_code_cache =
12.          compile_options == ScriptCompiler::kConsumeCodeCache;
13.      if (can_consume_code_cache) {
14.        compile_timer.set_consuming_code_cache();
15.      }
16.      // First check per-isolate compilation cache.
17.      maybe_result = compilation_cache->LookupScript(
18.          source, script_details.name_obj, script_details.line_offset,
19.          script_details.column_offset, origin_options, isolate->native_context(),
20.          language_mode);
21.      if (!maybe_result.is_null()) {
22.        compile_timer.set_hit_isolate_cache();
23.      } 
24.    }
25.  //.....omit..............
26.    if (maybe_result.is_null()) {
27.      ParseInfo parse_info(isolate);
28.      // No cache entry found compile the script.
29.      NewScript(isolate, &parse_info, source, script_details, origin_options,
30.                natives);
31.      // Compile the function and add it to the isolate cache.
32.      if (origin_options.IsModule()) parse_info.set_module();
33.      parse_info.set_extension(extension);
34.      parse_info.set_eager(compile_options == ScriptCompiler::kEagerCompile);
35.      parse_info.set_language_mode(
36.          stricter_language_mode(parse_info.language_mode(), language_mode));
37.      maybe_result = CompileToplevel(&parse_info, isolate, &is_compiled_scope);
38.      Handle<SharedFunctionInfo> result;
39.      if (extension == nullptr && maybe_result.ToHandle(&result)) {
40.        DCHECK(is_compiled_scope.is_compiled());
41.        compilation_cache->PutScript(source, isolate->native_context(),
42.                                     language_mode, result);
43.      } else if (maybe_result.is_null() && natives != EXTENSION_CODE) {
44.        isolate->ReportPendingMessages();
45.      }
46.    }
47.    return maybe_result;
48.  } In the 17th line of code, lookup compilation_cache, cache hit indicates that there are already bytecodes, and don’t need to recompile. The 26th line of code indicates that cache miss, so call the CompileToplevel on the 37th line to generate bytecodes. Bytecode needs to be bound to a context before execution, as below: 0.  Local<Script> UnboundScript::BindToCurrentContext() {
1.    auto function_info =
2.        i::Handle<i::SharedFunctionInfo>::cast(Utils::OpenHandle(this));
3.    i::Isolate* isolate = function_info->GetIsolate();
4.    i::Handle<i::JSFunction> function =
5.        isolate->factory()->NewFunctionFromSharedFunctionInfo(
6.            function_info, isolate->native_context());
7.    return ToApiHandle<Script>(function);
8.  } After binding, we get an important member — JSFunction, which is the input expected by the execution. 0.  bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
1.                            Local<Value> name, PrintResult print_result,
2.                            ReportExceptions report_exceptions,
3.                            ProcessMessageQueue process_message_queue) {
4.    bool success = true;
5.    {
6.      PerIsolateData* data = PerIsolateData::Get(isolate);
7.      Local<Context> realm =
8.          Local<Context>::New(isolate, data->realms_[data->realm_current_]);
9.      Context::Scope context_scope(realm);
10.      MaybeLocal<Script> maybe_script;
11.      Local<Context> context(isolate->GetCurrentContext());
12.      ScriptOrigin origin(name);
13.      if (options.compile_options == ScriptCompiler::kConsumeCodeCache) {
14.  //.......omit
15.      } else if (options.stress_background_compile) {
16.  //.......omit
17.      } else {
18.        ScriptCompiler::Source script_source(source, origin);
19.        maybe_script = ScriptCompiler::Compile(context, &script_source,
20.                                               options.compile_options);
21.      }
22.      maybe_result = script->Run(realm);
23.  //......omit
24.      if (options.code_cache_options ==
25.          ShellOptions::CodeCacheOptions::kProduceCacheAfterExecute) {
26.        // Serialize and store it in memory for the next execution.
27.        ScriptCompiler::CachedData* cached_data =
28.            ScriptCompiler::CreateCodeCache(script->GetUnboundScript());
29.        StoreInCodeCache(isolate, source, cached_data);
30.        delete cached_data;
31.      }
32.      if (process_message_queue && !EmptyMessageQueues(isolate)) success = false;
33.      data->realm_current_ = data->realm_switch_;
34.    }
35.    DCHECK(!try_catch.HasCaught());
36.    return success;
37.  } The above function is the entrance for executing JS. Line 19 compiles the JS to bytecode. Line 22 executes the bytecode. Debug line 22 to step into the Run(realm). 0.  MaybeLocal<Value> Script::Run(Local<Context> context) {
1.    auto isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
2.    TRACE_EVENT_CALL_STATS_SCOPED(isolate, "v8", "V8.Execute");
3.    ENTER_V8(isolate, context, Script, Run, MaybeLocal<Value>(),
4.             InternalEscapableScope);
5.    i::HistogramTimerScope execute_timer(isolate->counters()->execute(), true);
6.    i::AggregatingHistogramTimerScope timer(isolate->counters()->compile_lazy());
7.    i::TimerEventScope<i::TimerEventExecute> timer_scope(isolate);
8.    auto fun = i::Handle<i::JSFunction>::cast(Utils::OpenHandle(this));
9.    i::Handle<i::Object> receiver = isolate->global_proxy();
10.    Local<Value> result;
11.    has_pending_exception = !ToLocal<Value>(
12.        i::Execution::Call(isolate, fun, receiver, 0, nullptr), &result);
13.    RETURN_ON_FAILED_EXECUTION(Value);
14.    RETURN_ESCAPED(result);
15.  } The 8th line casts this pointer to JSFunction. For our case, the variable fun is console.log(JsPrint(6)), then call the 12th line — call(). In call(), the Invoke() will be called which is below. 0.  V8_WARN_UNUSED_RESULT MaybeHandle<Object> Invoke(Isolate* isolate,
1.                                                   const InvokeParams& params) {
2.  //...............omit
3.    Object value;
4.    Handle<Code> code =
5.        JSEntry(isolate, params.execution_target, params.is_construct);
6.    {
7.      SaveContext save(isolate);
8.      SealHandleScope shs(isolate);
9.      if (FLAG_clear_exceptions_on_js_entry) isolate->clear_pending_exception();
10.      if (params.execution_target == Execution::Target::kCallable) {
11.        // clang-format off
12.        // {new_target}, {target}, {receiver}, return value: tagged pointers
13.        // {argv}: pointer to array of tagged pointers
14.        using JSEntryFunction = GeneratedCode<Address(
15.            Address root_register_value, Address new_target, Address target,
16.            Address receiver, intptr_t argc, Address** argv)>;
17.        // clang-format on
18.        JSEntryFunction stub_entry =
19.            JSEntryFunction::FromAddress(isolate, code->InstructionStart());
20.        Address orig_func = params.new_target->ptr();
21.        Address func = params.target->ptr();
22.        Address recv = params.receiver->ptr();
23.        Address** argv = reinterpret_cast<Address**>(params.argv);
24.        RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::kJS_Execution);
25.        value = Object(stub_entry.Call(isolate->isolate_data()->isolate_root(),
26.                                       orig_func, func, recv, params.argc, argv));
27.      } else {
28.  //..................omit     
29.      }
30.    } Line 18 gets the address of the builtin, its index is 40, and its name is JSEntry. This builtin builds the execution environment for bytecodes. Then step into line 25, where the bytecode is executed. After that, we can only debug the assembly code, but c++. Figure 1 is the call stack. Before stepping into bytecodes, Generate_JSEntryVariant will be called. 0.  void Generate_JSEntryVariant(MacroAssembler* masm, StackFrame::Type type,
1.                               Builtins::Name entry_trampoline) {
2.    Label invoke, handler_entry, exit;
3.    Label not_outermost_js, not_outermost_js_2;
4.    {  // NOLINT. Scope block confuses linter.
5.      NoRootArrayScope uninitialized_root_register(masm);
6.      // Set up frame.
7.      __ pushq(rbp);
8.      __ movq(rbp, rsp);
9.      // Push the stack frame type.
10.      __ Push(Immediate(StackFrame::TypeToMarker(type)));
11.      // Reserve a slot for the context. It is filled after the root register has
12.      // been set up.
13.      __ AllocateStackSpace(kSystemPointerSize);
14.      // Save callee-saved registers (X64/X32/Win64 calling conventions).
15.      __ pushq(r12);
16.      __ pushq(r13);
17.      __ pushq(r14);
18.      __ pushq(r15);
19.  #ifdef _WIN64
20.      __ pushq(rdi);  // Only callee save in Win64 ABI, argument in AMD64 ABI.
21.      __ pushq(rsi);  // Only callee save in Win64 ABI, argument in AMD64 ABI.
22.  #endif
23.      __ pushq(rbx);
24.  //.....................omit............................
25.    __ ret(0);
26.  }
27.  }  // namespace
28.  //==================separation===============================
29.  void Builtins::Generate_JSEntry(MacroAssembler* masm) {
30.    Generate_JSEntryVariant(masm, StackFrame::ENTRY,
31.                            Builtins::kJSEntryTrampoline);
32.  } Look at the 30th line of code, the generator function of the 40th builtin is B, and its analysis method refers to my previous paper. Figure 2 shows the corresponding assembly code. You can also see a bit of C++ in Figure 2, but this is the last chance to see C++. After that, only the assembly code. Our case uses the console.log which is a global function. It is below. 1.  #define RUNTIME_FUNCTION_RETURNS_TYPE(Type, InternalType, Convert, Name)      \
2.    static V8_INLINE InternalType __RT_impl_##Name(Arguments args,              \
3.                                                   Isolate* isolate);           \
4.                                                                                \
5.    V8_NOINLINE static Type Stats_##Name(int args_length, Address* args_object, \
6.                                         Isolate* isolate) {                    \
7.      RuntimeCallTimerScope timer(isolate, RuntimeCallCounterId::k##Name);      \
8.      TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("v8.runtime"),                     \
9.                   "V8.Runtime_" #Name);                                        \
10.     Arguments args(args_length, args_object);                                 \
11.      return Convert(__RT_impl_##Name(args, isolate));                          \
12.    }                                                                           \
13.                                                                                \
14.    Type Name(int args_length, Address* args_object, Isolate* isolate) {        \
15.      DCHECK(isolate->context().is_null() || isolate->context().IsContext());   \
16.      CLOBBER_DOUBLE_REGISTERS();                                               \
17.      if (V8_UNLIKELY(TracingFlags::is_runtime_stats_enabled())) {              \
18.        return Stats_##Name(args_length, args_object, isolate);                 \
19.      }                                                                         \
20.      Arguments args(args_length, args_object);                                 \
21.      return Convert(__RT_impl_##Name(args, isolate));                          \
22.    }                                                                           \
23.                                                                                \
24.    static InternalType __RT_impl_##Name(Arguments args, Isolate* isolate)
25.  #define CONVERT_OBJECT(x) (x).ptr()
26.  #define CONVERT_OBJECTPAIR(x) (x)
27.  #define RUNTIME_FUNCTION(Name) \
28.    RUNTIME_FUNCTION_RETURNS_TYPE(Address, Object, CONVERT_OBJECT, Name)
29.  //=================separation==============================
30.  //==================separation===============================
31.  Object DeclareGlobals(Isolate* isolate, Handle<FixedArray> declarations,
32.                        int flags, Handle<JSFunction> closure) {
33.    HandleScope scope(isolate);
34.    Handle<JSGlobalObject> global(isolate->global_object());
35.    Handle<Context> context(isolate->context(), isolate);
36.    Handle<FeedbackVector> feedback_vector = Handle<FeedbackVector>::null();
37.    Handle<ClosureFeedbackCellArray> closure_feedback_cell_array =
38.        Handle<ClosureFeedbackCellArray>::null();
39.    if (closure->has_feedback_vector()) {
40.      feedback_vector =
41.          Handle<FeedbackVector>(closure->feedback_vector(), isolate);
42.      closure_feedback_cell_array = Handle<ClosureFeedbackCellArray>(
43.          feedback_vector->closure_feedback_cell_array(), isolate);
44.    } else {
45.      closure_feedback_cell_array = Handle<ClosureFeedbackCellArray>(
46.          closure->closure_feedback_cell_array(), isolate);
47.    }
48.    // Traverse the name/value pairs and set the properties.
49.    int length = declarations->length();
50.    FOR_WITH_HANDLE_SCOPE(isolate, int, i = 0, i, i < length, i += 4, {
51.      Handle<String> name(String::cast(declarations->get(i)), isolate);
52.      FeedbackSlot slot(Smi::ToInt(declarations->get(i + 1)));
53.      Handle<Object> possibly_feedback_cell_slot(declarations->get(i + 2),
54.                                                 isolate);
55.      Handle<Object> initial_value(declarations->get(i + 3), isolate);
56.      bool is_var = initial_value->IsUndefined(isolate);
57.      bool is_function = initial_value->IsSharedFunctionInfo();
58.      DCHECK_NE(is_var, is_function);
59.      Handle<Object> value;
60.      if (is_function) {
61.        DCHECK(possibly_feedback_cell_slot->IsSmi());
62.        Handle<FeedbackCell> feedback_cell =
63.            closure_feedback_cell_array->GetFeedbackCell(
64.                Smi::ToInt(*possibly_feedback_cell_slot));
65.        // Copy the function and update its context. Use it as value.
66.        Handle<SharedFunctionInfo> shared =
67.            Handle<SharedFunctionInfo>::cast(initial_value);
68.        Handle<JSFunction> function =
69.            isolate->factory()->NewFunctionFromSharedFunctionInfo(
70.                shared, context, feedback_cell, AllocationType::kOld);
71.        value = function;
72.      } else {
73.        value = isolate->factory()->undefined_value();
74.      }
75.      // Compute the property attributes. According to ECMA-262,
76.      // the property must be non-configurable except in eval.
77.      bool is_eval = DeclareGlobalsEvalFlag::decode(flags);
78.      int attr = NONE;
79.      if (!is_eval) attr |= DONT_DELETE;
80.      // ES#sec-globaldeclarationinstantiation 5.d:
81.      // If hasRestrictedGlobal is true, throw a SyntaxError exception.
82.      Object result = DeclareGlobal(isolate, global, name, value,
83.                                    static_cast<PropertyAttributes>(attr), is_var,
84.                                    is_function, RedeclarationType::kSyntaxError,
85.                                    feedback_vector, slot);
86.      if (isolate->has_pending_exception()) return result;
87.    });
88.    return ReadOnlyRoots(isolate).undefined_value();
89.  }
90.  //==================separation===============================
91.  //==================separation===============================
92.  RUNTIME_FUNCTION(Runtime_DeclareGlobals) {
93.    HandleScope scope(isolate);
94.    DCHECK_EQ(3, args.length());
95.    CONVERT_ARG_HANDLE_CHECKED(FixedArray, declarations, 0);
96.    CONVERT_SMI_ARG_CHECKED(flags, 1);
97.    CONVERT_ARG_HANDLE_CHECKED(JSFunction, closure, 2);
98.    return DeclareGlobals(isolate, declarations, flags, closure);
99.  } RUNTIME_FUNCTION(Runtime_DeclareGlobals) is a runtime function defined by a macro template. The function checks the parameters and then calls DeclareGlobals() to perform the corresponding operation. In our case, DeclareGlobals() lookup the global object console, then takes out the log() from the console, and gets the address of console.log(). Finally, pass the parameter JsPrint(6) into log() which will start a new compilation and execution. 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 story was first published here.

Let’s Understand Chrome V8 — Chapter 10: Ignition Execution Unit

Since the 5 years ago, I’ve been working remotely and loving it. I’m now the founder of , an online school for remote software developers where we teach our students how to take advantage of opportunities regardless of where they are. acquisition of my previous startup Microverse This guide is a living collection of resources that I often use or recommend to other people who want to become remote workers. If you have anything that you want to add or update, please leave a comment. Conferences (May 31-June 4, San Marcos La Laguna, Guatemala) Rebel + Connect’s Remote Work Summit (June 23-24, Bali, Indonesia) Running Remote (Sep 8-10, Lisbon, Portugal) DNX Conference (October, Medellín, Colombia) 7in7 (Date TBD, Gran Canaria, Spain) Nomad City (TBD) TRaD Works Forum (TBD) Yonder Conference (Jan 19, 2019) Nomad Summit Remote Working Conference (Feb 9-11 2018, Penang, Malaysia) The Coworking Unconference Asia (March 5 2018, Online) The Remote Work Summit (March 21–22 2018, Austin TX) Scatter (May 39, 2018, Online) Out of Office Companies 10up Aha! Articulate Auth0 Automattic Axelerant Balsamiq Bandcamp Basecamp Buffer Canonical Chef Clevertech Cloudbees Crossover DataRobot DataStax DigitalOcean Doist DuckDuckGo Elastic Envato Fire Engine Red Four Kitchens Genuitec Ghost GitHub GitLab Gun.io Heap Help Scout Heroku inVision Jackson River Jitbit Software Lullabot Mobile Jazz Mozilla Olark onTheGoSystems O’Reilly Media Original Eight Parse.ly Particular Software Pythian Scrapinghub Simple A SitePen Sonatype Spreaker Stack Exchange Toggl Toptal Trello Universal Mind X-team X-team Not enough? Check out this spreadsheet with more than other 600 companies hiring remotely: _Edit description_docs.google.com 600+ Startups hiring Remotely in 2018 - by Remotive.io Communities Nomad Base Reddit/telecommuting Remotive Hacker Paradise Remote Year Remote Way #freelance YonderWork Be Unsettled Nomad House DNX Camp Reboot Life Flylancers Co-living Nomad.Life Roam WeLive WifiTribe Outsite CoBoat NomadCruise Job boards (Remote filter) AngelList FlexJobs Jobbatical Jobspresso NODESK RemoteBase Remote.co Remote | OK Remotive Remote Friendly Stack Overflow remote job listings WeWorkRemotely WFH.io Workaline Working Nomads Newsletters Remotive Remoteur Books , by Jason Fried and David Heinemeier Hansson (37signals) Remote: Office Not Required , by Wade Foster (Zapier) The Ultimate Guide to Remote Work , by Scott Berkun The Year Without Pants: WordPress.com and the Future of Work , by Coby Chapple (GitHub) The Remote Jobseeker’s Handbook , by Robert Pankowecki and Andrzej Krzywda (Arkency) Async Remote (Wrike) The Art of Staying Productive Even Across Distance (Hubstaff) No Excuses, A definitive guide to building a remote team , by Dr. David Rock Your Brain at Work Working Remotely — The Telecommuter’s Guide to the Galaxy , Rules for Focused Success in a Distracted World Deep Work Podcasts Free People Move Podcast Lessons from Distributed Companies REMOTE WORKS Yonder Podcast Wide Teams Tools Communication Fleep Flowdock Hipchat Mumble PukkaTeam Sneek.io Rocket.Chat Slack Twist Video conferencing Appear.in Bluejeans Hangouts Skype Zoom Programming Codeshare.io Floobits Time tracking Clockify Harvest Toggl Project management Asana Trello Basecamp Pivotal Tracker Timezone management Timezone.io Spacetime Sundial Do you want to add anything? Leave a comment :)

The Ultimate List of Resources for Remote Workers

Reporting on Google’s future with today’s facts Illustration: Mandela Smith Google made almost all its money from ads. It was a booming business—until it wasn’t. Here’s how things looked right before the most spectacular crash the technology industry had ever seen. The crumbling of Google’s cornerstone Back when Google was still just an idea, its founders that “advertising funded search engines [would] be inherently biased towards the advertisers and away from the needs of the consumers.” thought They changed their minds. With that change, Google became one of the wealthiest, most powerful companies in history. Search was Google’s golden goose, as well as its only unambiguous win. So when Amazon as the top product search destination in 2017, Google’s foundations began to falter. rapidly surpassed Google Amazon was fighting Google on its home turf, and it was winning. Even worse, the people turning to Amazon over Google for their shopping searches were from the most important group for advertisers and the future: . Advertisers followed them, and Amazon began to that once went to Google search ads. Google’s mighty engine had started to sputter. young people siphon away ad dollars Google realized that it was hard to convince people who were used to getting something for free that they should now pay for it. A shift from also started to take shape in the late 2010s: When shoppers weren’t searching for things directly on Amazon, things were finding them. Advertisers realized that money previously spent on Google’s search ads was better spent either on Amazon ads or , like Instagram and Facebook. Google had no engaging content feeds, so it completely missed the wave, just like it had with and . search to discovery native ads in content feeds social media instant messaging Seeing the signs on the horizon, Google tried unsuccessfully to find revenue in areas other than advertising. Google to make money with its hardware, cloud services, and wildly ambitious “Other Bets” categories. struggled For all its efforts, the money Google earned from its nonadvertising ventures only ever accounted for a mere 15% of their revenue. And revenue from Google’s moonshot “Other Bets” a small fraction of the the company started to receive from looming regulators. didn’t even cover increasingly massive fines The war on ads In late 2015, Apple—Google’s main competitor in the mobile space— to their devices that allowed users to block ads. added a feature Devices running iOS were responsible for as much as from mobile search ads, which is probably why Google was paying Apple every year to remain the default search engine on Apple devices. By making this move, Apple was simultaneously weighing in decisively on the great ad blocking debate of the 2010s and dealing a substantial blow to the . 75% of Google’s revenue billions of dollars future of online advertising This move from Apple reflected the of ad blocking software happening at the time. Having one of the biggest technology companies on the planet standing behind consumers only emboldened the movement. unprecedented mainstream adoption of desktop and laptop users in the United States were blocking ads by the year 2018. Those users would soon block ads , too, as mobile ad block usage eclipsed desktop usage in 2017 and rose even faster. Well over a quarter on their mobile devices Source: 2017 Adblock Report/PageFair Mobile ads were one of Google’s during its final years of domination, but people started to block mobile ads en masse once they realized that ads and tracking scripts were costing them as much as in bandwidth and using up a significant portion of their . biggest areas of growth $23 per month battery life Research showed that reported a lack of trust as their reason for not clicking banner ads, and 33% found them completely . The average banner ad was clicked on by a dismal , and of those clicks, over . 54% of users intolerable 0.06% of viewers 60% were accidental Even those who weren’t blocking ads had trained themselves to ignore them entirely. Researchers dubbed this phenomenon “ .” banner blindness The people most likely to block ads were also the most valuable to advertisers: . Young users are a strong indicator for future trends, and they were of ad blocking software. Internet users had spoken, and they hated Google’s ads. millennials and high earners heavy users The ad blocking epidemic presented significant threats to Google’s business: People were getting used to using the internet without seeing ads, and Google was losing money every time their ads were blocked. In early 2017, Google made the desperate, confusing, and decision to add its own form of ad blocker to Chrome, but it did nothing except attract more antitrust regulation. It would quickly become clear to Google that even though ads were getting slightly better, ad blocking numbers would . legally questionable continue to rise Source: 2017 Adblock Report/PageFair Later, in 2019, Google for users to block ads in its then-dominant Chrome browser. All while Google was paying to let its ads through the most popular ad blocking software. tried to make it harder huge sums of money Google wasn’t willing to acknowledge the problems people had with the system they helped create, and it was clear that the company had no idea what to do when people started rejecting it. Too many people had become accustomed to a web without invasive banner ads following them around and slowing down every site they visited. Internet users had waged a war on ads, and Google was losing. An unprofitable behemoth A key platform where Google served ads was YouTube, which it bought in 2006 and quickly turned into one of its biggest entities. But even with a visiting this video-sharing behemoth every month, YouTube . sixth of the world never became profitable While attempting to coax big brands and advertisers onto the platform in the hopes of finally turning a profit, YouTube misunderstood, alienated, and downright angered the creators and communities that had turned the platform into a global phenomenon. In an attempt to combat the effect of ad blockers, Google launched an ad-free subscription model in late 2015, but the subscription numbers were , and eventually, Google realized that to convince people who were used to getting something for free that they should now pay for it. underwhelming it was hard YouTube ads were , and the video-sharing site never proved to be as effective for brand awareness advertising . Global ad spend from traditional media, but it wasn’t going to Google’s platforms. interruptive and annoying to users as Google needed it to be continued to move online The turning tides Google’s products were free, innovative, and used by billions of people. In order to get access to these free products, people had to give up their personal data and their valuable attention. Google’s ads weren’t something its users wanted—they were simply a tax for accessing the Google ecosystem. Google was enticing people into trading their privacy, data, and attention for the convenience of its amazing free products and services, some of which had no good alternatives. However, proved that the trade might not be worth it, and people started to question what they were giving up by clicking “I agree.” scandal after scandal after scandal Every word uttered to Google Assistant, every action in any of Google’s numerous apps, and every data point about every one of their billions of users was stored and analyzed in the name of more accurate advertising. And it wasn’t just Google’s users questioning the trade-off. Regulators and decision makers also to how free internet products and services made money, and the companies behind them soon faced . finally started understand a long-awaited reckoning With its golden goose getting old, ad blocking rising, public opinion shifting, regulation closing in, and all of its ambitious bets on the future failing to make money, a lot was riding on Google’s next moves. It made the wrong ones. How Google missed the chance to pivot If losing a major portion of their audience and annoying the rest wasn’t bad enough, Google also failed to get ahead of one of the biggest shifts in the internet’s history. Google’s strategy since day one could be summed up as “aggregate and advertise,” as George Gilder put it in . Every word uttered to Google Assistant, every action in any of Google’s numerous apps, and every data point about every one of their billions of users was stored and analyzed in the name of more accurate advertising. Life After Google Google’s business model was built on the foundational belief that in order to serve ads accurately, it had to collect and analyze as much data as possible from as many people as possible. This belief led the entire advertising industry to turn the web into a monstrosity of tracking and surveillance. The holy grail of accurate advertising is perfect targeting and perfect attribution: getting an ad in front of the right people, knowing exactly when and where someone saw an ad, and being able to prove where credit is due when they make a purchase. The entire industry was spinning its wheels chasing this vision, but eventually realized that its approach to the problem was completely backward. A vast, seedy, unfathomable of tracking tendrils spanning the entire web would only ever overcomplicate things, ruin the user experience, and enable a . landscape staggering amount of ad fraud True attribution and accurate targeting used to be rocket science, black magic, and nearly impossible. The breakthrough was this: If everything from interest matching to ad placement happened inside the user’s device, it would be possible to show the user ads they would actually find relevant and understand exactly which ads they interacted with and how, all without the user’s private data ever leaving the device. It turned out that ads didn’t need to broadcast a in order to be accurate, nor did they need to and cost the user their bandwidth and battery life in order to fund good content. user’s private data into the ether slow down websites Treating people as people turned out to be a winning strategy — not just for advertising or the bottom line, but for society. As Google’s revenue grew, so too did consumer awareness of how Google was profiting from our data and attention. We became increasingly unwilling to exchange privacy for convenience. We stopped clicking “I agree,” a trend that only accelerated when the company was forced by regulators to be about its business model. A perfect storm was brewing. more transparent Early signs of Google’s demise became clear toward the end of the 2010s, as its and hardly anyone even noticed as the company’s foundational principle by the creator of JavaScript (ironically, one of the very tools that had been weaponized by the dark side of online advertising). revenue growth began to slow was quietly proven false Brendan Eich while he was working at Netscape. After Internet Explorer , he co-founded Mozilla and to take down Internet Explorer with Firefox. Several years later, when Google dominated the web with Chrome, Eich created to fundamentally change . created JavaScript killed Netscape restarted the browser wars Brave the economics of the internet The companies that thrived were the ones that understood that people are not pawns in a game of corporate chess, bids in an infinite automated auction, data points in a sea of categories, or correlations in obscenely large data sets. People are people. And treating people as people turned out to be a winning strategy—not just for advertising or the bottom line, but for society. Google wasn’t forever At its peak, Google had a massive and loyal user-base across a staggering number of products, but advertising revenue was the glue that held everything together. As the numbers waned and the competitors circled, Google’s core began to buckle under the weight of its vast empire. Google had been a driving force in the technology industry ever since its disruptive entry in 1998. But in a world where people grew to resent being tracked and profiled, Google’s business model was not innovation-friendly, and it missed several opportunities to pivot, ultimately rendering its numerous grand and ambitious projects unsustainable. Innovation costs money, and Google’s main stream of revenue had started to dry up. In a few short years, Google had gone from a fun, commonplace verb to a reminder of how quickly a giant can fall. Life After Google Hacker Noon Disclaimers: The author owns a small number of Basic Attention Tokens (the utility token that makes Brave’s model possible). This article was updated on May 5, 2019. The original version as mentioned in was originally in the publication and can be found here .

This Is How Google Will Collapse

You've always wanted to have your own business, but you're not sure where to start. You have an idea for a product or service that could make you some cash, but you don't know if anyone would buy it. The problem is: You don't have any money. You're not alone. This is a common situation for people who are just starting out in business and lack the capital necessary to start a business from scratch. But what if I told you there was a way to get started in business without any money? Well, there is — and it's called freelancing. It's a good time to be a freelancer. The freelance economy has grown by almost 50% in the last 10 years and is expected to continue growing at a steady pace. In fact, according to Upwork, freelancing is the future of work. But why should you sell your skills on online platforms? There are many reasons — so many that we've compiled them into this guide. The benefits of selling your skills online include: You can reach more people and sell more easily than ever before. Automated tools make it possible for companies from all over the world to find you and communicate with you remotely, eliminating geographical barriers. Easy access to customers: You don't need an office or any other overhead costs like employees do. Instead, you can work from home or anywhere else that's convenient for you. This makes it easy for companies to hire freelancers without having to pay for their expenses (which can include health insurance and more). Low costs: You can choose when and how often you work — whether that's full-time or part-time — which means no fixed schedules and no commute time! As long as there is internet access, there are no limits on where or when you work. Flexibility: What is freelancing? Freelancing (also known as "the gig economy") refers to selling your skills and expertise as an independent contractor or consultant, rather than working for one company full time. It's a great way to make money without having to invest in equipment or overhead costs that would otherwise be required in order to start your own business from scratch. Also published . here

How Freelancing Can Help You Make Money With Your Skills

If you have online skills and know how to make money on Fiverr, your earning potential is endless. With Fiverr, you can travel around and make money online as a digital nomad. Despite what you think, you can earn way more than five dollars a job with Fiverr. Some freelancers are paid hundreds and even thousands of dollars per job. So it’s up to you to earn more money on Fiverr. Now learn how to make money on Fiverr. Listen up digital nomads, travelers, and freelancers. Fiverr is one of the best ways to utilize your skills to start as a side hustle and improve for your many jobs. So, let’s dive deeper into, how to make money on Fiverr. What is Fiverr? Fiverr is a marketplace that provides various service offerings and mini-jobs. Fiverr was founded as a website that provides a platform for digital marketing for freelancers. On this web-based service, you can search for a million jobs in any field. Fiverr is perfect for all kinds of artists and designers. Services on Fiverr are called gigs which usually start around $ 5 US per person and are therefore named. It’s the basic payment. You will find many job jobs paying similar prices to those found on other job services websites. What is a Gig on Fiverr & how to create a gig? On the online platform, you’ll find millions of gigs for every type of skill. No matter if you are a translator, graphic designer, architect, social media manager, or songwriter. You can easily make money on Fiverr with your skills and become a Fiverr seller. Your offered services are called “gigs”. Fiverr has 3 packages within a gig that you can use, . Your basic gig is usually the test package where people can buy your gig to check out your skill level & communication. The start for you making money. basic, standard and premium Once clients get to know you they will go for your standard or premium packages. You can adjust your gigs as you deal with your first clients and their comments. By connecting sellers directly with freelancers, Fiverr has grown to become one of the largest websites to offer an online service exchange. Its popularity in the industry makes it a desirable way to earn money while traveling, as a side gig, and even professionally. How to set up a successful Fiverr Gig? If you want to make money with Fiverr you have to make a good plan to build your first gig. Here few tips to maximize sales: The important thing is that you pay attention to Keywords in the gig packages, gig title, you create because that’s how potential buyers find you. Complete your Fiverr profile as good as you can to earn more trust & more mone The gig image is very important that the buyers click on your service, like on youtube. Promote your Fiverr gig with social media marketing Get always client feedback to improve your freelance service 5 Steps For A Gig Description — Capture the buyer’s attention Intro — Describe who in shortly you are and what you do Bio — What is your gig about Description — Describe what you will get from the basic package Basic package — Invite the buyer to order your gig to maximize sales Call to action Example Fiverr gig image: Let’s start, create your Fiverr account to become a Fiverr seller and earn money! How much can you make on Fiverr? How much money you make on Fiverr depends on your work schedule. The average salary on Fiverr is about $500 to $5000 for a freelancer. Enables may increase with 5-star ratings and positive feedback from your clients thereby increasing your hourly rate. Many freelancers are getting much larger incomes from this software platform with some reaching six-figure salaries to make different experiences. Promote your new gig on social media to earn some extra money with your freelance services. Let’s get started become a Fiverr seller: Create a Seller account. Fiverr Setup your Fiverr gig package. Create the gig image (clear striking image) Create the gig video (a video explaining your gig) Optimize your first gig (SEO keywords: URL, heading, description, tags, gig extras) Tip: If you see huge demand for your gig, you can also create similar gigs / multiple gigs with different keywords to rank more often and earn good money on Fiverr. Upsell in your Fiverr gig and add a gig extra like “faster delivery” for specific work to your gig Top 5 categories with high demand in 2022 There are a lot of people in today’s time that plan to make extra money but are not aware of how? Fiverr is one of the best marketplaces to generate extra revenue and start your side project while things get rolling on your big idea. and offer your digital services in over 200 job categories. Join Fiverr Also Published Here

How to Make Money on Fiverr as a Freelancer

I remember my first visit to China in 2010. We booked a hotel in a good location in Guangzhou, saving the coordinates and routes to Google Maps prior to our arrival. But when we got there, it was immediately obvious that there were no hotels in that area. I was at the correct point where my hotel should be, but all I have around me is a huge square ( ). 花城广场 - aka, Flower City Square Long story short: At some point, some guy saved us with his Meizu phone by showing that our hotel actually a few miles away from this square. These days I work with China, and face the same challenges as a developer. I decided to write an article to summarize my experience with  in the hope that this might help someone. Coordinate systems For starters let's talk about the main coordinate systems used today. An international standard is WGS-84 ( ) or World Geodetic System, where 84 is the latest revision of this standard applied in 1984. This standard is used by GPS. Each time you use Google Maps( ) you can thank WGS-84. Now let's talk about China. Earth coordinates or almost any maps Chinese regulators require ( ). It was formulated by the in 2002. Sometimes GCJ-02 is called Mars coordinates. GCJ-02 is based on WGS-84 and uses an obfuscation algorithm, which adds random offsets to both the latitude and longitude to improve national security. If the WGS-84 point is placed on the GCJ-02 map, on average, there will be a location offset for about 300-500m. Very few are into the «miles» apart, usually just by a couple of blocks. That's why I got lost during my first visit to China. approved map services to use standard GCJ-02 Chinese: 国测局; pinyin: guó-cè-jú Chinese State Bureau of Surveying and Mapping Hold tight. There is more. Baidu went further and implemented yet another abstraction adding further obfuscation to GCJ-02. It's called the BD-09( ). The primary purpose was to protect Baidu's data so that competitors couldn't easily duplicate. Baidu has internal tools to shift between the three coordinate systems, but only making GCJ-02 to BD-09 public to encourage using their standard for tiles, search coordinates, etc. Baidu, formulated in 2009 As required by the Chinese law there is no official API to convert to WGS-84. Licenses According to Wikipedia, « ». Although if you look at the Baidu or Mapbox maps, you'll often find OSM attribution next to the map license. It means that the usage of OSM is not illegal in China, and you can add data to OSM from satellite images. But to do ground data collection, you must obtain a Survey License( ). And it's a whole different story. OpenStreetMap, the crowdsourced project to assemble a map of the world, advises that "private surveying and mapping activities are illegal in China ability to collect data and create a commercial product As mentioned to me, a survey license is extremely difficult to get. As a result, there are fewer than 20 companies that have this license. Giant tech companies like Alibaba needed to acquire AutoNavi just for this license, Tencent had to buy NavInfo. Mapbox, for example, partnered with EMG, a leader in navigation grade map data. Didi was the first company to receive its license directly in the past decade(quite a milestone). Map license, on the other hand, is easier to obtain — if you look at the bottom right of licensed base maps in China ( ), you'll see something like « ». Chris Mapbox, Baidu, AutoNavi, etc. GS (2020) 123 号 Coordinate conversion As you can imagine, conversion goes like this: ⇛ ⇛ and backward. It is illegal to publish a formal conversion guide — each use of the coordinate shifting needs to be approved by . WGS-84 GCJ-02 BD-09 SBSM However, you can find open-source implementations for this algorithm in different programming languages(e.g., ). In this article, i will use , but you easily will find Python, R, Go and etc. Check the Notes section of my article. eviltransform JavaScript implementation uses to get BD-09 coordinates of the desired object. A screenshot is below. I then store this coordinates in the database and do conversion towards WGS-84 or GCJ-02, based on the user geolocation. For users in China you must use GCJ-02, remember? Our Chinese office Baidu Get Point Service I made an example with coordtransform library and Mapbox.com for you to play around. Copy BD-09 coordinates from and to see the result of transformation.  You can find . this service paste them here source code for this example here Which map provider to use for your users in China? If you want to provide a smooth map experience to your users from Mainland China, you don't have a lot of options. Google Maps isn't working without a VPN. I love Baidu Maps in China. They provide excellent UI with a lot of handy GEO-data. I mean, . look at the details But when it comes to the point where you should embed a map on your web page, the only choice left for me is . Mapbox is an excellent alternative map service. It's legal and works perfectly fine without a VPN in China. Due to Chinese regulations, they serve through mapbox.cn. All data inside China is shifted (from their mapping partner), all data outside China is unshifted (from their own data sets, including OSM). Mapbox 3 licensed base maps I tested api.mapbox.com endpoint with a global access token, and it worked perfectly fine from Guangzhou. But in the case with China, it's a gamble, so i suggest to obtain the access token from . mapbox.cn : show mapbox.cn embed with coordinates Yes GCJ-02 : show mapbox.com embed with coordinates No WGS-84 I hope this post will save time for someone. I will probably add more information later since this is a complex and not well-understood topic. if you have any questions or feedback. Drop me a line World Geodetic System Restrictions on geographic data in China Baidu Maps Transport coordinate between earth(WGS-84) and mars in china(GCJ-02) coordtransform 坐标转换 地球坐标系 (WGS-84) 到火星坐标系 (GCJ-02) 的转换算法 Baidu Maps Get Point API Thanks to Chris Wu from Mapbox China for his feedback on this article and insights about how maps works in China. Without him, this article would not be complete.

GCJ-02 Explained: The Chinese Coordinate System—For Developers

When you work remotely, having the freedom to travel is a big part of the appeal for many. Colombia is a popular destination on the circuit and the recent introduction of a is likely to boost its appeal further. But sometimes, connectivity and internet access can be a problem, especially in locations that are slightly off the beaten track. digital nomad visa Let’s explore why digital nomads are drawn to Colombia, what the digital nomad visa offers and which locations offer the most reliable internet connections. Why digital nomads are drawn to Colombia Colombia is known as one of the most biodiverse countries in the world, with incredible landscapes, such as the Sierra Nevada and Andes mountain ranges. This country is also home to several iconic nature reserves including Tayrona National Park and Chiribiquete National Park, considered World Heritage by Unesco. And the country also offers plenty of cultural attractions too. Barranquilla, a city on the northern coast, hosts the second largest carnival in the world (after Rio de Janiero, Brazil) and travelers can also enjoy a number of festivals throughout the year, including “Feria de Cali” and “Feria de las Flores” in Medellín. Colombia Cost of Living The cost of living is typically low compared to other countries in South America, the official currency is the Colombian Peso (COP), and for an individual is about USD $800, adding to the attraction for many international workers. the average monthly living costs So, it comes as no surprise that Colombia is a big tourist destination, attracting in 2022. Most travelers enter on a tourist visa that offers three months on arrival with the option to extend your stay for a further three months once in the country. However, this visa is meant for leisure purposes and doesn’t properly support those wishing to work remotely in the country. While other visas are available, they’re often time consuming and complicated to obtain. 3.5 million tourists For this reason Colombia has been issuing new regulations in order to improve communication and make the application process more welcoming to remote workers and digital nomads who wish to stay in the country for a longer period. The Launch of the Digital Nomad Visa After a long legislative process, . The new visa will allow foreigners to live in the country for 24 months and access a state ID known as “Cedula de Extranjeria” which is needed to access many services in the country. Without this ID it can be difficult to obtain a cellular phone service contract or rent an apartment to name a couple of examples. Colombia launched its Digital Nomad Visa in 2023 The proposal was presented by Ilana Milkes, the CEO of Tech World, at the last Mobile World Congress, after two years of working on it alongside the government agency, . This represents a massive step for the country, considering the growing tech scene in major cities like Bogotá and Medellín and digital nomads’ preferences of having Colombia as one of their moving options. Procolombia The initiative is expected to facilitate the arrival of at least 45,000 digital nomads to the country in the first 18 months. However, considering the visa targets remote workers who need optimal internet speeds, how does Colombia fare when it comes to reliable connectivity? Colombia’s connectivity: Stats and facts According to several surveys, the South American region has been expanding its internet penetration, . Additionally, Colombia is currently in the fourth position of fastest growing internet right after Argentina, Mexico, and Brazil. coming in fifth behind North America Colombia now counts over 39.34 million internet users, and its internet penetration was at . The country is also improving its Network Readiness Index faster than the world average due to from Colombia’s Ministry of Information and Communication Technologies (MinTic). 75.7% at the beginning of 2023 initiatives So, while Colombia’s connectivity rates are slightly behind some of its close neighbors in Latin America, its government’s various development initiatives to improve internet connectivity may be paying off with internet penetration increasing steadily for the past three years. Regional internet providers and coverage across Colombia The country has a fixed broadband speed offering a minimum of 25 Mbps downstream and 5 Mbps upstream. In addition, internet providers offer fiber-optic internet as an option and mobile broadband speeds of up to 4G. As for the internet provider options available for digital nomads in Colombia, the four, main providers offering the following speeds, according to : speedtest.net Movistar with the fastest median download speed at 141.32 Mbps ETB with a download speed of 74.47Mbps Claro with a download speed of 88.86Mbps Tigo with a download speed of 75.88 While these speeds are the average, they do vary from region to region across Colombia. Let’s take a closer look at how some of the most popular cities across the country fare with their . fixed broadband speeds Larger cities: Bogotá: 51.92 Mbps Medellín: 46.9 Mbps Cali: 51.18 Mbps Bucaramanga: 52.81 Mbps Smaller cities: Santa Marta: 36.77 Mbps Villavicencio: 42.52 Mbps Sincelejo: 33.53 Mbps Montería: 32.79 Mbps With this data it’s clear that Colombia offers many reliable places to work from for the growing number of digital nomads. But what about those who want to get away from the cities? Working reliably in rural Colombia As mentioned, the country has a lot to offer in terms of places to visit; beaches, jungles, mountains and vast, lush plains are some of Colombia’s biggest attractions. Major Colombian cities have a lot to offer, but many digital nomads often begin to look outside the city after a while of living in the country. Here, connectivity becomes even more important to consider. If you’re hoping to work remotely from one of Colombia’s many natural beauty spots it’s important to be aware that Wifi coverage may not be as reliable so you can plan accordingly. For example, if you head just outside of the cities of Medellín or Santa Marta to little mountain getaways like Guatapé or Minca, then connectivity can quickly become harder to guarantee, despite their close proximity to the cities. Equally, there are many rural locations that are popular with nomads such as Salento, Salamina, Villa de Leyva, and Valle del Cocora that are likely to have slower internet speeds. While Wifi is standard in hotels or hostels, it’s advisable to have the back-up of a local network provider if you’re planning to work remotely in rural Colombia. Movistar may offer the fastest speeds in urban areas but its coverage in rural areas is limited. If you’re planning to use your mobile network to support your connectivity, then Claro is a safer bet, offering coverage across more rural locations. The rise of fiber optic and 5G across Colombia Looking ahead, Colombia already has the most extensive fiber optic network in South America, and is on its way to offer fiber optic broadband to by the end of 2023. 4 million homes and businesses As for the future of mobile services, Colombia is still in the process of . Once in place, 5G coverage will drastically improve internet coverage in rural areas and is noted as a going forward. adopting 5G 5G mobile networks top priority for MinTec Overall, the launch of Colombia’s new digital nomad visa is likely to attract many more remote workers to the country. While big cities offer internationally competitive internet speeds, these rates aren’t guaranteed across the entire country. Yet with a little forward planning and knowledge on Colombia’s network coverage it’s possible to work remotely without issue. This article was originally published by Stefania Troncoso on The Sociable.

Stories, News & Mentions about NOMADHER

Nomadher’s Stories on HackerNoon