Bind

bind

The keyword in JavaScript is one of the most muddling concepts because its value depends on where it is used. Often it tricks developers and sometimes it's the culprit behind surreal results. this Let's discuss this keyword with simple and easy-to-understand examples before actually delving into the , , and methods as keyword is the main reason for having those methods. this call apply bind this What is this in JavaScript? The keyword in JavaScript refers to the object that the function is a property of and will depend on the object that is invoking the function. this this To get a quick idea of have a look at the code snippet below. this const myObj = {
  name: 'John',
  age: 25,
  place: 'London',
  myFunction: function() {
    return this;
  }
};

myObj.myFunction(); 
// {name: "John", age: 25, place: "London", myFunction: ƒ()} In the above code snippet, you can see that when method is called it returns the value of , which is nothing but the itself. If you recollect the definition for in the previous paragraph, it says refers to the object that the function is a property of, so here is a property of , which means is referring to that myObj object. myFunction this myObj this this myFunction myObj this A simple trick is whatever precedes before .(dot) is the object referenced by the keyword. So before .(dot) in is , which is the value of . this myObj.myFunction() myObj this Let's take another example to understand this. function myFunction() {
  return this;
}

myFunction(); // window or undefined(in case of 'strict mode') In the above code we are returning from the , so when is called what we see or get is the value of . this myFunction myFunction this Again if we recollect our definition of , it refers to the object which the function is a property of. Here our function is a property of global object nothing but the object in the browser, so which means when we call the value of is going to be the object. this myFunction window myFunction this window If we go by our trick of .(dot) preceding the function, here there's no dot but every function is a method in the object, so it translates to so here, the keyword refers to the object. window window.myFunction() this window In order to avoid functions getting attached to the window object, we mode so as a result window will be in such cases. use strict undefined So keep in mind our definition as we're going to use that for understanding , and methods. call apply bind The this keyword in JavaScript refers to the object that the function is a property of and this will depend on the object that is invoking the function. Understanding call, apply, bind in JavaScript Let's consider an object with a property and a method . person name details const person = {
  name: 'John',
  details: function(age, place) {
    return `${this.name} ${age} years old, lives in ${place}`
  }
}

person.details(25, 'London'); //John 25 years old, lives in London When we call the method on object with the arguments, we knew that refers to the object because is a property of the object and so would be and so the result that gets returned will be as shown in the comments. details person this person details person this.name John This part is going to be clear as we knew what means in the object. this person Let's consider a scenario where we wanted to use the method but with different arguments. details As per the method we can pass in different age and place values but how about the name, as it is connected with the keyword? This is where we are going to use those special methods , and . Let's dive into those. details this call apply bind Using Method call Now we want to associate a different object other than to keyword of method. So to do that we're going to use the method as shown below in the code snippet. person this details call person.details.call({ name: 'James'}, 30, 'Tokyo'); 
// James 30 years old, lives in Tokyo A method takes a new object that we want this to refer to followed by the arguments to the function(nothing but the method) and it gets called referencing to the new object passed as the first argument. Voila! That's what a call method is. call details this Using Method apply Guess what, method is just the same as the method, that is, it takes a new object as the first argument to reference the keyword and is followed by an array of arguments. So it means you can simply pass the arguments to the function in the form of an array instead of passing individually. Have a look at the code below so it becomes clear for you. apply call this details person.details.apply({ name: 'James'}, [30, 'Tokyo']); 
// James 30 years old, lives in Tokyo So and methods are used to reference a new object to keyword on methods. call apply this And then what is for? Guess! bind Using Method bind When and methods are applied they are called(invoked) directly referencing the new object passed but in order to get a new function reference that can be used to call at later times, the method is used. Have a look at the code snippet below to get more clarity. call apply bind const personDetails = person.details.bind({name: 'William'}, 40, 'Rome');

personDetails(); 
// William 40 years old, lives in Rome So using the method returns a new function reference which can be called at a later time and that is all about the bind method. bind So putting all the three methods together. const person = {
  name: 'John',
  details: function(age, place) {
    return `${this.name} ${age} years old, lives in ${place}`
  }
}

person.details(25, 'London');  //John 25 years old, lives in London

// Using call
person.details.call({ name: 'James'}, 30, 'Tokyo'); // James 30 years old, lives in Tokyo

// Using apply
person.details.apply({ name: 'James'}, [30, 'Tokyo']); // James 30 years old, lives in Tokyo

// Using bind
const personDetails = person.details.bind({name: 'William'}, 40, 'Rome');
personDetails();  // William 40 years old, lives in Rome So in short CAB(call, apply, bind in JavaScript) are used to reference a new owner object to the keyword. Hope this article has demystified the call, apply and bind methods in JS. this Did we miss anything here? Yes, the value will be different when we use an arrow function. See you in the next article. this If you liked this article please give a follow & share. More such interesting articles are on the way. First Published here

A Quick Guide to CAB(Call, Apply, Bind) in JavaScript

Javascript binding is done using the method. With the help of the bind method, we can make one common function and bind different objects, so that the function gives different results when it's needed. Otherwise, it gives the same result or gives an error while the code is executing. Bind() In short, when a function or method is invoked, the method allows us to easily set which object will be bound by keyword. bind() this info= { : , : { .write( .name);} }
info.printFunc(); var name "XYZ" printFunc ( ) function document this // XYZ In the above example, there is no problem accessing the name, keyword bind the variable to the function. This is called . this name default binding This keyword will here point to object i.e info object. info = { : , : { .write( ); .write( .name);
  }
} printFunc2= info.printFunc;
printFunc2(); var name "XYZ" printFunc ( ) function document this // window object or undefined(strict mode). document this var In the above example, we are storing a reference of info.printFunc to printFunc2 variable. After that, we are calling it without an object reference, so this will now refer to the window (global) object or undefined (in strict mode). Hence, the binding of is lost, so no output is produced. this So basically, the method is used so that binding of is not lost. By using method we can set the context of to a particular object. Bind() this bind() this or in simple terms we can bind this How to use bind? 1. The bind() method creates a new function, when invoked, has the this sets to the provided value. See example below:- car1 = { : , : ,
} car2 = { : , : ,
} { .write( .name + + .color + );
 }
infoFunc.bind(car1)(); infoFunc.bind(car2)(); var name "swift" color "red" var name "alto" color "blue" ( ) function infoFunc document this " " this "<br/>" // swift red // alto blue There is one common function infoFunc() which is invoked 2times with different objects so that different results are produced. first binds to car1 object and then to car2 object. This 2. Function borrowing which means the bind() allows an object to borrow a method from another object without making a copy of that method. runner = { : , : { .write( .name + + speed + );
    }
}; flyer = { : , : { .write( .name + + speed + );
    }
}; run = runner.run.bind(flyer, );
run(); let name 'Runner' run ( ) function speed document this ' runs at ' ' mph.' let name 'Flyer' fly ( ) function speed document this ' flies at ' ' mph.' let 20 //Flyer runs at 20 mph. The flyer object is able to run, using the bind() method. The method creates the run() function with the this sets to the flyer object. How Binding came into existence? To set the this keyword independent of how the function is called, we use call, bind, and apply methods. These methods allow us to write a function once and invoke it in a different context. They all attach into a function (or object) and the difference is in the function invocation. In other words, they allow us to specify the value of this which will be used while the function is being executed. They also take any parameters to be passed to the original function when it is invoked. this

The Binding Concept in Javascript

var obj = new CallableObject(); obj(args); A callable object is a data structure that behaves as both an object and a function. You can access and assign properties , call methods , but also call the object directly , as if it were a function. obj.bar obj.foo() obj() The direct call is like calling a method of which has access to the object’s properties through its . obj this context If you have experience with Python you’ll recognize this, there is a builtin Python protocol using the class method. Any method assigned to can be accessed as or as . __call__ __call__ obj.__call__() obj() Callable Objects can also be thought of as stateful functions. Functions are inherently single instance, stateless procedures. Callable Objects are instantiated, stateful procedures. In JavaScript almost everything is an object, including functions, so surely we can do this, but how? It’s not built in to the language like Python, but there are several ways to make it work. The Challenge Taking inspiration from Python, we want to create a Class / constructor that we can use to create callable objects that redirect their calls to a method named . We want this redirect so that we can inherit from our Class and easily override and extend the method with new functionality, without having to worry about the inner workings of the callable object. _call _call To do this, we’re going to need to inherit from the constructor, which inherits from , and allows us to create both an object and a dynamic function. Function Object Our main hurdle is giving a function object a reference to itself. In order to have a reference to the method, the function part of our function object, generated by our Callable class / constructor, must have a reference to itself. _call The Solutions We want to create an extensible class that  maintains proper and correct inheritance in JavaScript, and allows us to call the objects it constructs as functions, with a reference to themselves, redirecting those calls to an overridable method . Callable _call The Bind Way { () { ( , ) ._bound = .bind( ) ._bound
  }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor super '...args' 'return this._bound._call(...args)' // Or without the spread/rest operator: // super('return this._bound._call.apply(this._bound, arguments)') this this this return this console this Try it out on repl.it Because we’re inheriting from we can create dynamic functions from strings, using in our constructor. So the string we pass to will be the body of our function. We want that function to be able to access its own object and call a method , passing on its arguments. We do this using . Function super super _call bind The bind method will allow us to set the context of a function to whatever we want, by wrapping that function in a transparent bound function. So we bind the function to itself with . this this.bind(this) Now our callable object has a reference to itself, except the object we return from our constructor, returned by , is a wrapped version of our original object. So all our properties will be attached to that, new, wrapped function object, and our function has a reference to the old  object passed to . this.bind bind The easy solution to this is to attach a reference to the new wrapped object on the old object as . And the body of our function, in the string passed to , simply calls using the reference. _bound super _call this._bound Pros Doesn’t rely on deprecated or modern features. No need to modify prototypes. Cons Requires wrapping the function object in a bound function. The Callee Way { () { ( ) }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor super 'return arguments.callee._call.apply(arguments.callee, arguments)' // We can't use the rest operator because of the strict mode rules. // But we can use the spread operator instead of apply: // super('return arguments.callee._call(...arguments)') console this Try it out on repl.it Again we use the call to create a dynamic function, but his time we get our reference to the function itself by taking advantage of another implicit variable inside a function, the object. super arguments The arguments object has a property that is a reference to the called function. We use this reference as the first argument to which binds the functions context to itself. arguments.callee apply this So inside the function body, the string passed to super, we only need to call the method on . _call arguments.callee Pros Very simple. No need to modify prototypes. Cons and are unavailable in ‘strict mode’, see for more. arguments arguments.callee MDN Modern code should avoid for the / operator. arguments spread rest The Closure & Prototype Way { () { closure = { closure._call(...args) } .setPrototypeOf(closure, .target.prototype)
  }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor var ( ) function ...args return // Or without the spread/rest operator: // var closure = function() { //   return closure._call.apply(closure, arguments) // } return Object new console this Try it out on repl.it Here instead of creating a dynamic function with , we discard the function object created by the constructor ( the object ), and replace it with a , by returning it instead of from the . super this closure this constructor The closure is also a function object, and can reference itself in its body through the closed over variable. We use the reference to redirect calls to its method . closure closure _call But we’ve broken the prototype chain by replacing with , so we reattach the prototype of the constructor to using and (which is a reference to the constructor) to get the prototype. this closure closure Object.setPrototypeOf new.target You can use instead of , but then you must first call to create the object, which is wasteful. this.constructor.prototype new.target.prototype super this Pros Requires no wrapping of the returned object with a or . Proxy bind Cons Requires modifying prototypes. Modifying prototypes is slow and has other side effects, see . MDN The Proxy Way { () { () ( , { : target._call(...args)
    })
  }
  
  _call(...args) { .log( , args)
  }
} 'use strict' class Callable extends Function constructor super return new Proxy this apply ( ) => target, thisArg, args console this Try it out on repl.it Using we can intercept calls to a function, using the trap, and redirect it to another function. The trap gives our callable a reference to itself as the argument. Proxy apply apply target So we create a Class that inherits from Function, , wrapping the callable objects created in a , trapping any calls made to those objects, and redirecting them to the method on the object itself, using the reference. Callable Proxy _call target Pros Simple, native way to intercept calls and redirect them. No need to modify prototypes. Cons Requires wrapping objects created by in a . Callable Proxy A small performance penalty for using handlers. Proxy What We Learned JavaScript is a remarkably flexible language, and you can bend it into many interesting shapes, like Callable Objects. There may well be use cases for Callable Objects, but in general I wouldn’t recommend using them, it’s not idiomatic JavaScript, and might be confusing or unclear to anyone else using your code. This was mostly just an interesting exercise. References: https://stackoverflow.com/questions/36871299/how-to-extend-function-with-es6-classes/40878674#40878674

Creating Callable Objects in JavaScript

Creación de objetos invocables en JavaScript

Author:
(1) Thierry Boy de la Tour, Univ. Grenoble Alpes, CNRS, Grenoble INP, LIG 38000 Grenoble, France. Table of Links Abstract and 1 Introduction 2 Basic Definitions and Notations 2.1 Sets 2.2 Sequences 2.3 Signatures and Algebras and 2.4 Categories 3 Monographs and their Morphisms 4 Limits and Colimits 5 Drawing Monographs 6 Graph Structures and Typed Monographs 7 Submonographs and Partial Morphisms 8 Algebraic Transformations of Monographs 9 Attributed Typed Monographs 10 Conclusion and References 8 Algebraic Transformations of Monographs Rule-based transformations of graphs are conceived as substitutions of subgraphs (image of a left hand side of a rule) by subgraphs (image of its right hand side). Substitutions are themselves designed as an operation of deletion (of nodes or edges) followed by an operation of addition. This last operation is conveniently represented as a pushout, especially when edges are added between existing nodes (otherwise a coproduct would be sufficient). The operation of deletion is however more difficult to represent in category theory, since there is no categorical notion of a complement. This is a central and active issue in the field of Algebraic Graph Transformation, and many definitions have been proposed, see [12, 13, 14, 15]. The most common and natural one, known as the double pushout method [16, 17, 18], assumes the operation of deletion as the inverse of the operation of addition. More precisely, in the following pushout diagram Note that D is finite whenever M is finite. This proves that this gluing condition is also valid in FMonogr, and it is obviously also the case in SMonogr, O-Monogr and O-SMonogr for every set O of ordinals. It therefore characterizes the existence of D, but by no means its unicity. One way of ensuring the unicity of D (up to isomorphism) is to assume that l is injective: this is a well-known consequence of Theorem 4.17 (see [8]). However, an analysis of the construction of D in the proof of Lemma 8.2 (sufficient condition) shows that we can always build D as a submonograph of M, hence we may as well assume that f is a canonical injection and avoid restrictions on l. We therefore adopt a restricted notion of double pushout transformation compared to the standard one. As noted in Example 7.6, pushout of partial morphisms have a potential of removing edges. Since such pushouts always exist, they can be used to define transformations that are not restricted by the gluing condition. This is the idea of the single pushout method, that was initiated in [19] and fully developed in [20, 3]. We therefore see that single pushouts implement a semantics where edges can be silently removed, but minimally so for a monograph to be obtained. This may remove edges in a cascade, a feature that does not appear on graphs. Note that item (1) of the gluing condition may also be breached when an edge is marked more than once for removal, in which case it is deleted, but also when an edge is marked both for removal and for preservation. Example 7.6 shows that in such cases the edge is also removed. All edges marked for removal are guaranteed to be deleted, and the other edges are preserved only if this does not conflict with deletions. This semantics of transformation rules is thus dual to the previous one, and should be more appealing to the daring (or lazy) programmer. This paper is available on arxiv under CC BY 4.0 DEED license. Author: (1) Thierry Boy de la Tour, Univ. Grenoble Alpes, CNRS, Grenoble INP, LIG 38000 Grenoble, France. Author: Author: (1) Thierry Boy de la Tour, Univ. Grenoble Alpes, CNRS, Grenoble INP, LIG 38000 Grenoble, France. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Basic Definitions and Notations 2.1 Sets 2.1 Sets 2.2 Sequences 2.2 Sequences 2.3 Signatures and Algebras and 2.4 Categories 2.3 Signatures and Algebras and 2.4 Categories 3 Monographs and their Morphisms 3 Monographs and their Morphisms 4 Limits and Colimits 4 Limits and Colimits 5 Drawing Monographs 5 Drawing Monographs 6 Graph Structures and Typed Monographs 6 Graph Structures and Typed Monographs 7 Submonographs and Partial Morphisms 7 Submonographs and Partial Morphisms 8 Algebraic Transformations of Monographs 8 Algebraic Transformations of Monographs 9 Attributed Typed Monographs 9 Attributed Typed Monographs 10 Conclusion and References 10 Conclusion and References 8 Algebraic Transformations of Monographs Rule-based transformations of graphs are conceived as substitutions of subgraphs (image of a left hand side of a rule) by subgraphs (image of its right hand side). Substitutions are themselves designed as an operation of deletion (of nodes or edges) followed by an operation of addition. This last operation is conveniently represented as a pushout, especially when edges are added between existing nodes (otherwise a coproduct would be sufficient). The operation of deletion is however more difficult to represent in category theory, since there is no categorical notion of a complement. This is a central and active issue in the field of Algebraic Graph Transformation, and many definitions have been proposed, see [12, 13, 14, 15]. The most common and natural one, known as the double pushout method [16, 17, 18], assumes the operation of deletion as the inverse of the operation of addition. More precisely, in the following pushout diagram Note that D is finite whenever M is finite. This proves that this gluing condition is also valid in FMonogr , and it is obviously also the case in SMonogr, O- Monogr and O- SMonogr for every set O of ordinals. It therefore characterizes the existence of D, but by no means its unicity. FMonogr Monogr SMonogr One way of ensuring the unicity of D (up to isomorphism) is to assume that l is injective: this is a well-known consequence of Theorem 4.17 (see [8]). However, an analysis of the construction of D in the proof of Lemma 8.2 (sufficient condition) shows that we can always build D as a submonograph of M, hence we may as well assume that f is a canonical injection and avoid restrictions on l. We therefore adopt a restricted notion of double pushout transformation compared to the standard one. As noted in Example 7.6, pushout of partial morphisms have a potential of removing edges. Since such pushouts always exist, they can be used to define transformations that are not restricted by the gluing condition. This is the idea of the single pushout method, that was initiated in [19] and fully developed in [20, 3]. We therefore see that single pushouts implement a semantics where edges can be silently removed, but minimally so for a monograph to be obtained. This may remove edges in a cascade, a feature that does not appear on graphs. Note that item (1) of the gluing condition may also be breached when an edge is marked more than once for removal, in which case it is deleted, but also when an edge is marked both for removal and for preservation. Example 7.6 shows that in such cases the edge is also removed. All edges marked for removal are guaranteed to be deleted, and the other edges are preserved only if this does not conflict with deletions. This semantics of transformation rules is thus dual to the previous one, and should be more appealing to the daring (or lazy) programmer. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Monographs, Their Morphisms, and the Rules That Bind Them

Bla Bla Bla.. Okay; hear me out..!! Hundreds of blogs and tutorials explain call, bind, and apply. Heck, even ChatGPT and Copilot can simplify them for you! So, why another post? Well, this one’s not for you—it’s my self-note as I revisit JavaScript fundamentals. Even after 8 years in front-end development, I sometimes mix up these methods. Turns out, the confusion often stems from how they’re grouped in interview questions. Let me break it down for you—this time, in a way that sticks. Can We Skip to the Good Part? Why is it always call, bind, and apply in interviews? Functionally, call, and apply are closer—they invoke the function immediately—while bind returns a new function. That’s why I’ve grouped them this way in the title. Let's look at their usage to understand it better. What Is Common Among Call, Bind & Apply? call, bind, and apply are methods available on functions that allow you to explicitly set the value of this and pass arguments to the function. What Is the Difference Between Call, Bind & Apply? While Call and Apply Immediately invoke the function, the Bind method does not immediately invoke the function. instead, it returns a new function with this set to a specified value, and this returned function can be invoked/executed later. What Is the Difference Between Call and Apply Then? While both Call and Apply immediately invoke the function with the custom this, it’s how they take the additional argument that differentiates them. While Call takes the individual arguments, Apply takes an array of arguments. Examples Let’s look at the example below to understand the use of call, apply, and bind. function Greetings(greeting,punctuation){
    return `${greeting} ${this.name} ${punctuation}`
}

var person = {
    name : "Nandan"
}

// Call: Immediately invokes the function with individual arguments
console.log(Greetings.call(person,"Hello","!")); // Output : Hello Nandan !

// Apply: Immediately invokes the function, but takes arguments as an array
console.log(Greetings.apply(person,["Hello","!"])); // Output : Hello Nandan !

// Bind: Returns a new function with `this` bound to the specified value
let greet = Greetings.bind(person,"Hello","!");
console.log(greet()); // Output : Hello Nandan !

//Note:
console.log(Greetings.bind(person,"Hello","!")); // Output : It will return a function Some Additional Examples • Using call:Borrowing methods from another object: let person1 = { name: "Nandan" };
let person2 = { name: "Kumar" };

function introduce() {
    console.log(`Hi, my name is ${this.name}`);
}

introduce.call(person1); // Hi, my name is Nandan
introduce.call(person2); // Hi, my name is Kumar • Using apply: Finding the max value in an array: let numbers = [1, 2, 3, 4, 5];
console.log(Math.max.apply(null, numbers)); // 5 • Using bind: Event handling with custom this: let button = document.getElementById("myButton");
let user = {
    name: "Nandan",
    greet() {
        console.log(`Hello, ${this.name}`);
    }
};

button.addEventListener("click", user.greet.bind(user)); Additionally, I hope this table will help you understand it better. Feature

Execution

Arguments

Use Case



call

Executes the function immediately

Passed individually

When you know arguments at call time



apply

Executes the function immediately

Passed as an array

When arguments are in an array



bind

Returns a new function (does not execute)

Optionally pre-filled for the new function

When you need a reusable or pre-configured function That’s all, folks! I hope you found this short note on Call, Apply & Bind helpful. If you enjoyed this, check out more articles on my website, nandan.dev Feel free to comment, email me at connect@nandan.dev, or connect with me on Twitter, Instagram, or GitHub. Don’t forget to subscribe to my newsletter for regular updates on JavaScript topics! Twitter | Instagram | Github | Website Bla Bla Bla.. Okay; hear me out..!! Hundreds of blogs and tutorials explain call, bind, and apply. Heck, even ChatGPT and Copilot can simplify them for you! So, why another post? Well, this one’s not for you —it’s my self-note as I revisit JavaScript fundamentals. you Even after 8 years in front-end development, I sometimes mix up these methods. Turns out, the confusion often stems from how they’re grouped in interview questions. Let me break it down for you—this time, in a way that sticks. Can We Skip to the Good Part? Why is it always call, bind, and apply in interviews? Functionally, call, and apply are closer—they invoke the function immediately—while bind returns a new function. That’s why I’ve grouped them this way in the title. Let's look at their usage to understand it better. What Is Common Among Call, Bind & Apply? call , bind , and apply are methods available on functions that allow you to explicitly set the value of this and pass arguments to the function. call bind apply this What Is the Difference Between Call, Bind & Apply? While Call and Apply Immediately invoke the function, the Bind method does not immediately invoke the function. instead, it returns a new function with this set to a specified value, and this returned function can be invoked/executed later. this What Is the Difference Between Call and Apply Then? While both Call and Apply immediately invoke the function with the custom this, it’s how they take the additional argument that differentiates them. While Call takes the individual arguments, Apply takes an array of arguments. Examples Let’s look at the example below to understand the use of call, apply, and bind. function Greetings(greeting,punctuation){
    return `${greeting} ${this.name} ${punctuation}`
}

var person = {
    name : "Nandan"
}

// Call: Immediately invokes the function with individual arguments
console.log(Greetings.call(person,"Hello","!")); // Output : Hello Nandan !

// Apply: Immediately invokes the function, but takes arguments as an array
console.log(Greetings.apply(person,["Hello","!"])); // Output : Hello Nandan !

// Bind: Returns a new function with `this` bound to the specified value
let greet = Greetings.bind(person,"Hello","!");
console.log(greet()); // Output : Hello Nandan !

//Note:
console.log(Greetings.bind(person,"Hello","!")); // Output : It will return a function function Greetings(greeting,punctuation){
    return `${greeting} ${this.name} ${punctuation}`
}

var person = {
    name : "Nandan"
}

// Call: Immediately invokes the function with individual arguments
console.log(Greetings.call(person,"Hello","!")); // Output : Hello Nandan !

// Apply: Immediately invokes the function, but takes arguments as an array
console.log(Greetings.apply(person,["Hello","!"])); // Output : Hello Nandan !

// Bind: Returns a new function with `this` bound to the specified value
let greet = Greetings.bind(person,"Hello","!");
console.log(greet()); // Output : Hello Nandan !

//Note:
console.log(Greetings.bind(person,"Hello","!")); // Output : It will return a function Some Additional Examples • Using call:Borrowing methods from another object: Using let person1 = { name: "Nandan" };
let person2 = { name: "Kumar" };

function introduce() {
    console.log(`Hi, my name is ${this.name}`);
}

introduce.call(person1); // Hi, my name is Nandan
introduce.call(person2); // Hi, my name is Kumar let person1 = { name: "Nandan" };
let person2 = { name: "Kumar" };

function introduce() {
    console.log(`Hi, my name is ${this.name}`);
}

introduce.call(person1); // Hi, my name is Nandan
introduce.call(person2); // Hi, my name is Kumar • Using apply: Finding the max value in an array: Using let numbers = [1, 2, 3, 4, 5];
console.log(Math.max.apply(null, numbers)); // 5 let numbers = [1, 2, 3, 4, 5];
console.log(Math.max.apply(null, numbers)); // 5 • Using bind: Event handling with custom this: Using let button = document.getElementById("myButton");
let user = {
    name: "Nandan",
    greet() {
        console.log(`Hello, ${this.name}`);
    }
};

button.addEventListener("click", user.greet.bind(user)); let button = document.getElementById("myButton");
let user = {
    name: "Nandan",
    greet() {
        console.log(`Hello, ${this.name}`);
    }
};

button.addEventListener("click", user.greet.bind(user)); Additionally, I hope this table will help you understand it better. Feature

Execution

Arguments

Use Case



call

Executes the function immediately

Passed individually

When you know arguments at call time



apply

Executes the function immediately

Passed as an array

When arguments are in an array



bind

Returns a new function (does not execute)

Optionally pre-filled for the new function

When you need a reusable or pre-configured function Feature

Execution

Arguments

Use Case call

Executes the function immediately

Passed individually

When you know arguments at call time apply

Executes the function immediately

Passed as an array

When arguments are in an array bind

Returns a new function (does not execute)

Optionally pre-filled for the new function

When you need a reusable or pre-configured function Feature Execution Arguments Use Case Feature Feature Feature Execution Execution Execution Arguments Arguments Arguments Use Case Use Case Use Case call Executes the function immediately Passed individually When you know arguments at call time call call call Executes the function immediately Executes the function immediately Passed individually Passed individually When you know arguments at call time When you know arguments at call time apply Executes the function immediately Passed as an array When arguments are in an array apply apply apply Executes the function immediately Executes the function immediately Passed as an array Passed as an array When arguments are in an array When arguments are in an array bind Returns a new function (does not execute) Optionally pre-filled for the new function When you need a reusable or pre-configured function bind bind bind Returns a new function (does not execute) Returns a new function (does not execute) Optionally pre-filled for the new function Optionally pre-filled for the new function When you need a reusable or pre-configured function When you need a reusable or pre-configured function That’s all, folks! I hope you found this short note on Call, Apply & Bind helpful. If you enjoyed this, check out more articles on my website, nandan.dev nandan.dev nandan.dev Feel free to comment, email me at connect@nandan.dev , or connect with me on Twitter, Instagram, or GitHub. Don’t forget to subscribe to my newsletter for regular updates on JavaScript topics! connect@nandan.dev connect@nandan.dev Twitter | Instagram | Github | Website Twitter Twitter Instagram Instagram Github Github Website Website

Call, Apply, and Bind Simplified for JavaScript Developers

This paper is available on under CC 4.0 license. Arxiv Authors: (1) Md Masud Rana, Department of Mathematics, University of Kentucky; (2) Duc Duy Nguyen, Department of Mathematics, University of Kentucky & ducnguyen@uky.edu. Table of Links Abstract & Introduction Datasets and Results Methods Conclusion, Data and Software Availability, Competing interests, Acknowledgments & References 4 Conclusion The study of protein-protein interactions (PPIs) and the prediction of mutation-induced binding free energy changes are of great importance in understanding the molecular basis of biological processes. The application of geometric graph theory and atom-level graph coloring techniques provides a powerful framework for analyzing biomolecules and capturing their intricate relationships. By utilizing the concept of geometric subgraphs and constructing multi-scale weighted colored geometric subgraphs (MWCGS), we can effectively represent the structural and functional properties of PPIs. The site-specific MWCGS features allow us to extract meaningful patterns and characteristics, shedding light on the effects of mutations and the underlying molecular interactions. In this work, we developed a mutation-induced binding free energy change predictor, called GGL-PPI, by incorporating site-specific MWCGS features for PPIs and gradient-boosting trees. Our method demonstrates superior performance compared to existing methods. The model was validated on three datasets: AB-Bind S645, SKEMPI 1.0 S1131, and SKEMPI 2.0 S4169 and S8338, showcasing its robustness and effectiveness. Furthermore, GGL-PPI was evaluated on a blind test set, the Ssym dataset. To prevent data leakage between the test and training sets, the model was trained on a homology-reduced balanced training set Q3488. This approach ensures the reliability and fairness of the evaluation process. GGL-PPI exhibits the most unbiased and superior performance in predicting binding free energy changes for both direct and reverse mutations, outperforming other existing methods, particularly for reverse mutations. Overall, the results highlight the potential of the GGL-PPI approach in accurately predicting mutation-induced binding free energy changes in protein-protein interactions, providing valuable insights into the molecular mechanisms underlying protein-protein interactions and facilitating drug design and discovery efforts. 5 Data and Software Availability The source code is available at Github: https://github.com/NguyenLabUKY/GGL-Mutation. 6 Competing interests No competing interest is declared. 7 Acknowledgments This work is supported in part by funds from the National Science Foundation (NSF: # 2053284, # 2151802, and # 2245903), and the University of Kentucky Startup Fund. References [1] Dana Chuderland and Rony Seger. Protein-protein interactions in the regulation of the extracellular signal-regulated kinase. Mol. Biotechnol., 29:57–74, 2005. [2] Harry Jubb, Tom L Blundell, and David B Ascher. Flexibility and small pockets at protein–protein interfaces: new insights into druggability. Prog. Biophys. Mol., 119(1):2–9, 2015. [3] Mileidy W Gonzalez and Maricel G Kann. Chapter 4: Protein interactions and disease. PLoS Comput. Biol., 8(12):e1002819, 2012. [4] Cunliang Geng, Li C Xue, Jorge Roel-Touris, and Alexandre MJJ Bonvin. Finding the δδg spot: are predictors of binding affinity changes upon mutations in protein–protein interactions ready for it? Wiley Interdiscip. Rev. Comput. Mol. Sci., 9(5):e1410, 2019. [5] Rocco Moretti, Sarel J Fleishman, Rudi Agius, Mieczyslaw Torchala, Paul A Bates, Panagiotis L Kastritis, Joao PGLM Rodrigues, Mika¨el Trellet, Alexandre MJJ Bonvin, Meng Cui, et al. Community-wide evaluation of methods for predicting the effect of mutations on protein–protein interactions. Proteins: Struct. Funct. Genet., 81(11):1980–1987, 2013. [6] Jeffrey R Brender and Yang Zhang. Predicting the effect of mutations on protein-protein binding interactions through structure-based interface profiles. PLoS Comput. Biol., 11(10):e1004494, 2015. [7] Ning Zhang, Yuting Chen, Haoyu Lu, Feiyang Zhao, Roberto Vera Alvarez, Alexander Goncearenco, Anna R Panchenko, and Minghui Li. Mutabind2: predicting the impacts of single and multiple mutations on protein-protein interactions. Iscience, 23(3):100939, 2020. [8] Carlos HM Rodrigues, Yoochan Myung, Douglas EV Pires, and David B Ascher. mcsm-ppi2: predicting the effects of mutations on protein–protein interactions. Nucleic Acids Res., 47(W1):W338–W344, 2019. [9] Minghui Li, Marharyta Petukh, Emil Alexov, and Anna R Panchenko. Predicting the impact of missense mutations on protein–protein binding affinity. J. Chem. Theory Comput., 10(4):1770–1780, 2014. [10] Hafumi Nishi, Manoj Tyagi, Shaolei Teng, Benjamin A Shoemaker, Kosuke Hashimoto, Emil Alexov, Stefan Wuchty, and Anna R Panchenko. Cancer missense mutations alter binding properties of proteins and their interaction networks. PloS one, 8(6):e66273, 2013. [11] Mu Gao, Hongyi Zhou, and Jeffrey Skolnick. Insights into disease-associated mutations in the human proteome through protein structural analysis. Structure, 23(7):1362–1369, 2015. [12] Alessia David, Rozami Razali, Mark N Wass, and Michael JE Sternberg. Protein–protein interaction sites are hot spots for disease-associated nonsynonymous snps. Hum. Mutat., 33(2):359–363, 2012. [13] H Billur Engin, Jason F Kreisberg, and Hannah Carter. Structure-based analysis reveals cancer missense mutations target protein interaction interfaces. PLoS One, 11(4):e0152929, 2016. [14] Amelie Stein, Douglas M Fowler, Rasmus Hartmann-Petersen, and Kresten Lindorff-Larsen. Biophysical and mechanistic models for disease-causing protein variants. Trends Biochem. Sci., 44(7):575–588, 2019. [15] Stephanie Portelli, Jody E Phelan, David B Ascher, Taane G Clark, and Nicholas Furnham. Understanding molecular consequences of putative drug resistant mutations in mycobacterium tuberculosis. Sci. Rep., 8(1):1–12, 2018. [16] Sundeep Chaitanya Vedithi, Sony Malhotra, Madhusmita Das, Sheela Daniel, Nanda Kishore, Anuja George, Shantha Arumugam, Lakshmi Rajan, Mannam Ebenezer, David B Ascher, et al. Structural implications of mutations conferring rifampin resistance in mycobacterium leprae. Sci. Rep., 8(1):5016, 2018. [17] Vytautas Gapsys, Servaas Michielssens, Daniel Seeliger, and Bert L de Groot. Accurate and rigorous prediction of the changes in protein free energies in a large-scale mutation scan. Angew. Chem., Int. Ed., 55(26):7364–7368, 2016. [18] Elizabeth H Kellogg, Andrew Leaver-Fay, and David Baker. Role of conformational sampling in computing mutationinduced changes in protein structure and stability. Proteins: Structure, Function, and Bioinformatics, 79(3):830–838, 2011. [19] Brian J Bender, Alberto Cisneros III, Amanda M Duran, Jessica A Finn, Darwin Fu, Alyssa D Lokits, Benjamin K Mueller, Amandeep K Sangha, Marion F Sauer, Alexander M Sevy, et al. Protocols for molecular modeling with rosetta3 and rosettascripts. Biochemistry, 55(34):4748–4763, 2016. [20] Kurt S Thorn and Andrew A Bogan. Asedb: a database of alanine mutations and their effects on the free energy of binding in protein interactions. Bioinformatics, 17(3):284–285, 2001. [21] MD Shaji Kumar and M Michael Gromiha. Pint: protein–protein interactions thermodynamic database. Nucleic Acids Res., 34(suppl 1):D195–D198, 2006. [22] MD Shaji Kumar, K Abdulla Bava, M Michael Gromiha, Ponraj Prabakaran, Koji Kitajima, Hatsuho Uedaira, and Akinori Sarai. Protherm and pronit: thermodynamic databases for proteins and protein–nucleic acid interactions. Nucleic Acids Res., 34(suppl 1):D204–D206, 2006. [23] Iain H Moal and Juan Fern´andez-Recio. Skempi: a structural kinetic and energetic database of mutant protein interactions and its use in empirical models. Bioinformatics, 28(20):2600–2607, 2012. [24] Justina Jankauskait˙e, Brian Jim´enez-Garc´ıa, Justas Dapk¯unas, Juan Fern´andez-Recio, and Iain H Moal. Skempi 2.0: an updated benchmark of changes in protein–protein binding energy, kinetics and thermodynamics upon mutation. Bioinformatics, 35(3):462–469, 2019. [25] Sarah Sirin, James R Apgar, Eric M Bennett, and Amy E Keating. Ab-bind: antibody binding mutational database for computational affinity predictions. Protein Sci., 25(2):393–409, 2016. [26] Cunliang Geng, Anna Vangone, and Alexandre MJJ Bonvin. Exploring the interplay between experimental methods and the performance of predictors of binding affinity change upon mutations in protein complexes. Protein Eng. Des. Sel., 29(8):291–299, 2016. [27] Sherlyn Jemimah, K Yugandhar, and M Michael Gromiha. Proximate: a database of mutant protein–protein complex thermodynamics and kinetics. Bioinformatics, 33(17):2787–2788, 2017. [28] Douglas EV Pires, David B Ascher, and Tom L Blundell. mcsm: predicting the effects of mutations in proteins using graph-based signatures. Bioinformatics, 30(3):335–342, 2014. [29] Cunliang Geng, Anna Vangone, Gert E Folkers, Li C Xue, and Alexandre MJJ Bonvin. isee: Interface structure, evolution, and energy-based machine learning predictor of binding affinity changes upon mutations. Proteins: Structure, Function, and Bioinformatics, 87(2):110–119, 2019. [30] Sherlyn Jemimah, Masakazu Sekijima, and M Michael Gromiha. Proaffimuseq: sequence-based method to predict the binding free energy change of protein–protein complexes upon mutation using functional classification. Bioinformatics, 36(6):1725–1730, 2020. [31] Guangyu Zhou, Muhao Chen, Chelsea JT Ju, Zheng Wang, Jyun-Yu Jiang, and Wei Wang. Mutation effect estimation on protein–protein interactions using deep contextualized representation learning. NAR genom. bioinform., 2(2):lqaa015, 2020. [32] Alexey Strokach, Tian Yu Lu, and Philip M Kim. Elaspic2 (el2): combining contextualized language models and graph neural networks to predict effects of mutations. J. Mol. Biol., 433(11):166810, 2021. [33] Xianggen Liu, Yunan Luo, Pengyong Li, Sen Song, and Jian Peng. Deep geometric representations for modeling effects of mutations on protein-protein binding affinity. PLoS Comput. Biol., 17(8):e1009284, 2021. [34] Piero Fariselli, Pier Luigi Martelli, Castrense Savojardo, and Rita Casadio. Inps: predicting the impact of nonsynonymous variations on protein stability from sequence. Bioinformatics, 31(17):2816–2821, 2015. [35] Grant Thiltgen and Richard A Goldstein. Assessing predictors of changes in protein stability upon mutation using self-consistency. PLoS One, 7(10):e46084, 2012. [36] Fabrizio Pucci, Katrien V Bernaerts, Jean Marc Kwasigroch, and Marianne Rooman. Quantification of biases in predictions of protein stability changes upon mutations. Bioinformatics, 34(21):3659–3665, 2018. [37] Dinara R Usmanova, Natalya S Bogatyreva, Joan Ari˜no Bernad, Aleksandra A Eremina, Anastasiya A Gorshkova, German M Kanevskiy, Lyubov R Lonishin, Alexander V Meister, Alisa G Yakupova, Fyodor A Kondrashov, et al. Self-consistency test reveals systematic bias in programs for prediction change of stability upon mutation. Bioinformatics, 34(21):3653–3658, 2018. [38] Duc D Nguyen, Tian Xiao, Menglun Wang, and Guo-Wei Wei. Rigidity strengthening: A mechanism for protein– ligand binding. J. Chem. Inf. Model., 57(7):1715–1721, 2017. [39] Md Masud Rana and Duc Duy Nguyen. Geometric graph learning with extended atom-types features for proteinligand binding affinity prediction. Comput. Biol. Med., 164:107250, 2023. [40] Jian Jiang, Rui Wang, and Guo-Wei Wei. Ggl-tox: geometric graph learning for toxicity prediction. J. Chem. Inf. Model., 61(4):1691–1700, 2021. [41] Menglun Wang, Zixuan Cang, and Guo-Wei Wei. A topology-based network tree for the prediction of protein–protein binding affinity changes following mutation. Nat. Mach. Intell., 2(2):116–123, 2020. [42] Duan Chen, Zhan Chen, Changjun Chen, Weihua Geng, and Guo-Wei Wei. Mibpb: a software package for electrostatic analysis. J. Comput. Chem., 32(4):756–770, 2011. [43] Xiang Liu, Huitao Feng, Jie Wu, and Kelin Xia. Hom-complex-based machine learning (hcml) for the prediction of protein–protein binding affinity changes upon mutation. J. Chem. Inf. Model., 62(17):3961–3969, 2022. [44] Douglas EV Pires and David B Ascher. mcsm-ab: a web server for predicting antibody–antigen affinity changes upon mutation with graph-based signatures. Nucleic Acids Res., 44(W1):W469–W473, 2016. [45] Peng Xiong, Chengxin Zhang, Wei Zheng, and Yang Zhang. Bindprofx: assessing mutation-induced binding affinity change by protein interface profiles with pseudo-counts. J. Mol. Biol., 429(3):426–434, 2017. [46] Quanya Liu, Peng Chen, Bing Wang, Jun Zhang, and Jinyan Li. dbmpikt: a database of kinetic and thermodynamic mutant protein interactions. BMC bioinformatics, 19(1):1–7, 2018. [47] Bian Li, Yucheng T Yang, John A Capra, and Mark B Gerstein. Predicting changes in protein thermodynamic stability upon point mutation with deep 3d convolutional neural networks. PLoS Comp. Bio., 16(11):e1008291, 2020. [48] Lijun Quan, Qiang Lv, and Yang Zhang. Strum: structure-based prediction of protein stability changes upon single-point mutation. Bioinformatics, 32(19):2936–2946, 2016. [49] Leo Breiman. Random forests. Machine learning, 45:5–32, 2001. [50] Corinna Cortes and Vladimir Vapnik. Support-vector networks. Machine learning, 20:273–297, 1995. [51] Duc Duy Nguyen, Kaifu Gao, Menglun Wang, and Guo-Wei Wei. Mathdl: mathematical deep learning for d3r grand challenge 4. J. Comput. Aided. Mol. Des., 34(2):131–147, 2020. [52] Jerome H Friedman. Greedy function approximation: a gradient boosting machine. Annals of statistics, pages 1189–1232, 2001. This paper is available on under CC 4.0 license. Arxiv

PPIs and the Prediction of Mutation-Induced Binding Free Energy Changes: What It All Means

This paper is available on arxiv under CC 4.0 license. Authors: (1) Md Masud Rana, Department of Mathematics, University of Kentucky; (2) Duc Duy Nguyen, Department of Mathematics, University of Kentucky & ducnguyen@uky.edu. Table of Links Abstract & Introduction Datasets and Results Methods Conclusion, Data and Software Availability, Competing interests, Acknowledgments & References 3 Methods 3.1 Graph Theory and Atom-level Interactions in Biomolecules Graph theory provides a mathematical framework that is widely applied in the study of biomolecules such as proteins, DNA, and RNA. For a biomolecule, a graph G(V, E) is a collection of nodes V and edges E that can represent the connectivity and relationships between different atoms or residues within the molecule. A refinement to this representation is graph coloring, a technique that assigns unique labels to different atom types within the biomolecule. This enriched, colored graph encodes diverse atomic interactions, paving the way for a collective and coarse-grained description of the dataset. In this representation, atoms with assigned labels are organized into subgraphs, and the colored edges between them represent atom-specific interactions. The advantage of using subgraphs lies in their ability to focus on specific regions or components of the biomolecule. By isolating relevant subsets of atoms, subgraphs allow us to identify localized patterns, interactions, or clusters that might not be evident in the global graph representation. This targeted approach provides a more nuanced understanding of the structural and functional properties of biomolecules. To extract atom-level interaction information, we consider specific atom types based on their names in the PDB structure such as carbon alpha (CA), carbon beta (CB), carbon delta-1 (CD1), etc. These atom names serve as identifiers for specific positions within a protein’s three-dimensional structure. They help define the individual atoms that constitute amino acids, the building blocks of proteins, and provide crucial information about their spatial orientation and chemical properties. We consider a total of 37 distinct atom names that are frequently found in protein structures within the PDB database. These atom types are represented by the set A. To simplify the notation, we assume the set A is sorted in alphanumeric order, A = {C, CA, CB, · · · , N, ND1, ND2, · · · , O, OD1, · · · , SD, SG}, serves as a measure of the combined strength of interaction between chosen pairs of atom types, providing valuable insights into the molecular structure and properties. 3.2 Geometric Subgraph Representation of PPIs In the context of studying protein-protein interactions (PPIs) and predicting the effects of mutations on these interactions, it is important to focus on the relevant regions where the interactions occur. While protein-protein complexes can consist of a large number of atoms, the interactions between proteins primarily take place at specific regions known as interfaces. To streamline computational costs and concentrate on pertinent information, it is common practice to consider only the protein atoms near the binding sites. The binding site, in this context, refers to the region within a certain cutoff distance c from the chain where the mutation occurred. By defining the binding site in this way, we can narrow our focus to the specific area where the interaction and subsequent effects of the mutation are most pronounced. Furthermore, when analyzing the effects of mutations, it is crucial to incorporate geometric graph information from the mutation sites and their neighboring regions. The mutation site is defined as the region within a cutoff distance c from the mutated residue, allowing us to capture the structural changes resulting from the mutation. To construct a site-specific multiscale weighted colored geometric subgraph (MWCGS) representation for a PPI, both the wild-type and mutant-type proteins are considered. This leads to four sets of features for each PPI, corresponding to the two sites and the two types of proteins involved. Each set consists of 37 × 37 = 1369 MWCGS features, representing the interactions between the atom types involved in the PPI. These features encompass diverse chemical and biological properties, such as the presence of specific interatomic interactions involving oxygen and nitrogen atoms, the hydrophobic nature of certain regions, and the ability of atoms to undergo polarization, among other relevant molecular characteristics. By utilizing these site-specific MWCGS features, we can uncover valuable insights into the effects of mutations and the underlying molecular interactions, revealing significant information and characteristics embedded within the PPI system. 3.3 Geometric Graph Learning for PPIs Accurately predicting the changes in binding affinity induced by mutations in protein-protein complexes poses a significant challenge due to the complex nature of these systems. The interactions between proteins are highly intricate, and the effects of mutations can be subtle and context-dependent. Machine learning techniques offer a promising approach to tackle this problem by leveraging the power of data-driven models to capture complex patterns and relationships. Machine learning algorithms can aid in predicting mutation-induced binding affinity changes by learning from a set of training examples that consist of protein-protein complexes with known experimental binding affinities. These algorithms can analyze the features extracted from the complexes, such as geometric graph information, to identify relevant patterns and associations between the features and the binding affinities. By learning from these patterns, the algorithms can generalize and make predictions on unseen protein-protein complexes. There are several machine learning algorithms that can be used in combination with geometric graph features to predict binding affinity changes. These algorithms include random forests [49], support vector machines (SVM) [50], neural networks [51], and gradient boosting trees (GBT) [52]. Each algorithm has its strengths and weaknesses, and their performance can vary depending on the specific problem and dataset. Among these algorithms, gradient boosting trees (GBT) have gained significant popularity in recent years [39]. GBT is an ensemble method that builds a sequence of weak learners, typically decision trees, to correct the errors made by the previous learners. By combining these weak learners, GBT can effectively model complex relationships and improve prediction accuracy. One advantage of GBT is its robustness against overfitting, which is especially beneficial when dealing with a moderate number of features. Additionally, GBT models can provide interpretability, allowing us to gain insights into the factors contributing to the binding affinity changes. The implementation of the GBT algorithm in this study utilized the scikit-learn package (v 0.24.1). To optimize the performance of the GBT model for ensemble methods, specific hyperparameters were fine-tuned. The number of estimators was set to 40000, indicating the number of weak learners in the ensemble, while the learning rate was set to 0.001, determining the contribution of each weak learner to the final prediction. Given the large number of features involved in the prediction task, an efficient training process was achieved by limiting the maximum number of features considered to the square root of the descriptor length. This approach helped expedite the training process without compromising the overall performance of the GBT model. To ensure reliable performance evaluation, fifty runs were performed for each feature set, employing different random seeds. By averaging the results obtained from these runs, a more robust and representative performance measure was obtained. Despite the complexity of the prediction task and the involvement of numerous features, the selected parameter settings and multiple runs yielded satisfactory performance results. The GBT approach was chosen for its ability to effectively handle overfitting, exhibit good performance with moderately sized datasets, and provide interpretable models. These characteristics make GBT a suitable and reliable choice for this study, enabling accurate predictions of mutation-induced binding affinity changes in protein-protein complexes using the provided geometric graph features. This paper is available on under CC 4.0 license. Arxiv

The Methods We Used to Predict Mutation-Induced Binding Free Energy Changes

This paper is available on arxiv under CC 4.0 license. Authors: (1) Md Masud Rana, Department of Mathematics, University of Kentucky; (2) Duc Duy Nguyen, Department of Mathematics, University of Kentucky & ducnguyen@uky.edu. Table of Links Abstract & Introduction Datasets and Results Methods Conclusion, Data and Software Availability, Competing interests, Acknowledgments & References Abstract Protein-protein interactions (PPIs) are critical for various biological processes, and understanding their dynamics is essential for decoding molecular mechanisms and advancing fields such as cancer research and drug discovery. Mutations in PPIs can disrupt protein binding affinity and lead to functional changes and disease. Predicting the impact of mutations on binding affinity is valuable but experimentally challenging. Computational methods, including physics-based and machine learning-based approaches, have been developed to address this challenge. Machine learning-based methods, fueled by extensive PPI datasets such as Ab-Bind, PINT, SKEMPI, and others, have shown promise in predicting binding affinity changes. However, accurate predictions and generalization of these models across different datasets remain challenging. Geometric graph learning has emerged as a powerful approach, combining graph theory and machine learning, to capture structural features of biomolecules. We present GGL-PPI, a novel method that integrates geometric graph learning and machine learning to predict mutation-induced binding free energy changes. GGL-PPI leverages atom-level graph coloring and multi-scale weighted colored geometric subgraphs to extract informative features, demonstrating superior performance on three validation datasets, namely AB-Bind, SKEMPI 1.0, and SKEMPI 2.0 datasets. Evaluation on a blind test set highlights the unbiased predictions of GGLPPI for both direct and reverse mutations. The findings underscore the potential of GGL-PPI in accurately predicting binding free energy changes, contributing to our understanding of PPIs and aiding drug design efforts. — geometric graph, machine learning, protein-protein interactions, mutation, binding free energy changes Keywords 1 Introduction Protein-protein interactions (PPIs) play a fundamental role in numerous biological processes, including cell signaling, metabolic pathways, and immune responses [1;2;3]. Understanding PPIs and their dynamics is crucial for unraveling the intricate mechanisms underlying these processes and holds significant implications for various fields, such as cancer research, drug discovery, and personalized medicine [3;4]. The effects of mutations on PPIs have drawn substantial attention due to their potential impact on protein function and cellular behavior [5;6;7;8]. Missense mutations, which involve single amino acid substitutions, can disrupt the binding affinity between proteins and their partners [9;10]. Such alterations can lead to malfunctioning PPI networks, resulting in diseases, drug resistance, or other molecular disorders [11;12;13;14;15;16]. Therefore, accurate prediction of the impact of mutations on binding affinity holds significant importance in understanding disease mechanisms, facilitating therapeutic interventions, and enabling the design of innovative biopharmaceuticals. One of the key parameters used to assess the impact of mutations on PPIs is the binding free energy change (∆∆G). This thermodynamic parameter quantifies the difference in binding affinity between the wild-type and mutant protein complexes. Experimental determination of ∆∆G values, while accurate, can be tedious and costly. Consequently, there has been a surge in the development of computational methods to predict these energy changes. Broadly, these computation approaches fall into two main categories: physics-based and machine learning-based methods. The former, rooted in biophysical principles, delves into protein conformations and offers a rigorous approach [17;18;19]. However, they often demand significant computational resources and are not always scalable. On the other hand, machine learning-based methods have gained popularity due to their scalability and rapid prediction capabilities. Leveraging the wealth of data from PPI datasets such as ASEdb [20], PINT[21], ProTherm[22], SKEMPI [23;24], and others [25;26;27], machine learning models like mCSM28, BindProf 6 , iSEE29, MutaBind [7] , and several others [30;31;32;33] have been developed. These models have shown significant potential in predicting ∆∆Gs. However, challenges such as imbalanced training datasets, generalization across different PPI datasets, and the intricacy of capturing complex sequence-structure-function relationships remain obstacles [34;35;36;37]. This underscores the need for further research to enhance machine learning methodologies, ensuring accurate and efficient ∆∆G predictions. In recent years, geometric graph learning has emerged as a promising approach for analyzing complex biomolecular systems [38;39;40]. By representing proteins and their interactions as graphs, this methodology leverages the power of graph theory and machine learning to capture essential structural and spatial features of the biomolecular complexes. Specifically, the use of geometric subgraphs, which encode local interactions between atoms and residues, offers a rich representation. This not only sheds light on intricate molecular details but also provides insights into their impact on binding affinity [39]. This work presents a novel method, called GGL-PPI (Geometric Graph Learning for Protein-Protein Interactions), which combines the principles of geometric graph learning and machine learning to predict mutation-induced binding free energy changes. The workflow of GGL-PPI is depicted in Figure 1. Central to its methodology, GGL-PPI utilizes atom-level graph coloring and multi-scale weighted colored geometric subgraphs, enabling the extraction of informative features from protein structures and their interactions. These features serve as inputs to a gradient-boosting tree model, which facilitates precise and consistent predictions of binding free energy change upon mutations. When compared with existing models, GGL-PPI consistently outperforms state-of-the-art approaches across all datasets. Further addressing its generalizability, GGL-PPI was evaluated on a blind test set, Ssym dataset [36]. This evaluation was conducted using a homology-reduced balanced training set to avert data leakage, showcasing GGL-PPI’s robust performance and ability to produce unbiased predictions for both direct and reverse mutations. This paper is available on under CC 4.0 license. Arxiv

GGL-PPI: Geometric Graph Learning to Predict Mutation-Induced Binding Free Energy Changes

Memory management in Swift is based on automatic reference counting (ARC), which means that an object exists in memory as long as there is at least one strong reference to it. After that, ARC initiates the object deallocation mechanism, depending on the number of existing weak and unowned object references, the deallocation mechanism will be different. However, in addition to ARC, Swift also supports manual memory management. In this article, I will tell you what are the ways to work with memory that provide create/read/update/delete (CRUD) operations and much more. 1. Pointers Manual memory management can be implemented based on pointers. Pointer types vary depending on the need for unsafe memory access. The data type is: Pointers to a piece of memory without an explicit type. Returns the number of bytes. Usually contains in the name; Raw Pointers with an explicit type are specified during initialization as a generic parameter. contain in the name; Does not Raw Variability is distinguished by: Pointers to a memory area with the possibility of changing it. The name contains ; Mutable Pointers to a piece of memory without the possibility of changing it. The name contain ; does not Mutable The number of elements is distinguished by: Pointers that operate on an array of elements. The name contains ; Buffer Pointers that operate on a single element. The name contain ; does not Buffer In total, all possible combinations of pointers look like this: ; UnsafePointer<T> ; UnsafeMutablePointer<T> ; UnsafeBufferPointer<T> ; UnsafeMutableBufferPointer<T> ; UnsafeRawPointer ; UnsafeMutableRawPointer ; UnsafeRawBufferPointer ; UnsafeMutableRawBufferPointer 2. Creating objects Let’s consider the creation of objects in the example of UnsafePointer. var x: Int = 10
let unsafePointer = UnsafePointer<Int>(&x) Because is an immutable pointer, it can only be initialized by passing it an already initialized object directly. UnsafePointer You can get information about the memory area stored at a given pointer as follows: unsafePointer.pointee // printed 10 Consider the creation of objects in the example of . Unlike , this pointer can be initialized before information is written to the memory area. UnsafeMutablePointer UnsafePointer let size = MemoryLayout<Int>.size

let unsafeMutablePointer = UnsafeMutablePointer<Int>.allocate(capacity: size)
unsafeMutablePointer.pointee = 5 Now, through the pointee property, you can read and write the allocated memory area. Since we are working with the data type, the capacity area was chosen taking into account the required size of the . Int MemoryLayout You can deallocate a memory area and a pointer to it as follows: unsafeMutablePointer.deallocate()
unsafeMutablePointer.deinitialize(count: 1) Consider the creation of elements in the example of . Since this pointer is mutable and without explicit typing, it is enough to allocate a memory area for an object and then write data to it. In this case, all operations for this pointer occur byte by byte without a specific data type. UnsafeMutableRawPointer let unsafeMutableRawPointer = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment) // 6000006E44F0
unsafeMutableRawPointer.storeBytes(of: 32, as: Int.self) // 6000006E44F0
unsafeMutableRawPointer.load(as: Int.self) // printed 32 The method allows you to read a memory area with a given data type. The method allows you to write to the allocated memory area. At the same time, because of the lack of binding to a specific data type, you can easily put and read data with a completely different type into the allocated area: load storeBytes unsafeMutableRawPointer.initializeMemory(as: String.self, to: "123") // 6000006E44F0
unsafeMutableRawPointer.load(as: String.self) // printed “123”
unsafeMutableRawPointer.deallocate() The address was the number 32 with the data type , but we rewrote it to the string , hello Python. 6000006E44F0 Int "123" 3. Copying In addition to standard CRUD operations, pointers also support copying memory from one address to another. let size = MemoryLayout<Int>.size
let alignment = MemoryLayout<Int>.alignment

let unsafeMutableRawPointer1 = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
unsafeMutableRawPointer1.storeBytes(of: 32, as: Int.self) // 32

let unsafeMutableRawPointer2 = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
unsafeMutableRawPointer2.storeBytes(of: 40, as: Int.self) // 40

unsafeMutableRawPointer2.copyMemory(from: unsafeMutableRawPointer1, byteCount: size)
unsafeMutableRawPointer2.load(as: Int.self) // 32 Two pointers were created for different memory locations containing the numbers 32 and 40. Thanks to , we were able to copy information from one memory location to another. At the same time, the use of the method allows one-time copying, preserving the further independence of memory sections with different addresses. copyMemory copyMemory 4. Binding It is also possible to bind two different pointers: let unsafeMutableRawPointer3 = UnsafeMutableRawPointer.allocate(byteCount: size, alignment: alignment)
unsafeMutableRawPointer3.storeBytes(of: 32, as: Int.self)

let unsafeMutableRawPointer4 = unsafeMutableRawPointer3.bindMemory(to: Int.self, capacity: size)
unsafeMutableRawPointer4.pointee // 32

unsafeMutableRawPointer3.storeBytes(of: 40, as: Int.self)

unsafeMutableRawPointer4.pointee // 40 Thanks to , both pointers point to the same memory location and will catch all changes, regardless of which pointer they are written to. bindMemory 5. Collections To allocate an area of memory for an array using , the area for each element of the array will be allocated first: UnsafeMutableBufferPointer let array: [Int] = [5, 6, 7, 8, 9]
let elementPointer = UnsafeMutablePointer<Int>.allocate(capacity: array.count)
let arrayPointer = UnsafeMutableBufferPointer(start: elementPointer, count: array.count) Let’s fill in the previously allocated area. The offset between memory locations of different elements will be provided by the method. advanced(by: Int) for (index, value) in array.enumerated() {
    elementPointer.advanced(by: index).pointee = value
} In addition to writing, method also helps when reading a specific array element by ordinal index: the advanced(by: Int) elementPointer.advanced(by: 4).pointee // 9 supports to read and write array elements by ordinal index: UnsafeMutableBufferPointer subscript[index] arrayPointer[4] = 5
elementPointer.advanced(by: 4).pointee // 5
arrayPointer.deallocate() On this, the article comes to an end. I will talk about other types of manual memory management, such as , in the next article. Unmanaged objects Don’t hesitate to contact me on if you have any questions. Also, you can always . Twitter buy me a coffee Also published . here

Memory Management in Swift: Pointers, Object Creation, Copying, Binding, and Collections

Parsing logs with is a valuable technique for extracting essential information from large volumes of log data. By employing this method, one can effectively identify patterns, errors, and other key insights, ultimately streamlining log analysis and enhancing system performance. regex Prerequisites BindPlane OP & a BindPlane Agent (Custom OpenTelemetry Collector) A complex log file needing custom parsing Knowledge of Regex A selection of log samples that match all possible variations. (Optional) A good regex testing tool such as regex101.com Here is a link to regex101 for the examples from the blog: https://regex101.com/r/6hhy6K/4 Complex Log Data Samples In this post, we’ll examine log entries that resemble the examples provided below. By utilizing a script to write these entries to a file with the current timestamps, we can effectively work with real-time data. May 01 14:31:11 loggen-app10 test-system[712]: Mon May 01 14:31:11 UTC 2023|TEST_PROC|[result=Service Access Granted,service=https://portal.fakeuni.edu/uPortal/Login?...,requiredAttributes={}]|SERVICE_ACCESS_ENFORCEMENT_TRIGGERED|camillec1997|172.13.49.165|172.16.156.55

May 01 14:31:11 loggen-app10 test-system[712]: Mon May 01 14:31:11 UTC 2023|TEST_PROC|[result=Service Access Granted,service=https://portal.fakeuni.edu/uPortal/Login?...,requiredAttributes={}]|SERVICE_ACCESS_ENFORCEMENT_TRIGGERED|camillec1997|172.13.49.165|172.16.156.55

May 01 14:31:11 loggen-app10 test-system[712]: Mon May 01 14:31:11 UTC 2023|TEST_PROC|[event=success,timestamp=May 01 14:31:11 UTC 2023,source=RankedMultifactorAuthenticationProviderWebflowEventResolver]|AUTHENTICATION_EVENT_TRIGGERED|audit:unknown|172.25.178.6|172.16.156.55

May 01 14:31:11 loggen-app08 test-system[780]: Mon May 01 14:31:11 UTC 2023|TEST_PROC|Supplied credentials: [UsernamePasswordCredential(username=dawsonb, source=null, customFields={})]|AUTHENTICATION_SUCCESS|dawsonb|172.12.154.117|172.16.156.53

May 01 14:31:11 loggen-app10 test-system[712]: Mon May 01 14:31:11 UTC 2023|TEST_PROC|[event=success,timestamp=May 01 14:31:11 UTC 2023,source=RankedMultifactorAuthenticationProviderWebflowEventResolver]|AUTHENTICATION_EVENT_TRIGGERED|audit:unknown|172.25.178.6|172.16.156.55 Dissecting The Data We can now take the first log entry above, and start dissecting it into sections that we wish to parse out. First, we’ll notice that we have two timestamps: **May 01 14:31:11** loggen-app10 test-system[712]: **Mon May 01 14:31:11 UTC 2023**|TEST_PROC|[result=Service Access Granted,service=https://portal.fakeuni.edu/uPortal/Login?...,requiredAttributes={}]|SERVICE_ACCESS_ENFORCEMENT_TRIGGERED|camillec1997|172.13.49.165|172.16.156.55 The second timestamp is the one we will preserve to become our official timestamp because it contains more information (timezone and year are useful, while the day of the week isn’t really) that we can use to achieve the highest precision. Breaking this down, we will write a non-capturing pattern to match the first timestamp. anchors to the start of the line. This is followed by “ ”, which captures the 3 letter month abbreviation. After the month, is “ ”, which is to capture a space; the 2 digits, 0 padded days of the month; and another space. Finally, we have “ ” – for 2-digit hour, 2-digit minute, 2-digit second, and 1 or more spaces. ^\w{3}\s\d{2}\s\d{2}:\d{2}:\d{2}\s+The caret “^” \w{3} \s\d{2}\s \d{2}:\d{2}:\d{2}\s+ For the second timestamp, we want a named capture group. This will become a named field in the JSON blob of parsed-out fields. (?P<timestamp>\w{3}\s\w{3}\s\d{2}\s\d{2}:\d{2}:\d{2}\s\w{3}\s\d{4}) We’ve named this capture group “timestamp”. It contains the same basic regex as the other timestamp, with the addition of “ ” at the start to capture the abbreviated day of the week, and “ ” replacing the “ ” at the end in order to capture the 3 character timezone, and the 4 digit year. \w{3}\s \s\w{3}\s\d{4} \s+ Going further into the log message, we will want to parse out the hostname and the system: May 01 14:31:11 **loggen-app10 test-system[712]**: Mon May 01 14:31:11 UTC 2023|TEST_PROC|[result=Service Access Granted,service=https://portal.fakeuni.edu/uPortal/Login?...,requiredAttributes={}]|SERVICE_ACCESS_ENFORCEMENT_TRIGGERED|camillec1997|172.13.49.165|172.16.156.55 In this message, our hostname is , and our system is . I was not told what the [712] was when I received these logs. I made the assumption that it is the PID (process ID), but I chose not to parse it out separately for now. Parsing these fields is fairly simple, and we end up with: “ ”. We have a pair of named capture groups, hostname, and system. **loggen-app10** **test-system[712]** (?P<hostname>[^\s]+)\s+(?P<system>.*?):\s+ The pattern for the hostname is “ ”, which says capture any non-space character and capture as many of them as you can (greedy). This is followed by “ ”, which captures at least one, but as many as possible (greedy again) space(s). [^\s]+ \s+ The capture group for the system is even easier because after the space(s) we capture everything up to a colon character. To do this, we use “ ”. What that pattern says is, capture any character 0 or more times, but don’t be greedy. .*? After that, we have the colon character and another 1 or more spaces greedy. These aren’t captured but are needed to pad out between this section and the timestamp section we wrote above. This results in the following starting pattern: ^\w{3}\s*\d{2}\s*\d{2}:\d{2}:\d{2}\s+(?P<hostname>[^\s]+)\s+(?P<system>.*?):\s+(?P<timestamp>\w{3}\s\w{3}\s\d{2}\s\d{2}:\d{2}:\d{2}\s\w{3}\s\d{4}) I won’t go through the entire pattern creation process, but I continue to chunk it up as I did above. The resulting final pattern is: ^\w{3}\s*\d{2}\s*\d{2}:\d{2}:\d{2}\s+(?P<hostname>[^\s]+)\s+(?P<system>.*?):\s+(?P<timestamp>\w{3}\s\w{3}\s\d{2}\s\d{2}:\d{2}:\d{2}\s\w{3}\s\d{4})\|(?P<app_name>\w*)\|((?P<message_type>.*?):\s+)?\[?(?P<message>.*)\]?\|(?P<event_message>.*?)\|(?P<username>.*?)\|(?P<external_ip>[\d\.:]*)\|(?P<internal_ip>[\d\.:]*) This final pattern includes the following named capture groups, which become fields in our JSON blob of parsed data: hostname system timestamp app_name message_type message event_message username external_ip internal_ip Implementing The Regex In BindPlane, I create a File source. This looks at my generated log file in /root/complex.log. I’ve selected regex under Parse Format. Under the Regex Pattern, I put in the final pattern above. I’ve checked the box for Parse Timestamp, chosen Manual for the format, and put in the time parsing codes for my timestamp’s pattern. Once done, it looks like this: Sending & Verifying The Data To complete the testing, I need to create a destination and check the data there. For my use case, I’ve chosen a Google Cloud Logging destination. Once my pipeline configuration is complete, I attach it to an agent. After it has run for a few moments, I click the “View Recent Telemetry Button” on the agent’s page The telemetry view shows me the following parsed log: Finally, I check it on the Cloud Logging console as well: Google This displays the same log entry, and it has a JSON payload of our body’s JSON map object from the recent telemetry view. Next Steps For the next steps, I would want to look at parsing that message value. It is frequently a key/value set; as it is in the screenshots & samples above. I could pass the data onward to a processor that parses these key/value entries into another layer of JSON. In the above example, would get parsed back into itself, and you could have fields such as: body.message body.message.result=Service Access Granted
body.message.service=https://innosoftfusiongo.com/sso/logi…
body.message.principal=SimplePrincipal(id=dawsonb, attributes={mail=[dawson.branden@fakeuni.edu], 
eduPersonAffiliation=[Staff], 
ou=[Recreation/Student Rec Center], 
givenName=[Dawson], cn=[Dawson Branden], 
title=[Asst. Director], employeeNumber=[5000000], 
o=[Vice ChancellorStudent Affairs], 
fakeuniOrg=[Vice ChancellorStudent Affairs], casMFARequired=[YES], uid=[dawsonb], eduPersonPrimaryAffiliation=[Staff], fakeuniCid=[5000000], fakeuniSeparationDate=[99991231000000Z], UDC_IDENTIFIER=[dawsonb], sn=[Branden], organizationalStatus=[Staff]})
body.message.requiredAttributes=”” Even this could be parsed further, by putting body.message.principle through a key/value parser as well. Now, someone is bound to wonder, “Why didn’t you just use regex parsing of the body.message subfields as well?” The answer: It is too inconsistent. The regex would be incredibly, and unreasonably, complex when we have the capability to parse key/value pairs already. Conclusion Many forms of data can be found in log files. This data often needs to be parsed to make it both more easily readable for humans and easier for automation and tooling later in the chain to act upon. While the example I worked with was performed on a simple file log, the techniques herein can be used on any log stream. In addition to regex parsing, BindPlane also supports , , key/value pairs, and character-separated values. With the use of processors, these parsers can be chained together to parse embedded data, and manipulate it all into a usable format. JSON XML Also published here.

Stories, News & Mentions about BIND

Categories

Trending Topics

Stories, News & Mentions about BIND

Bind’s Stories on HackerNoon

Categories

Trending Topics