Get the most recent info and news about Tailscale on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

For teams who want secure, private networks without weeks of setup and configuration, Tailscale makes it easy. Unlike existing corporate VPNs, Tailscale has no upfront cost, minimal latency, and works with their existing services.

Tailscale

tailscale

By John GruberApple TV, now with more Tailscale. Try Tailscale for Apple TV now.Blah blah blah, something something something about how most people don’t

The iPhones 15 Pro (and iPhones 15) – Daring Fireball

Microsoft has published a detailed profile of a native English-speaking threat actor with advanced social engineering capabilities it tracks as Octo Tempest, that targets companies in data extortion and ransomware attacks.

Microsoft: Octo Tempest is one of the most dangerous financial hacking groups

Lumeo, a designer of computer vision solutions, has announced the launch of “Lumeo-Ready” Gateways, in partnership with AIMobile, Seeed Studio, and Velasea.

Lumeo announces “Lumeo-Ready” Gateways to accelerate field deployments

Tailscale is also now available on Apple TV. Tailscale lets you create your own secure peer-to-peer network without relying on an intermediate company server network. You can choose an exit node ...

Best VPN apps for Apple TV

Private Networks: How Tailscale Works

93 Stories To Learn About Networking

167 Stories To Learn About Vpn

Problem Residential proxies have a lot of useful applications, such as web scraping, online research, bypassing geo-restrictions and anonymous browsing. But, they can be expensive, with some charging more than $100 a month for access to over 10 GB of data. Last year, when I was travelling to India and other parts of Southeast Asia, I wanted a reliable way which would let me access content on various subscription services like Netflix and Amazon Prime without geo-restrictions. I wanted to do this while Not having to pay more than $100 per month for VPN/residential proxy service. Also, Netflix would occasionally block me when using VPN. Not paying an additional amount for a static IP for my home internet connection back in the US. Solution I discovered a solution by creating my own residential proxy on my home desktop in the US. By setting up a peer-to-peer(P2P) VPN and connecting my laptop and desktop to it, I was able to route the traffic of my laptop in India to my desktop in the US, which then forwarded these requests to www/public internet before returning the response from my home network. All this without having to go through the hassle of setting up connection forwarding configuration in my home router. What is a P2P VPN Peer-to-peer(P2P) is an architecture model for VPNs used to create a secure shared environment for users. A P2P based VPN differs from the standard hub-and-spoke model by not routing all traffic through a central server, avoiding congestion. This improves security and allows for more efficient scaling by adding nodes without overburdening the network. Additionally, connections in a P2P VPN utilize the quickest path, reducing delays. There a multiple open-source, freemium and paid P2P VPN solutions available. Tinc is one of popular open-source VPN. How does the network setup look? The network stack consists of the following components: Desktop at home (US) My laptop (Outside US) P2P vpn daemon running on both machine via same account Http proxy server running on the desktop The diagram below depicts the flow of information to retrieve a public webpage from my laptop outside of the US. I wanted a P2P VPN which is easy to setup and requires near-zero config. I ended up using tailscale. The steps below are mostly generic for any VPN but you may find this most suitable if using tailscale. Steps taken to setup this network : Setting up the vpn client on desktop and laptop Download and install VPN client on desktop and laptop. If using a zero-config VPN, register your account with vpn and sign-in on both the machines with the same account : Setting up a forward http proxy server on desktop You can use any open source proxy server. I used https://github.com/abhinavsingh/proxy.py as it was easy to set up. I ran it within a docker container. The docker image for this proxy is available on docker hub.  To run it within a docker container you can execute this command docker run -it -p 8899:8899 --rm abhinavsingh/proxy.py:latest In the command above, the proxy server is listening on port 8899. This will be useful when we specify the url of proxy server in the applications within the laptop : After installing and signing into your VPN account, lets figure out the ip address of the desktop which will be used by the laptop to forward its http requests . Identify the ip address of desktop in the VPN network For this, you can list the ip addresses for all the network interfaces on the desktop. Then identify the ip address for an interface whose name starts with the name of your VPN client, for my case, it starts with “tailscale”. I used the command on my linux machine’s terminal to identify the ip address ip $ ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
….
4: tailscale0: <POINTOPOINT,MULTICAST,NOARP,UP,LOWER_UP> mtu 1280 qdisc fq_codel state UNKNOWN group default qlen 500
    link/none 
    inet 100.113.xxx.xx/32 scope global tailscale0
       valid_lft forever preferred_lft forever
 … Here I was able to find the ip address of desktop within my local tailscale network in the network interface : tailscale0 100.113.xxx.xx Using the address of proxy server on laptop to access public web: Now that we know the ip address of desktop (let's call it ) and the port number for the http proxy server on desktop (let’s call it ), we can forward all the network traffic from laptop via proxy address . $ip_desktop $proxy_port http://$ip_desktop:$proxy_port For example you can send a curl request to example.com from laptop via desktop like curl --proxy "http://$ip_desktop:$proxy_port" "https://example.com" Using the proxy server The above instructions demonstrate how to create a free residential proxy server while travelling using a spare computer at home. Now you can use this proxy address on your personal laptop in any of the following ways: Within your application code inside the http client libraries of your web framework/language (requests in python, fetch in javascript etc) For all the web requests from your laptop. This way you can forward any kind http request via desktop’s proxy server. In ubuntu you can do this by following these steps https://help.ubuntu.com/stable/ubuntu-help/net-proxy.html.en Just in your browser. Although Chrome and Firefox don’t provide a native way to setup exclusive http proxy settings for them, you can do this via extensions like https://github.com/foxyproxy/firefox-extension I chose 2. and forwarded all the http requests from my laptop to desktop. I used this setup for more than two months without any noticeable downtime. Conclusion In this article we went over how to setup a personal residential proxy using P2P VPN Two or more personal computers Depending on the choice of the VPN, the whole setup can be done without any additional cost, assuming you already own multiple computers. Using this residential proxy you can then access the internet anonymously without any geo-restrictions due to your current physical location.

How to Create a Personal Residential Proxy to Bypass Geo Restrictions

জিও সীমাবদ্ধতা বাইপাস করার জন্য কীভাবে একটি ব্যক্তিগত আবাসিক প্রক্সি তৈরি করবেন

So erstellen Sie einen persönlichen Wohn-Proxy, um geografische Beschränkungen zu umgehen

Cómo crear un proxy residencial personal para eludir las restricciones geográficas

Comment créer un proxy résidentiel personnel pour contourner les restrictions géographiques

भू-प्रतिबंधों को बायपास करने के लिए व्यक्तिगत आवासीय प्रॉक्सी कैसे बनाएं

地理的制限を回避するための個人用の住宅用プロキシを作成する方法

지리적 제한을 우회하기 위해 개인 주거용 프록시를 만드는 방법

Como criar um proxy residencial pessoal para contornar as restrições geográficas

Coğrafi Kısıtlamaları Aşmak için Kişisel Konut Proxy'si Nasıl Oluşturulur

Cách tạo Proxy dân cư cá nhân để vượt qua các hạn chế về địa lý

如何创建个人住宅代理来绕过地理限制

Over time most Linux aficionados accrue a sparkling war chest full of hard-won tricks that can come in tremendously handy when a situation demands quick thinking at your terminal. I stashed away many of these bits of knowledge over the years and whenever I had the opportunity to watch over the shoulder of somebody exceptionally well-versed with Linux. Today, you're pairing with me at the terminal. We're exploring the depths of Linux filesystem and shell tools and tricks. Take a with me /proc One of the most useful directories in a Linux system is . From the page for : /proc man proc The proc filesystem is a pseudo-filesystem which provides an interface to kernel data structures. When the page says "pseudo-filesystem", it means that if you were to peek underneath your disk where you might expect to find bits representing a file like you would for a text file at , there's nothing at . It's present and alive on a running Linux system, but entirely absent if you were to pull the disk out and inspect it. a control panel for your running kernel! man /tmp/launch-codes.txt /proc /proc If you were to take a look in your own right now, you might find a lot of directories like the following: /proc ls /proc 1
10
10021
10059
10144
...hundreds more files... Each of those numbers represents a process ID, or – yes, the same that identifies the process for your browser or terminal program. In fact, you can interrogate lots of information about the process itself. For example, you might recall that process on a Linux system is traditionally the top-level process, which in most modern systems is systemd-based. Let's see the command that kicked off on my system: PID PID 1 init PID 1 cat /proc/1/cmdline /run/current-system/systemd/lib/systemd/systemd is a file that tells us the command that kicked off process - in this case, itself. cmdline 1 systemd There's a file in that is particularly useful - , which actually shows you the arguments passed to your kernel itself at boot time. Mine is very wordy, but tells me the that my system booted with, along with any other flags, which in my case is and : cmdline /proc /proc/cmdline initrd init loglevel cat /proc/cmdline initrd=\efi\nixos\hx5g5rmvq748m64r32yjmpjk3pmgqmr1-initrd-linux-5.17.11-initrd.efi init=/nix/store/9zvklk45yx41pak2hdxsxmmnq12n712k-nixos-system-diesel-22.05.20220604.d9794b0/init loglevel=4 My NixOS hostname is . Please note that I do not put petroleum in my laptop. diesel isn't just read-only, either. Like its man page says, is an to the kernel, which includes interacting with the kernel itself. The directory holds a variety of knobs and dials, but I want to show you , which lets us peek at the kernel's virtual memory. Want to get more adventurous? /proc /proc interface /proc/sys /proc/sys/vm Consider my machine's current memory usage. free -h total        used        free      shared  buff/cache   available
Mem:           31Gi        22Gi       3.0Gi       4.4Gi       5.6Gi       3.6Gi
Swap:          31Gi       130Mi        31Gi Nothing too unusual here – but what if I wanted to free up my memory aggressively? Most of the time, the kernel knows best when it comes to using memory for caching, but there are some situations in which you may want to clear any memory that is safe to clear – we don't want to break any running processes, just reclaim memory if possible. It turns out that there's a file for that. We pipe an command into because is usually write-protected and only can write to the file we're interested in. echo sudo tee /proc/sys/vm root echo 1 | sudo tee -a /proc/sys/vm/drop_caches What this command does is effectively signal to the kernel, "please drop any caches in memory that you can afford to lose without breaking any running processes on my system." On my machine this opens up about 500M of memory: total        used        free      shared  buff/cache   available
Mem:           31Gi        22Gi       3.5Gi       4.4Gi       5.1Gi       3.6Gi
Swap:          31Gi       130Mi        31Gi Cool! There are all sorts of useful file-like objects in that can do interesting things like this. Feel free to open up if you'd like to learn more. /proc man proc as a prehistoric /dev curl A character device like represents an attached disk, but there's another use for the path: a little-known way to send network requests. /dev/sda /dev The path isn't actually a file-like device exposed by the Linux kernel, but actually a feature of your chosen shell like . Shells can intercept operations on this path in order to open up low-level socket connections to remote endpoints like web servers listening on port . /dev/tcp bash 80 To begin, open a new file descriptor connected to a file path in that indicates the desired endpoint and port. Much like how file descriptor numbers 0, 1, and 2 represent , , and , respectively, you can think of this new file descriptor 3 as representing a pipe to a remote network endpoint. We'll assume the use of from here on out. /dev/tcp stdin stdout stderr bash exec 3<>/dev/tcp/httpbin.org/80 Next, send the plaintext form of a simple HTTP request to the open file descriptor. This request to also requires the header to be set in order to be properly handled by most reverse proxies. Two newlines signal termination of the request: GET /status/200 Host echo -e "GET /status/200 HTTP/1.1\r\nHost: httpbin.org\r\n\r\n" >&3 Finally, a simple read operation retrieves the HTTP response: cat <&3 You should see a response similar to the one below: HTTP/1.1 200 OK
Date: Fri, 10 Jun 2022 21:39:43 GMT
Content-Type: text/html; charset=utf-8
Content-Length: 0
Connection: keep-alive
Server: gunicorn/19.9.0
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true Congratulations! You've just sent an HTTP request using nothing but your shell. Swimming in /sys There's one more root-level directory to explore after diving into and : the enigmatic directory. /proc /dev /sys Like and , is another file-like interface to low-level mechanisms that sit very close to the operating system. Unlike - which is relatively process-focused - and - which models block devices and more - is a useful interface to many abstractions that the kernel models. /proc /dev /sys /proc /dev /sys For example, take the directory . Inside of this directory, you'll find a list of links that represent the network interfaces on your host. Here's what mine looks like: /sys/class/net ls /sys/class/net enp0s20f0u6u4u1
lo
tailscale0
wlan0 As you can see, the active network connections that my system is managing include a wired interface (the interface that begins with ), the loopback interface, a interface, and my wireless interface . Listing the contents of one of these directories reveals a long list of files, but let's look more closely at two files in particular for my wired network interface: en lo Tailscale wlan0 cat /sys/class/net/enp0s20f0u6u4u1/statistics/rx_bytes
cat /sys/class/net/enp0s20f0u6u4u1/statistics/tx_bytes 11281235262
274308842 Each of these files represents the number of received bytes and transmitted bytes, respectively. Check out how the numbers change if I use the same command a few seconds later: cat /sys/class/net/enp0s20f0u6u4u1/statistics/rx_bytes
cat /sys/class/net/enp0s20f0u6u4u1/statistics/tx_bytes 11289633209
274760138 Bigger numbers! Apparently I'm making the most of my bandwidth. How is this useful? Have you ever wondered how network usage widgets are written? Well, how about making your own? Check out this small script that uses the aforementioned files in the directory to derive a network activity rate. bash statistics interval=1
interface=$1

rx_bytes=$(cat /sys/class/net/$interface/statistics/rx_bytes)
tx_bytes=$(cat /sys/class/net/$interface/statistics/tx_bytes)

rx_bytes_rate=0
tx_bytes_rate=0

function fmt() {
  numfmt --to=iec-i --suffix=B $1
}

while true
do
        echo -en " $(fmt $tx_bytes_rate)/s ⬆ $(fmt $rx_bytes_rate)/s ⬇\t\r"
        sleep $interval
        old_rx_bytes=$rx_bytes
        old_tx_bytes=$tx_bytes
        rx_bytes=$(cat /sys/class/net/$interface/statistics/rx_bytes)
        tx_bytes=$(cat /sys/class/net/$interface/statistics/tx_bytes)
        tx_bytes_rate=$(( ($tx_bytes - $old_tx_bytes) / $interval ))
        rx_bytes_rate=$(( ($rx_bytes - $old_rx_bytes) / $interval ))
done You can place this script somewhere in your , make it executable with , and try it out with . Here's what the output looks like on my machine: $PATH chmod +x <script> script.sh <interface name> 13KiB/s ⬆  379KiB/s ⬇ That's pretty cool! You can imagine some uses for this: for example, as a widget for a tool that can render command output or as a quick way to look at network activity for a particular network interface. In either case, the file-based interface to this data makes accessing and using it exceptionally easy. Further Exploration This was just a small dive into the types of information available to you as you look further into the capabilities of a modern Linux system. You can search for additional guides like this one or go straight to the source by reading pages for entries like in order to read the function and purpose of various directories in . man man hier / Have fun exploring!

20,000 Leagues Under Your Shell

20.000 leguas bajo tu caparazón

20 000 lieues sous votre coquille

20,000 लीग अंडर योर शेल

シェルの下で 20,000 マイル

20.000 léguas sob sua concha

20.000 giải đấu dưới vỏ bọc của bạn

20,000 联赛在您的壳下

A Javascript object is a collection of properties and some member methods. Use the “.” symbol to operate property values. We know that the string is not an object, so why does it have properties? Because V8 converts a string into an object first when operating the properties of the string. The conversion is invisible to developers. But in V8, you can see the conversion detail and understand the source code of the String object. In this paper, we’ll talk about the conversion from a string to a string object. 1. String variable 1.var s = "hello world!";
2.var word = s.substring(s.indexOf(" ")+1,s.length);
3.console.log(word) Look at the above code, the string s is not an object, but when we call .indexOf(), V8 will convert s to a string object. Let’s talk about conversion from the following two questions. In the 1st line, let’s take a look at what type is? (1) s In the 2nd line, when we call .indexOf, how does V8 convert it to an object? (2) Look at the code below, which is the bytecode data of our case. 1.  [generated bytecode for function:  (0x03d78d381bd1 <SharedFunctionInfo>)]
2.  Parameter count 1
3.  Register count 6
4.  Frame size 48
5.           000003D78D381D06 @    0 : 12 00             LdaConstant [0]
6.           000003D78D381D08 @    2 : 26 fa             Star r1
7.           000003D78D381D0A @    4 : 0b                LdaZero
8.           000003D78D381D0B @    5 : 26 f9             Star r2
9.           000003D78D381D0D @    7 : 27 fe f8          Mov <closure>, r3
10.           000003D78D381D10 @   10 : 61 2d 01 fa 03    CallRuntime [DeclareGlobals], r1-r3
11.      0 E> 000003D78D381D15 @   15 : a7                StackCheck
12.      8 S> 000003D78D381D16 @   16 : 12 01             LdaConstant [1]
13.      8 E> 000003D78D381D18 @   18 : 15 02 04          StaGlobal [2], [4]
14.     36 S> 000003D78D381D1B @   21 : 13 02 00          LdaGlobal [2], [0]
15.           000003D78D381D1E @   24 : 26 f9             Star r2
16.     38 E> 000003D78D381D20 @   26 : 29 f9 03          LdaNamedPropertyNoFeedback r2, [3]
17.           000003D78D381D23 @   29 : 26 fa             Star r1
18.     48 E> 000003D78D381D25 @   31 : 13 02 00          LdaGlobal [2], [0]
19.           000003D78D381D28 @   34 : 26 f7             Star r4
20.     50 E> 000003D78D381D2A @   36 : 29 f7 04          LdaNamedPropertyNoFeedback r4, [4]
21.           000003D78D381D2D @   39 : 26 f8             Star r3
22.           000003D78D381D2F @   41 : 12 05             LdaConstant [5]
23.           000003D78D381D31 @   43 : 26 f6             Star r5
24.     50 E> 000003D78D381D33 @   45 : 5f f8 f7 02       CallNoFeedback r3, r4-r5
25.     62 E> 000003D78D381D37 @   49 : 40 01 06          AddSmi [1], [6]
26.           000003D78D381D3A @   52 : 26 f8             Star r3
27.     65 E> 000003D78D381D3C @   54 : 13 02 00          LdaGlobal [2], [0]
28.           000003D78D381D3F @   57 : 26 f7             Star r4
29.     67 E> 000003D78D381D41 @   59 : 29 f7 06          LdaNamedPropertyNoFeedback r4, [6]
30.           000003D78D381D44 @   62 : 26 f7             Star r4
31.  //....omit......
32.  Constant pool (size = 10)
33.  000003D78D381C71: [FixedArray] in OldSpace
34.   - map: 0x03ac45880169 <Map>
35.   - length: 10
36.             0: 0x03d78d381c11 <FixedArray[8]>
37.             1: 0x03d78d381b69 <String[#12]: hello world!>
38.             2: 0x03d78d381b51 <String[#1]: s>
39.             3: 0x02ed266ea9e9 <String[#9]: substring>
40.             4: 0x02ed266e8121 <String[#7]: indexOf>
41.             5: 0x006d3e183c21 <String[#1]:  >
42.             6: 0x03ac45884819 <String[#6]: length>
43.             7: 0x03ac45885301 <String[#4]: word>
44.             8: 0x02ed266f2441 <String[#7]: console>
45.             9: 0x02ed266f1a81 <String[#3]: log>
46.  Handler Table (size = 0) Before diving in, let’s take a look at a concept — constant pool(from lines 32 to 45), which is a string-type array generated during JavaScript compilation and used to store constants. The 37th line is the string and the 38th line code is the string s, these two lines are the variable s we are talking about. hello world! Let’s look at lines 12 and 13, LdaConstant loads the constant-pool[1] into the accumulator, and StaGlobal uses the constant-pool[2] as the name to store the accumulator. What is the meaning of these two lines? They are declaring the string variable s(var s = “hello world!”) for our case. Debug line 13 to find out how to store the value of variable in detail. If we can see how to store s, we can see his type incidentally. s After Debugging, we find the following code will be called. RUNTIME_FUNCTION(Runtime_StoreGlobalICNoFeedback_Miss) {
  HandleScope scope(isolate);
  DCHECK_EQ(2, args.length());
  // Runtime functions don't follow the IC's calling convention.
  Handle<Object> value = args.at(0);
  Handle<Name> key = args.at<Name>(1);

  // TODO(mythria): Replace StoreGlobalStrict/Sloppy with StoreNamed.
  StoreGlobalIC ic(isolate, Handle<FeedbackVector>(), FeedbackSlot(),
                   FeedbackSlotKind::kStoreGlobalStrict);
  RETURN_RESULT_OR_FAILURE(isolate, ic.Store(key, value));
}
//.................separation...................................
#define RETURN_RESULT_OR_FAILURE(isolate, call)      \
  do {                                               \
    Handle<Object> __result__;                       \
    Isolate* __isolate__ = (isolate);                \
    if (!(call).ToHandle(&__result__)) {             \
      DCHECK(__isolate__->has_pending_exception());  \
      return ReadOnlyRoots(__isolate__).exception(); \
    }                                                \
    DCHECK(!__isolate__->has_pending_exception());   \
    return *__result__;                              \
  } while (false) In the above code, the RETURN_RESULT_OR_FAILURE is a macro template. We go on with debugging the code and step into the WriteDataValue() which is below. void LookupIterator::WriteDataValue(Handle<Object> value,
                                    bool initializing_store) {
  DCHECK_EQ(DATA, state_);
  Handle<JSReceiver> holder = GetHolder<JSReceiver>();
  if (IsElement()) {
    Handle<JSObject> object = Handle<JSObject>::cast(holder);
    ElementsAccessor* accessor = object->GetElementsAccessor(isolate_);
    accessor->Set(object, number_, *value);
  } else if (holder->HasFastProperties(isolate_)) {
    if (property_details_.location() == kField) {
  //omit......................... In WriteDataValue, determine whether the parameter value is a global object. In our case, the value is our s apparently, which is a global object and meets the condition in Figure 1. Look at the green marks in Figure 1, the value is our , and its type is ONE_BYTE_INTERNALIZED_STRING, which solves question 1 exactly. hello world! 2. String object Let’s take a look at question 2, how to convert a string variable to an object. Our case is calling .substring(). In the bytecode array of the case, lines 14 and 15 have stored the variable s in register r2, line 16 needs to load .substring() for r2, and the below bytecode LdaNamedPropertyNoFeedback is responsible for loading properties. 1.  IGNITION_HANDLER(LdaNamedPropertyNoFeedback, InterpreterAssembler) {
2.    TNode<Object> object = LoadRegisterAtOperandIndex(0);
3.    TNode<Name> name = CAST(LoadConstantPoolEntryAtOperandIndex(1));
4.    TNode<Context> context = GetContext();
5.    TNode<Object> result =
6.        CallBuiltin(Builtins::kGetProperty, context, object, name);
7.    SetAccumulator(result);
8.    CallRuntime(Runtime::kDebugPrint, context, object, name,result);//This is the debug command I wrote,@huidou
9.    Dispatch();
10.  }
11.  //.........................separation.........................................
12.  TF_BUILTIN(GetProperty, CodeStubAssembler) {
13.    Node* object = Parameter(Descriptor::kObject);
14.    Node* key = Parameter(Descriptor::kKey);
15.    Node* context = Parameter(Descriptor::kContext);
16.    // TODO(duongn): consider tailcalling to GetPropertyWithReceiver(object,
17.    // object, key, OnNonExistent::kReturnUndefined).
18.    Label if_notfound(this), if_proxy(this, Label::kDeferred),
19.        if_slow(this, Label::kDeferred);
20.    CodeStubAssembler::LookupInHolder lookup_property_in_holder =
21.        [=](Node* receiver, Node* holder, Node* holder_map,
22.            Node* holder_instance_type, Node* unique_name, Label* next_holder,
23.            Label* if_bailout) {
24.          VARIABLE(var_value, MachineRepresentation::kTagged);
25.          Label if_found(this);
26.          TryGetOwnProperty(context, receiver, holder, holder_map,
27.                            holder_instance_type, unique_name, &if_found,
28.                            &var_value, next_holder, if_bailout);
29.          BIND(&if_found);
30.          Return(var_value.value());
31.        };
32.    CodeStubAssembler::LookupInHolder lookup_element_in_holder =
33.        [=](Node* receiver, Node* holder, Node* holder_map,
34.            Node* holder_instance_type, Node* index, Label* next_holder,
35.            Label* if_bailout) {
36.          // Not supported yet.
37.          Use(next_holder);
38.          Goto(if_bailout);
39.        };
40.    TryPrototypeChainLookup(object, object, key, lookup_property_in_holder,
41.                            lookup_element_in_holder, &if_notfound, &if_slow,
42.                            &if_proxy);
43.    BIND(&if_notfound);
44.    Return(UndefinedConstant());
45.    BIND(&if_slow);
46.    TailCallRuntime(Runtime::kGetProperty, context, object, key);
47.    BIND(&if_proxy);
48.    {
49.      // Convert the {key} to a Name first.
50.      TNode<Object> name = CallBuiltin(Builtins::kToName, context, key);
51.      // The {object} is a JSProxy instance, look up the {name} on it, passing
52.      // {object} both as receiver and holder. If {name} is absent we can safely
53.      // return undefined from here.
54.      TailCallBuiltin(Builtins::kProxyGetProperty, context, object, name, object,
55.                      SmiConstant(OnNonExistent::kReturnUndefined));
56.    }
57.  } In the process of debugging LdaNamedPropertyNoFeedback, we can only see the assembly code, but not the C++ source code. The bytecode is stored separately in the snapshot_blob file and loaded by V8 in the deserialized way without the symbol table, so we can’t see C++. The 8th line of code is my additional CallRuntime, which is used to return to the C++ environment for watching variables. Look at Figure 2. With the help of line 8, we can get back to the C++ environment. Here, we can only watch variables, not debug. We will return to the assembly environment if we do a step. Figure 3 is the call stack. To sum up, in Figure 2, the args[0] is ‘hello world!’, which is the global variable s declared before. Note that its type is still ONE_BYTE_INTERNALIZED_STRING. Let’s look at args[2], its type is JS_FUNCTION, which is the address of the substring() method. At this point, the operation is completed, and s is still a string. Actually, it doesn’t prevent V8 from calling the substring and returning the value. This is the implementation style of V8, the engineering method and technical principle may be dissimilar. . 3. Summary In v8, the String is subdivided into many subtypes which are below. switch (map.instance_type()) {
    case CONS_STRING_TYPE:
    case CONS_ONE_BYTE_STRING_TYPE:
    case THIN_STRING_TYPE:
    case THIN_ONE_BYTE_STRING_TYPE:
    case SLICED_STRING_TYPE:
    case SLICED_ONE_BYTE_STRING_TYPE:
    case EXTERNAL_STRING_TYPE:
    case EXTERNAL_ONE_BYTE_STRING_TYPE:
    case UNCACHED_EXTERNAL_STRING_TYPE:
    case UNCACHED_EXTERNAL_ONE_BYTE_STRING_TYPE:
    case STRING_TYPE:
    case ONE_BYTE_STRING_TYPE:
    //omit........................ When using .substring(), the variable is still a string. In the V8 implementation, the string is a heap-managed object, but as I’ve mentioned, its type is the string. s Below is the function I use to debug a bytecode, it is Runtime, and the usage is CallRuntime(Runtime::kDebugPrint, context, your args0, your args1….). You can see how I use it in the code above. 1.  RUNTIME_FUNCTION(Runtime_DebugPrint) {
2.    SealHandleScope shs(isolate);
3.    //DCHECK_EQ(1, args.length());
4.    MaybeObject maybe_object(*args.address_of_arg_at(0));
5.    StdoutStream os;
6.    if (maybe_object->IsCleared()) {
7.      os << "[weak cleared]";
8.    } else {
9.      Object object = maybe_object.GetHeapObjectOrSmi();
10.      bool weak = maybe_object.IsWeak();
11.  #ifdef DEBUG
12.      if (object.IsString() && !isolate->context().is_null()) {
13.        DCHECK(!weak);
14.        // If we have a string, assume it's a code "marker"
15.        // and print some interesting cpu debugging info.
16.        object.Print(os);
17.        JavaScriptFrameIterator it(isolate);
18.        JavaScriptFrame* frame = it.frame();
19.        os << "fp = " << reinterpret_cast<void*>(frame->fp())
20.           << ", sp = " << reinterpret_cast<void*>(frame->sp())
21.           << ", caller_sp = " << reinterpret_cast<void*>(frame->caller_sp())
22.           << ": ";
23.      } else {
24.        os << "DebugPrint: ";
25.        if (weak) {
26.          os << "[weak] ";
27.        }
28.        object.Print(os);
29.      }
30.      if (object.IsHeapObject()) {
31.        HeapObject::cast(object).map().Print(os);
32.      }
33.  #else
34.      if (weak) {
35.        os << "[weak] ";
36.      }
37.      // ShortPrint is available in release mode. Print is not.
38.      os << Brief(object);
39.  #endif
40.    }
41.    os << std::endl;
42.    return args[0];  // return TOS
43.  } By the way, you can also use the function in your JavaScript source via the option. allow-natives-syntax 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. Also Published here

What is String Object Analysis in Chrome V8

Welcome to other chapters of Let’s Understand Chrome V8 Dispatch is responsible for scheduling bytecode, which is equivalent to registering EIP++, and jumps to the next bytecode. Dispatch consists of two parts, one is a dispatch table and the other is the physical register. The table is an array that contains all bytecode addresses. V8 uses the physical register to dispatch bytecode for getting greater efficiency. 1. Dispatch Table The dispatch table is an array of pointers, which is used to store the address of the bytecode processing program. The array type is Code, and the Code Class is below: class Code: public HeapObject {
    public: NEVER_READ_ONLY_SPACE
    using Flags = uint32_t;
    #define CODE_KIND_LIST(V)\
    V(OPTIMIZED_FUNCTION)\
    V(BYTECODE_HANDLER)\
    V(STUB)\
    V(BUILTIN)\
    V(REGEXP)\
    V(WASM_FUNCTION)\
    V(WASM_TO_CAPI_FUNCTION)\
    V(WASM_TO_JS_FUNCTION)\
    V(JS_TO_WASM_FUNCTION)\
    V(JS_TO_JS_FUNCTION)\
    V(WASM_INTERPRETER_ENTRY)\
    V(C_WASM_ENTRY)
    enum Kind {
      #define DEFINE_CODE_KIND_ENUM(name) name,
        CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
      #undef DEFINE_CODE_KIND_ENUM
      NUMBER_OF_KINDS
    };
    static
    const char * Kind2String(Kind kind);
    #ifdef ENABLE_DISASSEMBLER
    const char * GetName(Isolate * isolate) const;
    V8_EXPORT_PRIVATE void Disassemble(const char * name, std::ostream & os,
      Address current_pc = kNullAddress);
    #endif
    //................omit................
  }; : In the isolate, there is another pointer array that is the same type as the dispatch table. It holds all the Builtins addresses, which can confuse beginners easily. Note The dispatch table is maintained by BuildWithMacroAssembler, code is below: Code BuildWithMacroAssembler(Isolate * isolate, int32_t builtin_index,
    MacroAssemblerGenerator generator,
    const char * s_name) {
    HandleScope scope(isolate);
    // Canonicalize handles, so that we can share constant pool entries pointing
    // to code targets without dereferencing their handles.
    CanonicalHandleScope canonical(isolate);
    constexpr int kBufferSize = 32 * KB;
    byte buffer[kBufferSize];
    MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
      CodeObjectRequired::kYes,
      ExternalAssemblerBuffer(buffer, kBufferSize));
    masm.set_builtin_index(builtin_index);
    DCHECK(!masm.has_frame());
    generator( & masm);
    int handler_table_offset = 0;
    // JSEntry builtins are a special case and need to generate a handler table.
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSConstructEntry), Builtins::ASM);
    DCHECK_EQ(Builtins::KindOf(Builtins::kJSRunMicrotasksEntry), Builtins::ASM);
    if (Builtins::IsJSEntryVariant(builtin_index)) {
      handler_table_offset = HandlerTable::EmitReturnTableStart( & masm);
      HandlerTable::EmitReturnEntry( &
        masm, 0, isolate -> builtins() -> js_entry_handler_offset());
    }
    //.....................................................
    //................omit.............................
  } You can see regarding how to debug the BuildWithMacroAssembler. When the value of the parameter builtin_index is 65, the function pointer generator points to which is responsible for maintaining the Dispatch table, code is below: Chapter 9 Generate_InterpreterEnterBytecodeDispatch static void Generate_InterpreterEnterBytecode(MacroAssembler * masm) {
    // Set the return address to the correct point in the interpreter entry
    // trampoline.
    Label builtin_trampoline, trampoline_loaded;
    Smi interpreter_entry_return_pc_offset(
      masm -> isolate() -> heap() -> interpreter_entry_return_pc_offset());
    DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero);
    // If the SFI function_data is an InterpreterData, the function will have a
    // custom copy of the interpreter entry trampoline for profiling. If so,
    // get the custom trampoline, otherwise grab the entry address of the global
    // trampoline.
    __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset));
    __ LoadTaggedPointerField(
      rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset));
    __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister);
    __ j(not_equal, & builtin_trampoline, Label::kNear);
    __ movq(rbx,
      FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset));
    __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag));
    __ jmp( & trampoline_loaded, Label::kNear);
    __ bind( & builtin_trampoline);
    // TODO(jgruber): Replace this by a lookup in the builtin entry table.
    __ movq(rbx,
      __ ExternalReferenceAsOperand(
        ExternalReference::
        address_of_interpreter_entry_trampoline_instruction_start(
          masm -> isolate()),
        kScratchRegister));
    __ bind( & trampoline_loaded);
    __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value()));
    __ Push(rbx);
    // Initialize dispatch table register.
    __ Move(
      kInterpreterDispatchTableRegister,
      ExternalReference::interpreter_dispatch_table_address(masm -> isolate()));
    // Get the bytecode array pointer from the frame.
    __ movq(kInterpreterBytecodeArrayRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp));
    if (FLAG_debug_code) {
      // Check function data field is actually a BytecodeArray object.
      __ AssertNotSmi(kInterpreterBytecodeArrayRegister);
      __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
        rbx);
      __ Assert(
        equal,
        AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry);
    }
    // Get the target bytecode offset from the frame.
    __ movq(kInterpreterBytecodeOffsetRegister,
      Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
    __ SmiUntag(kInterpreterBytecodeOffsetRegister,
      kInterpreterBytecodeOffsetRegister);
    // Dispatch to the target bytecode.
    __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister,
      kInterpreterBytecodeOffsetRegister, times_1, 0));
    __ movq(kJavaScriptCallCodeStartRegister,
      Operand(kInterpreterDispatchTableRegister, r11,
        times_system_pointer_size, 0));
    __ jmp(kJavaScriptCallCodeStartRegister);
  }
  //================================separation=========================
  void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler * masm) {
    Generate_InterpreterEnterBytecode(masm);
  } In the above code, the is the entry point of bytecode dispatch, and the is the key code that implements the bytecode dispatch. Here are two important concepts: Generate_InterpreterEnterBytecodeDispatch Generate_InterpreterEnterBytecode The is a Builtin and its index is 65. (The index may be dissimilar in different V8 versions) Generate_InterpreterEnterBytecodeDispatch V8 uses a physical register to manage the dispatch table, the name of the register is . Using the physical register can avoid the push and pop of the dispatch table frequently, to improve efficiency. kInterpreterDispatchTableRegister Here are the key lines of code： Line 35, loads the dispatch table to the A register. Line 37 of code, take out the table address from the isolate. The implementation of A is in the below three functions. (1) ExternalReference ExternalReference::interpreter_dispatch_table_address(
  Isolate * isolate) {
  return ExternalReference(isolate -> interpreter() -> dispatch_table_address());
}
interpreter::Interpreter * interpreter() const {
  return interpreter_;
}
Address dispatch_table_address() {
  return reinterpret_cast < Address > ( & dispatch_table_[0]);
} Line 39 takes out the bytecode array from the stack. (2) Line 51 takes out the offset of the target bytecode from the bytecode array. (3) Lines 56 and 58 calculate the target bytecode address and store the address in kJavaScriptCallCodeStartRegister. (4) Line 61 jumps to register kJavaScriptCallCodeStartRegister and executes bytecode. Figure 1 is the call stack. (5) 2. TailCall The Dispatch() is the last step in a bytecode, so its alias is the tail call. Let’s look at a few bytecodes： IGNITION_HANDLER(StaGlobal, InterpreterAssembler) {
    TNode < Context > context = GetContext();
    //omit..............
    Goto( & end);
    Bind( & no_feedback);
    CallRuntime(Runtime::kStoreGlobalICNoFeedback_Miss, context, value, name);
    Goto( & end);
    Bind( & end);
    Dispatch(); // !!! this is the tail call.
  }
  IGNITION_HANDLER(LdaContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here also is.
  }
  IGNITION_HANDLER(LdaImmutableContextSlot, InterpreterAssembler) {
    TNode < Context > context = CAST(LoadRegisterAtOperandIndex(0));
    TNode < IntPtrT > slot_index = Signed(BytecodeOperandIdx(1));
    TNode < Uint32T > depth = BytecodeOperandUImm(2);
    TNode < Context > slot_context = GetContextAtDepth(context, depth);
    TNode < Object > result = LoadContextElement(slot_context, slot_index);
    SetAccumulator(result);
    Dispatch(); //!!! here 
  } The above three bytecodes all end with Dispatch(). Below is the code of Dispatch: void InterpreterAssembler::Dispatch() {
    Comment("========= Dispatch");
    DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
    TNode < IntPtrT > target_offset = Advance();
    TNode < WordT > target_bytecode = LoadBytecode(target_offset);
    if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
      target_bytecode = StarDispatchLookahead(target_bytecode);
    }
    DispatchToBytecode(target_bytecode, BytecodeOffset());
  } The 2nd line is the comment function. When debugging, we can use its output information to locate the execution position. The 4th line takes out the offset of the target(next) bytecode. The 5th line loads the target bytecode. The 9th line calls which calls eventually. DspatchToBytecode() DispatchToBytecodeHandlerEntry() void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
  TNode < RawPtrT > handler_entry, TNode < IntPtrT > bytecode_offset) {
  // Propagate speculation poisoning.
  TNode < RawPtrT > poisoned_handler_entry =
    UncheckedCast < RawPtrT > (WordPoisonOnSpeculation(handler_entry));
  TailCallBytecodeDispatch(InterpreterDispatchDescriptor {},
    poisoned_handler_entry, GetAccumulatorUnchecked(),
    bytecode_offset, BytecodeArrayTaggedPointer(),
    DispatchTablePointer());
} In , parameter 1 is the target bytecode and 2 is the offset of the bytecode. Parameter 1 is used to load the bytecode handler and 2 is used to load operands. Then call , which is below: DispatchToBytecodeHandlerEntry TailCallBytecodeDispatch template < class...TArgs >
    void CodeAssembler::TailCallBytecodeDispatch(
      const CallInterfaceDescriptor & descriptor, TNode < RawPtrT > target,
        TArgs...args) {
      DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
      auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
        zone(), descriptor, descriptor.GetStackParameterCount());
      Node * nodes[] = {
        target,
        args...
      };
      CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
      raw_assembler() -> TailCallN(call_descriptor, arraysize(nodes), nodes);
    } In the above code, the 5th line creates the descriptor, as below: CallDescriptor * Linkage::GetBytecodeDispatchCallDescriptor(
    Zone * zone,
    const CallInterfaceDescriptor & descriptor,
      int stack_parameter_count) {
    const int register_parameter_count = descriptor.GetRegisterParameterCount();
    const int parameter_count = register_parameter_count + stack_parameter_count;
    DCHECK_EQ(descriptor.GetReturnCount(), 1);
    LocationSignature::Builder locations(zone, 1, parameter_count);
    locations.AddReturn(regloc(kReturnRegister0, descriptor.GetReturnType(0)));
    for (int i = 0; i < parameter_count; i++) {
      if (i < register_parameter_count) {
        // The first parameters go in registers.
        Register reg = descriptor.GetRegisterParameter(i);
        MachineType type = descriptor.GetParameterType(i);
        locations.AddParam(regloc(reg, type));
      } else {
        int stack_slot = i - register_parameter_count - stack_parameter_count;
        locations.AddParam(LinkageLocation::ForCallerFrameSlot(
          stack_slot, MachineType::AnyTagged()));
      }
    }
    MachineType target_type = MachineType::Pointer();
    LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
    const CallDescriptor::Flags kFlags =
      CallDescriptor::kCanUseRoots | CallDescriptor::kFixedTargetRegister;
    return new(zone) CallDescriptor( // --
      CallDescriptor::kCallAddress, // kind
      target_type, // target MachineType
      target_loc, // target location
      locations.Build(), // location_sig
      stack_parameter_count, // stack_parameter_count
      Operator::kNoProperties, // properties
      kNoCalleeSaved, // callee-saved registers
      kNoCalleeSaved, // callee-saved fp
      kFlags, // flags
      descriptor.DebugName());
  } In , parameter 2 is the target bytecode, and parameter 3 is the stack parameter count. This function is used to apply for register resources and create a . The gives what parameters to supply when executing a bytecode. The comments on lines 24 to 25 give its layout. GetBytecodeDispatchCallDescriptor CallDescriptor CallDescriptor In , the on the 9th line is below, we see that it’s parameter 1 is . TailCallBytecodeDispatch TailCallN() CallDescriptor void RawMachineAssembler::TailCallN(CallDescriptor * call_descriptor,
    int input_count, Node *
    const * inputs) {
    // +1 is for target.
    DCHECK_EQ(input_count, call_descriptor -> ParameterCount() + 1);
    Node * tail_call =
      MakeNode(common() -> TailCall(call_descriptor), input_count, inputs);
    schedule() -> AddTailCall(CurrentBlock(), tail_call);
    current_block_ = nullptr;
  } The 5th line generates a node. In the 7th line adds the node to the end of the current basic block. So far, the dispatch is completed and the next bytecode is started to execute. Figure 2 shows the function call stack. AddTailCall() 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

Let's Understand Chrome V8 — Chapter 11: Bytecode Dispatch 

Improvements in the healthcare field are a vital aspect of the modern life progress. Scientists from different branches become one well-knit team delivering solutions for our soundness and healthy lifestyle. But no matter how great the scientific mind is, it needs a helping hand of the technical sphere — and that’s where mobile development gains strength. There are plenty of healthcare app types, but our attention today is focused on only one of them — apps managing chronic illnesses. In this case, a mobile tool contains data about all symptoms, medications, and doctor appointments. Your business has a chance to become a really helpful solution for hundreds of users. US Healthcare System: Problems Should Be Solved The growing number of healthcare apps is not a fashion choice — that’s a necessity for the whole healthcare industry. Let’s review some data that has gradually led to the appearance of mobile apps for patients. First, we should look at the spending per capita for medical services. The number rises each year, and in the US, the stats are really impressive: in 2000, the national expense was $4 881, and it became $10 300 in 2017 ( ). Less than 10 years have passed, but the index increased more than twice. Statista Among all patients, around 47.7% of Americans suffer from chronic diseases. With time, this number is expected to grow gradually up to 49.2% in 2030 ( ). Partnership to Fight Chronic Disease Number of People with Chronic Conditions Another long-term problem that the healthcare sphere faces is a lack of nursing specialists. According to the research provided by , at least 400 000 of professionals will be needed by 2020. The more time will pass the bigger problem it will become. Sigma It is some basic information on the medical industry in general, but these three important factors give us a triangle depicting the biggest current problems. Turning to modern technologies seems to be the fastest and safest way to move forward. That is the reason why chronic condition health apps have appeared. How to Manage Chronic Illnesses with a Mobile App Generally speaking, special apps for managing chronic conditions help both patients and doctors. There are three big groups of chronic diseases that have a huge influence on the healthcare industry: diabetes, heart diseases, and lung diseases. You can imagine what a thorough work should be done to properly manage this problem. But if patients regularly monitor their vitals and specific symptoms along with taking medications on time, less money would be spent on doctor appointments. So, we cope with two problems altogether. On the one hand, patients win because they save their budget, on the other hand, hospitals save some of their labor force in the tight conditions. You’ve probably guessed that achieving these two goals is possible with portable devices. Nowadays, smartphones or tablets are not wonderment for a broad audience anymore. On the contrary, it is the shortest way to make people’s life much easier. And we didn’t mention an important psychological aspect: people would more gladly communicate with their mobile phone than with a flesh-and-blood medical specialist. Why wait any longer? A new idea for a mobile solution is right in front of you. Chronic Condition Health Apps: What People Prefer to Monitor According to a report published by , we now have data on those vitals which are the most important for patients managing their chronic illnesses. The biggest number of patients is focused on three factors: Springer Blood pressure (28.5%) Blood glucose (28.1%) Weight (27.0%) What People Monitor with Their Smartphones By other factors, authors meant oxygen, temperature, asthma, respiration, etc. The thing is, mobile apps give patients an opportunity to gather this data quickly thanks to the flawless UX/UI design. Plus, all the data is stored in one place without a risk to lose it among other notes. But in addition to the list of vitals, there are some other things a patient should keep in mind: taking medications on time, finding a good doctor, remembering insurance details, and so on. Let’s see the list of some great app examples that will inspire you. 5 Best Applications for Chronic Condition Management Mobile apps have lots of options for the patients with a chronic condition. When building your own product, you can mix several mobile offers or focus on one specific advantage that will help hundreds of patients. Here is the list of the best chronic condition management apps you can find in the app stores. MyID This is a helpful app for every person — it is a database where each line of your medical card is stored. When you talk to your doctor or filling out a new medical form, all information you need will be already gathered in one place, i.e. in your mobile device. Imagine how useful may be for patients with chronic illnesses who often have a long medical history. MyID Medisafe The way of medical treatment can be sometimes exhausting and confusing for a patient. When you’ve got to take several pills every day, your memory is the main thing you rely on, except… can be installed on Android, iOS smartphones, or smart watches, and then they remind you about each pill and dosage. Besides, you can collaborate with a Medifriend who will be also informed when you miss a medication. Such apps allow patients to always stay on track. Medisafe PainScale is focused on tracking your pains and explaining it with more detail to your doctor: use drawings to express the pain’s location, build graphs to tell about the intensity of the pain, and describe its characteristics. Apart from that, patients can share their data with doctors and other app users, track other symptoms like fatigue or mood swings, and get the statistics on their condition. Users also have an access to reliable tips and articles from specialists. PainScale Fooducate That’s another one mobile solution helpful for all users — eating healthy is important for any of us. But the necessity of a diet increases by several times when it comes to managing chronic illnesses, and will be by your side. With this app, users can both track their food intake and get more knowledge about products, diets, and weight loss. And in case a user is giving up, he gets support from the Fooducate community, which is already quite broad. Fooducate TeMed And finally, it’s hard to manage any medical condition without the doctor’s mentoring. Guess what? Mobile apps can also help to find a specialist perfect for you. is a huge database of professionals from more than 50 medical specialties. With an advanced search feature, users may look for a doctor depending on the specific symptoms, and chronic conditions are among them. Next, you can make an appointment with a doctor and leave a review afterward to help other users choose. TeMed How Much Does It Cost to Build a Chronic Condition Management App? Now, here is the most interesting part. After a small market research, you’ve probably drawn an image of a perfect app, but what’s the price of its implementation? Let’s move step by step. This is the very foundation of the developer’s work because such workflows include tracking and managing medications along with marking symptoms and incidents. 1. Elements of the medical workflow. To connect doctors and patients, a development team should first take a thorough look at the graphic design and convenient user flow. This stage includes appointment scheduling and messaging. 2. Communications within the app. Chronic condition health apps always imply some work with the server: creating a personal profile, messaging within the app, synchronization with the email, etc. So, it will be also included in the list of necessary tasks. 3. The back-end side. Finally, you may have an idea to integrate your mobile product with certain hardware. We haven’t mentioned such type of solutions before, but they surely will do lots of help on the field of chronic illness management. 4. Integration with medical devices. Regarding all the work that should be done, creating an app managing chronic conditions takes around 2–3 months. If we take into account hourly rates of the Ukrainian developer (around $30), we get the price of a new app of $25 000-$30 000. To know a more precise cost considering all of your requirements, that will answer all of your questions. contact team of professionals Healthcare and Smartphones: A Perfect Union Virgil said that health is the greatest wealth. The modern world has changed a lot, but we can’t argue with this statement — we only care more about the wealth we have. As more people are diagnosed with a chronic disease, new industries should be involved. That’s how apps managing chronic conditions appeared on the market. Such tools help a lot those patients who have diabetes, asthma, problems with weight and blood pressure, etc. Moreover, people get a priceless support from the app’s community with similar problems. This way, gives the highest level of support to thousands of people over the globe. mobile app development

Stories, News & Mentions about TAILSCALE

Tailscale’s Stories on HackerNoon

Tailscale's News & Mentions