Tailcallis in the API Management Industry

Tailcall

A stack frame-by-frame breakdown of how TCP improves your memory footprint Every time we call a function, we stack another rock on top. This obviously does not scale. One of the behind-the-scenes changes that is coming with ES6 is support for tail call optimization (TCO). Tail call optimization means that, if the last expression in a function is a call to another function, then the engine will optimize so that the call stack does not grow. Let’s take a look. What is Tail Call Optimization? Tail call optimization means that it is possible to call a function from another function without growing the call stack. In order to understand the importance of that statement, we have to talk about how the stack works. You might be familiar with the word stack considering it is one of the most commonly seen data structures. It is a LIFO (last-in first-out) queue with two primary operators — and . The “call stack” is an implementation of the stack data structure used to navigate a program through function calls and store variables local to those functions. Consider the following code block: push pop (function wrapperFunction(){    console.log("Executing in the Wrapper Function");

    function functionA(a,b,c) {        console.log("Executing in Function A");        functionC(10,11);        return;    }

    function functionB(d,e,f) {        console.log("Executing in Function B");        return;    }

    function functionC(g,h) {        console.log("Executing in Function C");        return;    }

    functionA(20, 40, 60);    functionB(15, 25, 35);    functionC(17, 22, 27);})(); The output of the above block of code is Executing in the Wrapper FunctionExecuting in Function AExecuting in Function CExecuting in Function BExecuting in Function C What we have here are a series of function calls nested within one another. During runtime, when the engine sees the immediately-invoked function expression (IIFE) titled , it pushes a frame to the call stack which includes the parameters, a return address, and all variables currently in scope. That being said, our first frame of the call stack includes the return address to the global execution, the variables which are in scope, which, at this point, are none, and all variables passed into the function (also none). javascript wrapperFunction When we then call later on, the engine will push the call to to the stack. This frame will now include the return address back to the current location in and the values , , and to be stored in references , , and , respectively. functionA functionA wrapperFunction 20 40 60 a b c This process happens for every function call. If you look at the image below and read it from left to right, you can see this process happening. We begin by pushing the call on top of the global execution frame. Then, gets called and pushed onto the stack, followed by which is called by . Observe that you can tell which function is currently executing by looking at the top of the call stack and see which function called it by seeing which frame is below it. This is known as the stack trace of the function execution. wrapperFunction functionA functionC functionA The diagram represents the call stack of the code block above from left to right The diagram represents the call stack of the code block above from left to right (click to enlarge) So that brings us back to our original question: What is tail call optimization? The best example of a tail call is a recursive function. We know that a recursive function is one that calls itself, but what makes it a tail call? A tail recursive function is one that can get rid of its frame on the call stack after recursively calling itself. Example: Fibonacci Sequence The easiest way to tell that a function exhibits tail is by looking at the return statement in a function that calls itself. If the return statement of the recursive function is a call to itself, i.e and nothing else, then the javascript engine will be able to optimize the tail call and not grow the stack. recursion return recursiveFunction() As an example, we will create a function that calculate a Fibonacci number. The N’th Fibonacci number is the sum of the numbers at N-1 and N-2 in the same sequence with the first two numbers both being . 1 1, 1, 2, 3, 5, 8, 13, 21, ..., N-2, N-1, N The Fibonacci sequence up to the N’th digit Let’s think about how we could calculate the numbers above programatically. We know that a Fibonacci number is the sum of the previous two numbers, each of which are the sum of the two numbers that precede them, respectively. That being said, if we want to calculate the N’th Fibonacci number, we begin with the first number, , and an initial sum of (which we leverage to set) and then iterate through that summing process N number of times. 1 0 default parameters (function(){    function fib(n, sum=0, prev=1) {      if (n <= 1) return sum;      return fib(n-1, prev+sum, sum);    }    console.log(fib(20000));})(); The above is a tail recursive function. It does not need to hold onto its stack frame This might seem a little hard to follow, but it is really quite simple. is nothing more than a function that adds two numbers and then passes through that sum (to be used as the next N-1) to the next iteration, along with the number it just added (the next N-2) and the number of iterations left to run. fib It is tail recursive because the return statement consists solely of a call to itself, passing along all information that it needs with it. Therefore, the javascript engine optimized for tail recursion can dump that frame before pushing on the new one. Example 2: Non-tail Fibonacci Sequence To contrast the above example, let’s consider another implementation of the Fibonacci sequence, this time without using a tail recursive method. It was stated above that the N’th Fibonacci number is the sum of the fibonacci numbers at N-1 and N-2. Therefore, we can also implement it as the following: function fib(n) {    if (n <= 0) return 0;    if (n === 1 || n === 2) return 1;    return fib(n-1) + fib(n-2);}console.log(fib(20000)); //ERROR: maximum call stack size exceeded This is NOT a tail recursive function. It must hold a stack frame for each call. This function has calls to itself in the return statement, HOWEVER, it contains two of them in an addition statement. Therefore, as was the case in the very first example of this post, it needs to maintain a reference to state of the original calling function for every single iteration it goes through so it knows which two results to add. With that in mind, do not run this function in a console unless you want to crash it and, more importantly, do not write recursive functions that are not tail recursive. Example 3: Non-Recursive Tail Optimization TCO is not just for recursive functions. Any function that ends with an invocation of a function can be optimized. Let’s return to the first example of the post and change the invocation of within to be a tail call. functionC functionA (function wrapperFunction(){

    console.log("Executing in the Wrapper Function");

    function functionA(a,b,c) {        console.log("Executing in Function A");        return functionC(10,11);  //Now a tail-call    }

    function functionB(d,e,f) {        console.log("Executing in Function B");        return;    }

    function functionC(g,h) {        console.log("Executing in Function C");        return;    }

    functionA(20, 40, 60);    functionB(15, 25, 35);    functionC(17, 22, 27);})(); The invocation of from within is now a tail call functionC functionA In the example above, the return statement of is a call to . Programmatically, this means that there is no need to return to after the completion of since all we want to do is return the value. Therefore, the optimizer will pop off the frame and push the frame with a return address to . The return address is the crucial thing to note here. Without TCO, the return address would be , meaning that we would not be able to drop that stack frame. By including the return address to , however, we can safely drop the frame and the program will run as intended. functionA functionC functionA functionC functionA functionC wrapperFunction functionA wrapperFunction functionA The tail call optimizer can drop the stack call frame before pushing functionA functionC How to Use In my experience as a javascript developer, it is not TOO often that you have to write recursive functions, but it definitely does happen. So, if you find yourself thinking that you need a recursive function, you should do your best to make it tail recursive. This saves a lot of processing power and prevents the possibility of a stack overflow. On the other hand, it is very common to have function invocations embedded within other functions. Whenever you see a function with an embedded function invocation, you should consider if it is possible to rearrange the expressions and logic so that you are navigating through the functions using tail calls. This will allow the engine to optimize and drop off unnecessary stack frames, saving processing power and improving performance Important Notes on Browser/Engine Support EDIT 5/7/19 — Unfortunately, as far as I know, Safari is the only browser that supports proper tail calls as described in the ES5 specification. I am going to leave this post up, but will be making some edits so that it’s clear this feature is not yet able to be used and might not ever be.

Tail Call Optimization (TCO) in JavaScript

La Constantin by Alexandre Dumas, is part of the HackerNoon Books Series. You can jump to any chapter in this book here . Chapter I LA CONSTANTIN - CHAPTER I Before beginning our story, we must warn the reader that it will not be worth his while to make researches among contemporary or other records as to the personage whose name it bears. For in truth neither Marie Leroux, widow of Jacques Constantin, nor her accomplice, Claude Perregaud, was of sufficient importance to find a place on any list of great criminals, although it is certain that they were guilty of the crimes with which they were charged. It may seem strange that what follows is more a history of the retribution which overtook the criminals than a circumstantial description of the deeds for which they were punished; but the crimes were so revolting, and so unsuitable for discussion, that it was impossible for us to enter into any details on the subject, so that what we offer in these pages is, we confess quite openly, not a full, true, and particular account of a certain series of events leading up to a certain result; it is not even a picture wherein that result is depicted with artistic completeness, it is only an imperfect narrative imperfectly rounded off. We feel sure, however, that the healthy-minded reader will be grateful for our reticence and total disregard of proportion. In spite of the disadvantage which such a theme imposes on any writer with a deep sense of responsibility, we have resolved to let in some light on these obscure figures; for we can imagine no more effective way of throwing into high relief the low morals and deep corruption into which all classes of society had sunk at the termination of the factious dissensions of the Fronde, which formed such a fitting prelude to the licence of the reign of the grand roi. After this explanation, we shall, without further preamble, introduce the reader to a little tavern in Paris, situated in the rue Saint-Andre-des-Arts, on an evening in November 1658. It was about seven o’clock. Three gentlemen were seated at one of the tables in a low, smoky room. They had already emptied several bottles, and one of them seemed to have just suggested some madcap scheme to the others, the thought of which sent them off into shouts of laughter. “Pardu!” said one of them, who was the first to recover his breath, “I must say it would be an excellent trick.” “Splendid!” said another; “and if you like, Commander de Jars, we can try it this very evening.” “All right, my worthy king’s treasurer, provided my pretty nephew here won’t be too much shocked,” and as he spoke de Jars gave to the youngest of the three a caressing touch on the cheek with the back of his hand. “That reminds me, de Jars!” said the treasurer, “that word you have just said piques my curiosity. For some months now this little fellow here, Chevalier de Moranges, follows you about everywhere like your shadow. You never told us you had a nephew. Where the devil did you get him?” The commander touched the chevalier’s knee under the table, and he, as if to avoid speaking, slowly filled and emptied his glass. “Look here,” said the treasurer, “do you want to hear a few plain words, such as I shall rap out when God takes me to task about the peccadilloes of my past life? I don’t believe a word about the relationship. A nephew must be the son of either a brother or a sister. Now, your only sister is an abbess, and your late brother’s marriage was childless. There is only one way of proving the relationship, and that is to confess that when your brother was young and wild he and Love met, or else Madame l’Abbesse——.” “Take care, Treasurer Jeannin! no slander against my sister!” “Well, then, explain; you can’t fool me! May I be hanged if I leave this place before I have dragged the secret out of you! Either we are friends or we are not. What you tell no one else you ought to tell me. What! would you make use of my purse and my sword on occasion and yet have secrets from me? It’s too bad: speak, or our friendship is at an end! I give you fair warning that I shall find out everything and publish it abroad to court and city: when I strike a trail there’s no turning me aside. It will be best for you to whisper your secret voluntarily into my ear, where it will be as safe as in the grave.” “How full of curiosity you are, my good friend!” said de Jars, leaning one elbow on the table, and twirling the points of his moustache with his hand; “but if I were to wrap my secret round the point of a dagger would you not be too much afraid of pricking your fingers to pull it off?” “Not I,” said the king’s treasurer, beginning to twirl his moustache also: “the doctors have always told me that I am of too full a complexion and that it would do me all the good in the world to be bled now and then. But what would be an advantage to me would be dangerous to you. It’s easy to see from your jaundiced phiz that for you blood-letting is no cure.” “And you would really go that length? You would risk a duel if I refused to let you get to the bottom of my mystery?” “Yes, on my honour! Well, how is it to be?” “My dear boy,” said de Jars to the youth, “we are caught, and may as well yield gracefully. You don’t know this big fellow as well as I do. He’s obstinacy itself. You can make the most obstinate donkey go on by pulling its tail hard enough, but when Jeannin gets a notion into his pate, not all the legions of hell can get it out again. Besides that, he’s a skilful fencer, so there’s nothing for it but to trust him.” “Just as you like,” said the young man; “you know all my circumstances and how important it is that my secret should be kept.” “Oh! among Jeannin’s many vices there are a few virtues, and of these discretion is the greatest, so that his curiosity is harmless. A quarter of an hour hence he will let himself be killed rather than reveal what just now he is ready to risk his skin to find out, whether we will or no.” Jeannin nodded approvingly, refilled the glasses, and raising his to his lips, said in a tone of triumph— “I am listening, commander.” “Well, if it must be, it must. First of all, learn that my nephew is not my nephew at all.” “Go on.” “That his name is not Moranges.” “And the next?” “I am not going to reveal his real name to you.” “Why not?” “Because I don’t know it myself, and no more does the chevalier.” “What’ nonsense!” “No nonsense at all, but the sober truth. A few months ago the chevalier came to Paris, bringing me a letter of introduction from a German whom I used to know years ago. This letter requested me to look after the bearer and help him in his investigations. As you said just now, Love and someone once met somewhere, and that was about all was known as to his origin. Naturally the young man wants to cut a figure in the world, and would like to discover the author of his existence, that he may have someone at hand to pay the debts he is going to incur. We have brought together every scrap of information we could collect as to this person, hoping to find therein a clue that we could follow up. To be quite open with you, and convince you at the same time how extremely prudent and discreet we must be, I must tell you that we think we have found one, and that it leads to no less a dignitary than a Prince of the Church. But if he should get wind of our researches too soon everything would be at an end, don’t you see? So keep your tongue between your teeth.” “Never fear,” said Jeannin. “Now, that’s what I call speaking out as a friend should. I wish you luck, my gallant Chevalier de Moranges, and until you unearth your father, if you want a little money, my purse is at your service. On my word, de Jars, you must have been born with a caul. There never was your equal for wonderful adventures. This one promises well-spicy intrigues, scandalous revelations, and you’ll be in the thick of it all. You’re a lucky fellow! It’s only a few months since you had the most splendid piece of good fortune sent you straight from heaven. A fair lady falls in love with you and makes you carry her off from the convent of La Raquette. But why do you never let anyone catch a glimpse of her? Are you jealous? Or is it that she is no such beauty, after all, but old and wrinkled, like that knave of a Mazarin?” “I know what I’m about,” answered de Jars, smiling; “I have my very good reasons. The elopement caused a great deal of indignation, and it’s not easy to get fanatics to listen to common sense. No, I am not in the least jealous; she is madly in love with me. Ask my nephew.” “Does he know her?” “We have no secrets from each other; the confidence between us is without a flaw. The fair one, believe me, is good to look on, and is worth all the ogling, fan-flirting baggages put together that one sees at court or on the balconies of the Palais Roy: ah! I’ll answer for that. Isn’t she, Moranges?” “I’m quite of your opinion,” said the youth; exchanging with de jars a singularly significant look; “and you had better treat her well, uncle, or I shall play you some trick.” “Ah! ah!” cried Jeannin. “You poor fellow! I very much fear that you are warming a little serpent in your bosom. Have an eye to this dandy with the beardless chin! But joking apart, my boy, are you really on good terms with the fair lady?” “Certainly I am.” “And you are not uneasy, commander?” “Not the least little bit.” “He is quite right. I answer for her as for my self, you know; as long as he loves her she will love him; as long as he is faithful she will be faithful. Do you imagine that a woman who insists on her lover carrying her off can so easily turn away from the man of her choice? I know her well; I have had long talks with her, she and I alone: she is feather-brained, given to pleasure, entirely without prejudices and those stupid scruples which spoil the lives of other women; but a good sort on the whole; devoted to my uncle, with no deception about her; but at the same time extremely jealous, and has no notion of letting herself be sacrificed to a rival. If ever she finds herself deceived, good-bye to prudence and reserve, and then—” A look and a touch of the commander’s knee cut this panegyric short, to which the treasurer was listening with open-eyed astonishment. “What enthusiasm!” he exclaimed. “Well, and then——” “Why, then,” went on the young man, with a laugh, “if my uncle behaves badly, I, his nephew, will try to make up for his wrong-doing: he can’t blame me then. But until then he may be quite easy, as he well knows.” “Oh yes, and in proof of that I am going to take Moranges with me to-night. He is young and inexperienced, and it will be a good lesson for him to see how a gallant whose amorous intrigues did not begin yesterday sets about getting even with a coquette. He can turn it to account later on. “On my word,” said Jeannin, “my notion is that he is in no great need of a teacher; however, that’s your business, not mine. Let us return to what we were talking about just now. Are we agreed; and shall we amuse ourselves by paying out the lady in, her own coin?” “If you like.” “Which of us is to begin?” De Jars struck the table with the handle of his dagger. “More wine, gentlemen?” said the drawer, running up. “No, dice; and be quick about it.” “Three casts each and the highest wins,” said Jeannin. “You begin.” “I throw for myself and nephew.” The dice rolled on the table. “Ace and three.” “It’s my turn now. Six and five.” “Pass it over. Five and two.” “We’re equal. Four and two.” “Now let me. Ace and blank.” “Double six.” “You have won.” “And I’m off at once,” said Jeannin, rising, and muffling himself in his mantle, “It’s now half-past seven. We shall see each other again at eight, so I won’t say good-bye.” “Good luck to you!” Leaving the tavern and turning into the rue Pavee, he took the direction of the river. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Alexandre Dumas (2004). La Constantin. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/2749/pg2749-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html.

Before beginning our story

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 

This post is substantially directed to non Haskellers. Haskell frequently appears on or /r/programming but the content is commonly evangelizing some aspect of functional programming, strong types, and purity. hackernews Haskell embodies all those things, but the practicality does not come from strongly typed functional programming, it comes from the power of the runtime. Other strongly typed functional languages such as exist, but many aspects are . Here I explore some of runtime properties that greatly contribute to the Haskell's power, performance, and convenience. OCaml not nearly as mature Numerous Haskell implementation exist ( , , ) however we will specifically go over which is by far the most used, and powerful. FLRC UHC JHC GHC Asynchronous Exceptions In almost all languages exceptions are thrown by the executing thread. In throwing an exception would look something like this: C++ { ( == ) { ::runtime_error( );
    }
} {
    doAction();
} ( ::exception& err) { << err.what() << :: ;
} void doAction () if 1 0 throw std "the impossible happened" try catch const std cout std endl In Haskell *any* thread can throw an exception to another thread. Let's spawn a thread and then immediately kill it by throwing an exception from outside of it. No modification of the thread or function itself is required. <- forkIO myLongRunningAction threadId threadId throwTo MyException This capability ends up being incredibly powerful. All of a sudden, features that might normally be implemented as fundamental properties of the language can now be expressed within it. An example of this is . Timeout takes a timeout in microseconds, an action to run, and may or may not return a result depending on if the action completes in time. Internally it spawns a thread with a timer, and should a deadline be hit issues an exception to the other threads computation. timeout :: Int -> IO a -> IO (Maybe a) In a language like a goroutine cannot be killed externally. A common pattern emerges where authors manually wait on channels to ensure can be controlled: Go stop := ( ) { { { <- stop: }
    }
}()

stop <- make chan bool go func () for select case return true Should a mistake be made resources will leak, and more complicated control flows must be continually duplicated. Even killing a thread utilizing owned resources such as sockets is safe in Haskell because of constructs built on that automatically cleanup resources. bracket Automatic detection of failure cases is hard. Language features to make screwing up harder . While Haskell will not stop you from deadlocking your program, the runtime has tooling to detect when this happens and throw an exception such as in the deadlocked code. Fearless concurrency are in the works BlockedIndefinitelyOnMVar Haskell is so while less common, if an unproductive infinite loop is detected a exception may be thrown. This is however . lazy NonTermination not perfect Haskell has limiting required stack size however a recoverable can be thrown. Various arithmetic exceptions exist for numeric errors such as , or . tail call optimization StackOverflow Overflow DivideByZero Each thread can have independently set allocation limits via which causes an exception. This can be useful for handling . setAllocationCounter AllocationLimitExceeded multitenancy Green threads and asynchronous networking Most languages have some implementation of , but few have it as the primary mode of computation. The success of , and for writing networked applications is heavily tied to this model of concurrency. Languages such as that implement the functionality as a library, have . green threads Go Erlang Rust substantial ergonomics implications Standard POSIX consume substantially more resources than green threads, and utilize the operating systems scheduler. On my system: pthreads > -a | grep stack
stack size (kbytes, -s) 8192 ulimit the default thread stack size as 8 megabytes. Technically Linux does lazy allocation via virtual memory, however even *spawning and killing* a thread can consume . thousands of CPU cycles Scaling to a large number of concurrent users (generally known as the ), is usually accomplished via asynchronous IO operations. Asynchronous IO multiplexing combined with a low level of parallelism is how services such as attain such high performance. C10K problem NGINX GHC internally utilizes epoll, or kqueue depending on platform. And support for the new io_uring Linux API is being , which can bring . experimented with already substantial performance gains Of green thread implementations, Haskell's is among the most powerful. For example with you can inspect the status of a thread, and if blocked even see *why*: threadStatus :: ThreadId -> IO ThreadStatus = | | | | | data BlockReason BlockedOnMVar -- ^blocked on 'MVar' BlockedOnBlackHole -- ^blocked on a computation in progress by another thread BlockedOnException -- ^blocked in 'throwTo' BlockedOnSTM -- ^blocked in 'retry' in an STM transaction BlockedOnForeignCall -- ^currently in a foreign call BlockedOnOther Performance tuning and GC Some languages such as Java are famous for the . A garbage collector cannot be perfect for every workload. There exist among others. tuning capabilities throughput and latency tradeoffs By default, a generational copying collector is used by the runtime. GHC has a wide variety of . One of particular interest is to enable optimizations for high core count multi CPU servers which have higher communication overhead. flags to flip, and knobs to turn --numa Profiling and related tooling Haskell has a full range of tooling to support debugging and building complex applications: Code coverage reporting via HCP. Time profiling flamegraphs via ghc-prof-flamegraph Space profiling graphs via hp2ps Also published on: https://harporoeder.com/posts/haskell-runtime/

Functional Programming is not What Makes Haskell Great

Did you know that recursion can be optimized using a concept which works similar to the way how we jump on a  trampoline. Let me elaborate, in recursion a function calls itself without finishing its own execution. As execution cannot be finished until the next function call returns (or finished execution) and this goes on for further function calls. This creates a stack of unfinished function calls and due to memory constraints there can only be a certain limit of function calls allowed in a stack. But situations with a large number of recursion calls in javascript does not lead to stack overflow, javascript prevents from reaching that limit by throwing a range error. Consider this example, { { (test > ) test; increment(++test);
  } { .log( , test);
  }
} ( ) function increment test try if 1000000 return return catch console "test===>" If you run the above code, it will go into the catch block pretty soon. On a macbook air 2k19, it maxed out around 10K. That means there was a stack overflow. Well in the above example the function calls itself in the return statement, this adds on to the stack one more function call to and this call will again add on to the stack one more function call to and this keeps going on until it reaches the base condition, when becomes greater than , but that never happens. increment increment increment initialValue 1000000 But here if you notice that recursion call is a tail call. A tail call is when a recursion call only happens at the end of the function in a return statement. Why do we need to concern ourselves with the tail call and how does it matter? The trampoline technique that we are about to learn only works when we have recursion defined as a tail call. This will become more clear once we look at the trampoline, let's hop on to it. 'Tramploine of recursion' is given by Kyle Simpson. A trampoline is nothing but a wrapper around our recursive function. In recursion, we call a function from within a function. In a trampolined recursion, we call a function that in turn returns a function ( not a function call & therefore completing the current function execution) and this returned function again calls our recursive function. That is a bit confusing, I know but read it again I am sure you will get it. Here's how the trampoline wrapper looks like, { { result = f(...args); ( result === ) {
      result = result();
    } result;
  };
} ( ) function trampoline f return ( ) function enclose ...args let while typeof "function" return The above trampoline function, takes a function as an argument and returns a function called , you can call it anything you want. enclose In order to use the above wrapper, we need to modify our recursive function a little bit. { { (test > ) test; increment(++test);
  } { .log( , test);
  }
} ( ) function increment test try if 1000000000 return return => () catch console "test===>" Did you notice the difference, we modified our tail call by returning an anonymous function instead. So that its not a function call anymore, but it returns a function that calls our recursive function which is in this case increment Now, if we pass in the above function to our trampoline wrapper, our code will look like this. trampolinedIncrement = trampoline( { { (test > ) test; increment(++test);
  } { .log( , test);
  }
}); .log(trampolinedIncrement( )); const ( ) function increment test try if 1000000000 return return => () catch console "test===>" console 1 When you run the above code, there will be no range error, and you will get as output. The above code took around on a Macbook Air. 1000000001 20 sec But what just happened? Our code just got on a trampoline, LOL! Here is the whole code, { { result = f(...args); ( result === ) {
      result = result();
    } result;
  };
} trampolinedIncrement = trampoline( { { (test > ) test; increment(++test);
  } { .log( , test);
  }
}); .log(trampolinedIncrement( )); ( ) function trampoline f return ( ) function enclose ...args let while typeof "function" return const ( ) function increment test try if 1000000000 return return => () catch console "test===>" console 1 When we trampolined the function, we got the definition of function in with being the function. So now, when we call the function with initial arguments, it calls and the output of that execution is an anonymous function which is stored in the . Then we keep on calling function until it returns a function and at the end will return the result. increment enclose trampolinedIncrement f increment trampolinedIncrement f result result typeof If you are still confused just ask in the comments, I will clarify. You can reach out to me on twitter on @heypran Just to wrap it up, in a normal recursion the stack size keeps on increasing because the current function call has not finished its execution and yet it calls another function. This function again calls another function and this keeps on repeating. This leads to stack overflow. In a trampolined scenario, we are not calling the recursive function directly, instead we are finishing the current function call by returning a function, that in turn calls our recursive function. This makes our stack size always increase only by one and when it finishes it again reduces by one. This jumping between the functions is referred as . I find it pretty cool! trampoline Cheers! Have a Happy Day! @heypran

On Recursion and Trampolining

At the beginning of the year, when I started building , I evaluated some cool tech out there. Here’s the list of tech I think will change the world in ways we can’t even predict. Archbee 1. Swift Objective C was perceived as clunky/verbose by many, and hard to teach to younger developers. So Apple decided to brew their second programming language, Swift. They recruited Chris Lattner, notorious from his work on LLVM and conceived one of the most impressive languages ever. What many don’t know is that Swift is open source, and has a big and growing community behind it. They made Swift work on Linux, created Swift Package Manager and are making Swift a workable server-side language, all happening in a very short amount of time. Take a look at a SwiftUI intro from Twilio: So why should you invest your time in learning a bit of Swift? Borrows heavily from functional languages with features like: non-nullable types, immutable data structures, first-class functions, higher-order functions, sum types with exhaustive switch patterns, partial and pure functions, tail-call optimisations for recursion, extensions and many more; Swift is no Haskell, but goes a long way from classic OOP languages like Java and C#; Swift is compiled to LLVM bytecode, so no CPU cycles will ever be wasted; Has Automatic Reference Counting for memory management. Although it can’t compete with something like compile-time memory management in Rust, in my opinion, ARC is the second-best; SwiftUI is a great UI library by Apple — heavily influenced by React, it proves once again that the ideas behind React are great: top-down data flow, immutability and language level declarative views. SwiftUI is not open-source but it’s so cool that it deserved to be on the list; Growing server-side ecosystem — Vapor and Kitura both great for writing backend systems; a bit immature, but very workable with; XCode is a very mature, fast and editor that is a pleasure to work with.Swift playground makes it easy to learn and experiment because of its immediate feedback, no compile required. Swift’s future is bright because of the active and excited community; One of the highest paying jobs; 2. Kotlin A bit of the same story as Swift, Kotlin came to life as a modern less verbose Java alternative on the JVM. Surprisingly, this great language was created and is being developed by JetBrains, a company that makes code editors. Kotlin became popular through Android, when Google made it an official language for its OS, but is becoming a monster alternative for Java in the server-side world too, mainly because Spring Framework made it a priority to have it as first-class citizen. Quick intro from Kotlin’s project lead: So why should you invest your time in learning a bit of Kotlin? Kotlin is multi-platform, meaning you can compile it to JVM, LLVM (and WASM by association) and JavaScript, covering most use cases; Modern type system with non-nullable types, generics, comprehensions, and great influences by functional programming languages. Arrow is an excellent addition to its standard library, take a look here: ; https://arrow-kt.io/ Server-side Kotlin can benefit from one of the most mature server-side ecosystem built over more than two decades since Java/JVM was introduced; Coroutines make it a great programming language to build scalable asynchronous web APIs, but unfortunately, most libraries will block as they were designed for the old thread-per-request paradigm. One of the best IDEs out there — IntelliJ IDEA; React bindings for when you compile to JavaScript to build web apps. Compile to executable files like Rust or Go. 3. Kubernetes When Docker came around, many developers didn’t see the value. Dependency isolation seemingly was not enough for most to make the switch from bare VMs running in the cloud. After Google to open-sourced their internal project Borg, everybody started to see why containers and container orchestration are the way of the future for running systems in the cloud and on-premise. Quick video explanation of Kubernetes: So why should you invest your time in learning a bit of k8s? Declarative infrastructure means you’ll be done with error-prone manual configuring of your system. Yes, YAML is not the best, but solutions like Pulumi make it a lot more reasonable; Distributed systems are more resilient, and Kubernetes makes it a lot easier to build one; Almost Hands-free scaling by just running configuration changes to add nodes or scale containers; Automatic revival of dead/crashed containers, with zero downtime deployments; Readiness and liveness probes for containers; Small to no attack surface if you create your cluster in private networks, only exposing through Ingresses; Greater security than self-managed servers: most hosted k8s clusters will have great security defaults right out the box; Most cloud providers will provide you with a free k8s master, so no actual resources will be added to your cost; As long as you can package your services as Docker containers, everything will work 100% the same in development and in production, making the development process faster; 4. Elixir What a beauty of a dynamic functional language! Built on top of the rock-solid Erlang VM and benefitting from the ecosystem and stability, Elixir marks the spot as one of the crucial technologies developed in the 2010s. They said it best on their homepage so I’m just going to quote it: “The unavoidable truth about software running in production is that things will go wrong. Even more when we take network, file systems, and other third-party resources into account. To cope with failures, Elixir provides supervisors which describe how to restart parts of your system when things go awry, going back to a known initial state that is guaranteed to work: The combination of scalability, fault-tolerance, and event-driven programming via message passing makes Elixir an excellent choice for Reactive Programming and Architectures.” So why should you invest your time in learning a bit of Elixir? Functional language with immutability by default, first-class and higher-class functions, pattern matching, structs, sigils; Phoenix Framework is really great, taking some hints from Ruby On Rails in productivity but scales a lot better and easier on the computing resources; Already true, but in the 2020s non-realtime applications won’t be acceptable anymore for user experience. This means that any language/platform with a focus on realtime data sync and WebSockets will have the edge, and Erlang VM + Elixir does it best in my opinion; Read up on the story of how WhatsApp team productivity skyrocketed with very low computing resources here: ; https://www.wired.com/2015/09/whatsapp-serves-900-million-users-50-engineers/ 5. Elm Elm is a delight. A very simple programming language with guarantees like no other. Have you heard of the expression “Zero runtime exceptions”?. That comes from Elm. Its Haskell inspired type system allows it to do this, meaning you’ll sleep better at night. Elm is also very specific on what problem it solves — frontend development. In my opinion, this is a great choice by Evan Czaplicki acknowledging that “catch-all use-cases” languages won’t cut it anymore. So why should you invest your time in learning a bit of Elm? Rock-solid type system means you’ll refactor easily because the compiler will guide you; Zero runtime exceptions in practice; Built-in toolkit for building user interfaces called The Elm Architecture (TEA). TEA is so great it inspired lots of clones in many other languages; Compiler is top-notch: set the new standard for error messages in the industry, very fast, type inference works great; Great ecosystem with “Enforced Semantic Versioning” meaning your dependencies will always know if something is broken or not — at build-time; Best asset size in the industry — smaller than React and even Preact. As you can see Elm has constantly set a bunch of new standards in our industry. Def one of the top innovations of the 2010s. 6. Flutter Building native UIs is a very hard task. Add that you need to do it for 4–5 operating systems, and you’re in deep trouble. This is why Google started building Flutter, initially focusing on Android and iOS, and eventually adding the Web Platform and even macOS and Windows apps soon. Take a look at this video: So why should you invest your time in learning a bit of Flutter? Helps you build performant mobile apps; Great backing from Google, which apparently is trying to build another OS called Fuchsia based on Flutter UIs; Dart 1 is kind of boring and old-school, but Dart 2 is more functional programming oriented, and also very specific on solving UI problems best; Flutter’s hot reload helps you quickly and easily experiment, build UIs, add features, and fix bugs faster. Experience sub-second reload times, without losing state, on emulators, simulators, and hardware for iOS and Android. Delight your users with Flutter’s built-in beautiful Material Design and Cupertino (iOS-flavor) widgets, rich motion APIs, smooth natural scrolling, and platform awareness. Dart + Flutter has great IDE support in Intellij IDEA and Visual Studio Code; 7. Redis From their homepage: “Redis is an open-source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. It supports data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes with radius queries and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.” So why should you invest your time in learning a bit of Redis? Redis is insanely fast; Redis is a very versatile toolkit; You can use it as a cache store, database and message broker; You can use it as an in-memory data structure store, which is the most important aspect of Redis in my opinion. In the era of microservices, if you need some shared state that you need to modify concurrently, you basically have no choice but to use Redis; Most cloud providers will provide a managed Redis service for you; Bindings to most programming languages; Very small API surface, and very intuitive; Very scalable through high availability and automatic partitioning. 8. TensorFlow TensorFlow is Google’s machine learning toolkit. From their homepage: “TensorFlow is an end-to-end open-source platform for machine learning. It has a comprehensive, flexible ecosystem of tools, libraries and community resources that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML powered applications.” TensorFlow’s core strength is performance. It was built for taking models from research to production at massive scale and it delivers. Persevere and you’d be able to join the ranks of ML practitioners who use it for incredible things, like finding new planets and pioneering medicine. The TensorFlow community put in a lot of elbow grease to make the initial magic happen, and then more effort again to polish the best gems while scraping out less fortunate designs. The plan was never to force you to use a rough draft forever, but perhaps you habituated so well to the discomfort that you didn’t realize it was temporary. So why should you invest your time in learning a bit of TensorFlow? High-performance machine learning library Bindings to high-level languages like Python, JavaScript and Swift; Can run on both CPU and GPU; Scalable horizontally; Many available trained models; Huge community, and backed by Google and a lot of big companies; Keras — the higher-level abstraction is now built into Tensorflow; Tensorflow 2.0 coming soon — “TensorFlow 2.0 focuses on simplicity and ease of use, with updates like eager execution, intuitive higher-level APIs, and flexible model building on any platform”. 9. Istio Many organizations migrated their existing monolithic workloads/systems to Kubernetes. But that is not where Kubernetes provides the most value, it’s in microservices architectures. But this new way of writing systems brings a new set of problems with it, like: observability, connecting, controlling and securing the microservices. This is where Google saw the opportunity to build Istio, a service mesh. If you are more on the DevOps side, you def need to take a look at Kubernetes and Istio. So why should you invest your time in learning a bit of Istio? Istio is very high performance, written on top of Envoy (C++); Helps you solve most of the problems that arise with microservice-based architectures; Side-car design pattern: most of the stuff every microservice needs to perform (logging, security, figuring out DNS, rate-limiting) will be moved out of the microservice into a “side-car”. This means less code (and error-prone) in each of your microservices; If you run on Google Cloud, you’ll be able to benefit greatly by their integration and ease of deployment. 10. The ELK “So, what is the ELK Stack? “ELK” is the acronym for three open source projects: Elasticsearch, Logstash, and Kibana. Elasticsearch is a search and analytics engine. Logstash is a server‑side data processing pipeline that ingests data from multiple sources simultaneously, transforms it, and then sends it to a “stash” like Elasticsearch. Kibana lets users visualize data with charts and graphs in Elasticsearch.” So why should you invest your time in learning a bit of ELK? Best in Class User Interface for Data Analysis; Data Visualization for the Amazing price of… Free; Extendable Source and Aggregation; Hosted by many cloud providers; Very versatile — works from ingesting logs, to text search, to filtering through huge datasets. Article originally published at https://archbee.io/blog/10-open-source-tech-you-should-take-a-look-at-before-2020

About Ten Open Source Technologies That Are Changing the World

Immutability? that is the question! Functional tends to scare people with the academic terms borrowed from Category Theory to describe interfaces known as . Programming “Algebraic Structures” Functional Paradigm was adopted through languages like Erlang, R and even the most recent ML, Haskell, OCaml, F # and Elixir. Already our beloved wasn’t designed to be a functional language. Fortunately, JavaScript is well-suited for the task, thanks to functions and proper provided in ES2015. Javascript first-class, high-order tail-call optimization The more abstract a concept is, the harder it is to understand. Interfaces are abstract in nature. The more abstract they are, the more powerful they become, because they allow us to solve a wider range of problems apparently unrelated to a surprisingly small set of patterns. The purpose of functional programming is to allow us to think less and write more descriptive codes. The good news is that you don’t need to turn the key and everything is working in your head. You can apply functional approaches as you learn. I’ve been slowly studying this paradigm, and every day I see new ways of solving problems and each refactoring makes the code much more enjoyable. Learning new programming paradigms is like learning a new instrument. After each note learned we increase our power of expression. In my day-to-day work I use Functional Paradigm infrequently, but this foundation allows me to see problems in a different way and even to combine functional concepts with other paradigms such as Object Orientation. This has been a trend in the evolution of languages, in other other, we can unite the best of worlds. The example below in Typescript/Angular shows the union of functional concepts like map and Object Guidance concepts like the use of classes. Multiple paradigms help you apply different ways of thinking about solutions to problems because solutions vary across languages. Ultimately we will see that a stateless application is useless. But we always need to carefully select the points in the code where we allow the mutation to occur. Most of the internal parts of the code should strive to be immutable and therefore testable. The more mutations you can eliminate, the better. Why should we care about immutability? Chip makers are on the atomic limits of transistor miniaturization. As a result, clock rates have not increased since 2004. Multi-core is currently the preferred strategy for improving speed. Routines with shared mutable state cannot be distributed in parallel across multiple cores because they are not thread-safe. As a suggestion follows Robert Martin’s lecture about this subject. Just note: an “assignment statement” is totally benign a “reassignment statement” is problematic. When you reassign (mutate) a variable you are introducing state change to your application. To reproduce a complex bug you often need the sequence of computations that lead to the failure. When you mutate variables you are throwing away that sequence. How do we avoid mutations? Whenever you need to model a state change, you pass the previous value to a function that returns a new value. Don’t change the old value just return a new one. Manual Although JavaScript doesn’t support immutable objects, we can still write our code in a way that avoids most mutations. Don’t change objects in functions Write functions that return changed copies instead of changing the properties of the specified object. Don’t exchange objects after construction. Objects are references, if we avoid changing their properties we avoid situations of unclear states. Also our finished code will be simpler to understand and easier to test. It seems a lot of tedious work to avoid mutation with the above examples but the fact JavaScript doesn’t have built-in support for immutable objects makes this very difficult for us. Time to get help! Immutable.js Facebook’s is a small library that helps us keep our state immutable. There are other libraries that work in a similar way ( , , ), but for this article we limit ourselves to Immutable.js. Immutable.js Mori seamless-immutable acient-oak Immutable.js provides many persistent immutable data structures including: _List, Stack, Map, OrderedMap, Set, OrderedSet and Record_ Or in form of code: Although we lose direct access to object properties, we can now focus on our goals, rather than fighting against mutations. ESLint Immutable There is also the plugin to disable all mutations in JavaScript. The readme mentions a lot of React/Redux, but you can safely use the plugin without both. eslint-plugin-immutable The plugin adds three rules: use const instead of let. no-let: forbids this, and therefore ES6 classes. no-this: prohibits assigning a value to the result of member expressions. no-mutation: When do we use it? Concurrency This is the main reason why immutability makes sense. To be , you don’t need to lock anything that is not changed. In Javascript there is no real concurrency. Instead, we have an event loop. So forget it. thread safe To avoid side effects. Changing object properties is considered a mutation, in other words, a side effect by definition. We all learn that we should avoid at all costs. We don’t need to examine the implementation of a function if it has no side effects. Our code gets easier to reason about and will be more predictable and more testable. side effects With functional programming There are times when you need to stop and think if you are dealing with a value or a reference. Immutable objects are always values. This is one of the fundamental principles of functional programming. If I pass the value to a function, I can promise that it stays the same forever. When don’t we use it? Often changing properties If you have objects that change very often, it isn’t a good idea to create a new instance for each change. This is especially true for games and simulations where this happens several times per second. I’m not saying that you can’t use immutability in games, but it is easier to fall into performance problems than in mutable objects. Huge data structures If you have a huge data tree stored as an immutable container, I recommend checking your memory consumption. Of course, garbage collection kills all old objects, but copying large objects still has its price (Most frameworks on the market already handle this kind of problem very well). Conclusion In general, it is a pretty reasonable language design choice to take into consideration are the immutable types of data, since there are some problems that are simply not well modeled when everything is immutable. In most situations the advantages of immutable types vastly outweigh the disadvantages and they are better than the alternatives and lead to better code and faster executables overall. As said at the beginning of the post, we don’t have to turn on a key to changing paradigms completely, we can start implementing immutable types gradually entering into more complex and useful patterns according to the need of our application. To end this post I leave ’s tweet as a reflection. @jamesiry Functional programmer: (noun) One who names variables “x”, names functions “f”, and names code patterns “zygohistomorphic prepromorphism” — James Iry To be, or not to be a “Functional Programmer”, that is the question 😂 References and Related Contents _fantasy-land — Specification for interoperability of common algebraic structures in JavaScript_github.com fantasyland/fantasy-land _js-real-world-functional-programming — Tips and guidelines for real world functional code-bases in JS_github.com haskellcamargo/js-real-world-functional-programming _Functional-Light-JS — Pragmatic, balanced FP in JavaScript. @FLJSBook on twitter._github.com getify/Functional-Light-JS _This is the second chapter in a series of articles on practical Functional Programming paradigms. If you haven’t read…_hackernoon.com Functional programming paradigms in modern JavaScript: Immutability _On this podcast, we talk with Andrea Magnorsky, who is a tech lead at Goodlord on their engineering squads; she has a…_www.infoq.com Andrea Magnorsky on Paradigm Shifts and the Adoption of Programming Languages _functionaljava — Functional programming in Java_github.com functionaljava/functionaljava _I’ve been asked at least once “How can I get better at programming in a compositional style, with functions?” This…_www.mojotech.com Functional Programming Pro Tips

Tailcall

tailcall.in

-- employees

Since n.d.

COMPANY RANKING

TAILCALL

EVERGREEN INDEX #10354

Tailcall WIKI

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

Tailcall

tailcall.in

-- employees

Since n.d.

COMPANY RANKING

TAILCALL

EVERGREEN INDEX #10354

RELATED COMPANIESRANK

STORIES ABOUT TAILCALL

Tailcall WIKI

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