Forem: Ibrahim Elhofy

A brief overview of what alt data is ?

Ibrahim Elhofy — Wed, 16 Nov 2022 04:36:13 +0000

You must know enough about the company or the sector you will invest in to make accurate investment decisions. You can gather this information from formal reports such as company filings, broker forecasts, and management guidance but this will not give you the full picture. The more data outside the conventional you have, the easier it will be to decide your next investment, leaving little to gut feelings.

What is Alternative Data?

The key to solving the problem is using alternative data, which can be any non-traditional data that can provide information on how well a company or asset will perform in the future. And don't worry there is an abundance of this kind of data thanks to the devices we use. However, the question remains: what are the most effective ways to harvest and utilize it?

Where can I harvest this data from?

Social media

It provides a lot of data that really represents people's behaviors and how they behave as humans. these data like social media activity, online reviews, and web searches. Engagements of fans and followers count on a brand’s page can indicate future receptiveness when it launches new products or new campaigns and can be used for Event-driven sentiment tracking or Brand Virality/Advertising success.

Web browsing

Does a software company's app attract or drop new users? Are sites in a particular product category experiencing a sudden influx of visitors? Is the company suffering from weakness and despair and suddenly giving a huge discount?
With an ocean of 4 billion web pages, there is a lot of valuable data for investors, which makes investors able to answer questions like ours. This data can be high product ratings that can indicate strong sales and give a positive insight into a manufacturer or company, Traffic data that can indicate a company's ability to attract new users, quantity sold, and prices on each item page and more of these data
Mobile application data
Like social media, mobile application data reveals a lot of subtle behaviors around the consumer that are very real and close to the market along with in-app activities that can make us know more about how the market works and give us an understanding of the consumer demographic. The level of accuracy and usefulness of the data depends on the size of the application panel and the functions and features collected

Email recipes

Transaction data that is generated from email receipts are accurate enough to build a prediction model about consumers' purchase behaviors, but panels are typically smaller than credit/debit card panels and can be biased depending on the nature of the email receipt collection still you can be given an insight about how macroeconomic conditions like inflation impact demand and purchase

Location data

Where people go is valuable information. More specifically, the GPS data they test on their phones over cellular networks, which reveals broader consumer traffic trends, is valuable information that gives us insight into subtle directions that web or social media searches don't reveal. Social. And that became even more true during the pandemic. In the past, geolocation was not considered quite as useful as other alternative sensor-based data streams, such as satellite imagery. But when previously predictable traffic patterns break down, Wall Street's appetite for GPS seems to be expanding.

People & Company data

This data can give an insight into the next destination of CEOs of the companies like FAANG - be it another company, competitor, or if they are starting a company.
Companies like Proxycurl provide data on identifying and tracking prospective founders. Using the Employee Listing and Person Profile API endpoints, hedge funds can identify existing employees of FAANG companies, then track their change of jobs history all in one place.

Jet tracking

When a private jet carrying representatives from the oil company Occidental landed in Omaha, Nebraska in April 2019, to interview Warren Buffett, news of the arrival extended beyond the chairman and CEO of Berkshire Hathaway. Alternative data company Quandl, which tracks private jet flights, shared news of the visit to its hedge fund clients, who reportedly pay upwards of $100,000 a year for the information. The cost paid off days later, when Buffett announced a $10 billion investment in Occidental, sending its value skyward.

In the years since, "corporate aviation intelligence," as Quandell calls it, has grown in scope. Quiver Quantitative, a free alternative data platform launched in 2020 that aims to give ordinary investors a Wall Street-style edge, is now offering a corporate private jet tracker to everyone.

Who is using alternative data?

Approximately half of all investment firms use alternative data in some form, and this number is likely to continue to increase. Alternative data is increasingly used by hedge funds and investment firms. Investing analysts, quant traders, and fund managers use alternative data in their algorithms to guide their strategies to generate consistently higher returns than the broad market. Furthermore, firms are also investing increasingly in alternative data as part of their investment strategies.

Where can I get alternative data in an actionable way?

According to the Alternative Investment Management Association in collaboration with fintech company SS&C. There are 400 currently active providers. This number is more than 20 times larger now than it was 30 years ago, this tells the story of how alt data providers are fast rising.

Proxycurl

For a more macro view, the hiring velocity or employee turnover rate within a company will signal to hedge funds on its situation at the moment in time. Proxycurl currently provides an exhaustive dataset of companies and their employees for investment analysis and training AI models for this analysis. As Eric Schmidt (former CEO of Google) once said, “People are the foundation of any company’s success.” This alternative data gives a valuable edge in foreseeing the performance of a company and its future trend.

The article that inspired me :
Proxycurl - "The Ultimate Guide to Alternative Data - What Is It Really?"

Contemplate with me : mitt.js

Ibrahim Elhofy — Sun, 12 Jun 2022 17:11:03 +0000

In this article, I'm going to explain some shine lines that I have found in this tiny library, and what we can learn from them.
Before diving into these lines you should have the basics of typescript and javascript.

What is mitt.js

mitt describes itself as a tiny 200-byte functional event emitter / pubsub.
And this is what makes the mitt awesome because the priority of the mitt's size, makes its creator look for solutions that keep their library tiny and awesome at the same time.

Our material

This is the code that we will explain. Check it well to understand what is doing, before continuing reading.

/**
 * Remove an event handler for the given type.
 * If `handler` is omitted, all handlers of the given type are removed.
 * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
 * @param {Function} [handler] Handler function to remove
 * @memberOf mitt
 */
off<Key extends keyof Events>(type: Key, handler?: GenericEventHandler) {
    const handlers: Array<GenericEventHandler> | undefined = all!.get(type);
    if (handlers) {
        if (handler) {
            handlers.splice(handlers.indexOf(handler) >>> 0, 1);
        }
        else {
            all!.set(type, []);
        }
    }
},

Non-null assertion operator `!.`

const handlers: Array<GenericEventHandler> | undefined = all!.get(type);

look at this operator !. did you see it, if you like me I think this is the first time you have seen this operator before in typescript.
This operator is a way to tell the compiler "this expression cannot be null or undefined here, so don't complain about the possibility of it being null or undefined." Sometimes the type checker is unable to make that determination itself.

Bitwise operators with `.splice` method

handlers.splice(handlers.indexOf(handler) >>> 0, 1);

before we know why they used the bitwise operator with .splice method, we should know how .splice method work.

The splice() method changes the contents of an array by removing or replacing existing elements and/or adding new elements in place. To access part of an array without modifying it, see slice().

let list1 = [1, 2, 3, 4, 5];

list.splice(list1.indexOf(2), 1) // [2]

console.log(list1) // [1, 3, 4, 5]

let list2 = [1, 2, 3, 4, 5]

list.splice(list.indexOf(6), 1) // []

console.log(list) // [1, 2, 3, 4] Why ?

but why, because the "indexOf" function returned here -1 so the .splice remove the last one, so simple but the issue is we need to prevent that from happening, but how?
here the ">>>" operator comes, this operator is called Unsigned Right Shift Operator ( we will not talk about it here ), what you should know about this operator, it can convert -1 to 4294967295, and keep all the rest of the numbers as it is.

console.log(-1 >>> 0) // 4294967295
console.log(1 >>> 0) // 1
console.log(4 >>> 0) // 4

and this is the trick, it acts as an implicit if condition, if the item is undefined ( here .splice will return -1 ) the operator will convert it to this huge number 4294967295 if not it keep it the same, and this reduces the possibility of accidentally deleting or sometimes makes it impossible

Finally

I know it ended quickly but these are the things that caught my eye, and it was very interesting to explain them to you.
if you enjoyed like me by learning from these shine lines, remember that the beauty always is in the details.

Resources

In Typescript, what is the ! (exclamation mark / bang) operator when dereferencing a member? - stackoverflow.com

Unsigned right shift (>>>) - developer.mozilla.org

if you want more like this article, tell me in the comments below. bye 👋

HSL-based color name

Ibrahim Elhofy — Wed, 29 Sep 2021 01:06:36 +0000

just add the lightiness parameter of hsl color to the end of color name

:root {

    --white : hsl(0, 0%, 100%);

    --gray-95: hsl(0, 0%, 95%);
    --gray-65: hsl(0, 0%, 65%);
    --gray-45: hsl(0, 0%, 45%);
    --gray-30: hsl(0, 0%, 30%);

    --blue-95 : hsl(195, 100%, 95%);
    --blue-45 : hsl(195, 100%, 45%);
    --blue-20 : hsl(220, 50%, 20%);

    --black : hsl(0, 0%, 10%);

}

My Javascript Execution Context Journey

Ibrahim Elhofy — Mon, 31 May 2021 07:53:08 +0000

Introduction

Execution Context is a concept if you understand it, will make it easier for you to understand more deeper concepts like :

Scope
Scope Chain
Closure
Event Loop

So in this article we will dive in this mysterious concept to understand what really happens under the hood in addition to digging a little bit deeper to know how Execution Context works with Web APIs, let's go.

Execution Context

When a fragment of JavaScript code runs, it runs inside an execution context which is an abstract concept of an environment where the Javascript code is evaluated and executed By environment, we mean the value of this, variables, objects, and functions JavaScript code has access to at a particular time.

When is an `Execution Context` created ?

There are three types of code that create a new execution context:

Global Execution Context (GEC) This is the default or base execution context When a script executes for the first time, the JavaScript engine creates it. All of the global code ( which is not inside any function or object is executed inside the global execution context ). GEC cannot be more than one because only one global environment is possible for JS code execution as the JS engine is single threaded.

Hint: In the Browser the Global Execution Context is created if there is no javascript script in the page or even when you do not have a single line of code in a .js file and load it, you will have the Global Execution Context created.

Function Execution Context It is an Execution Context like similar Global Execution Context gets created when function is invoked, but instead of creating the global object, it creates the arguments object that contains a reference to all the parameters passed into the function:
Eval Execution Context The underrated type in this Execution Context any code executed inside it also gets its own execution context, but because eval is underrated I will ignore it too and in the other hand it is also not recommended, so I will not discuss it here.

Execution Context Stack

When Execution Context is executing it is pushed into Execution Contexts Stack after it terminates, it popped off from the stack and this a whole process makes the javascript engine able to keep track off running function, or processes.

The way that Execution Context Stack works by can solve you the mysterious of how javascript is single threaded that is because you can't put multiple execution context in Execution Context Stack in the same time so you do one thing at run time

So the execution context stack can be conceptually represented as follows:

ExecutionContextStack [

  ExecutionStack <global> { ... }

]

When you execute your script the javascript engine creates a new Execution Context called Global Execution Stack we will examine it deeper later in this article, then it pushes it in our Execution Context Stack

Execution Context Phases

Our Execution Context his life cycle walks through two phases:

The Creation Phase

In this phase The execution context is created. which the JS engine is in the compilation phase and it just scans over the code to compile the code, it doesn’t execute any code and in our Creation Phase there is a lot of things happen.

LexicalEnvironment component is created.
VariableEnvironment component is created.

Lexical Environment

According to ECMAScript 6 specification:

A Lexical Environment is a specification type used to define the association of Identifiers to specific variables and functions based upon the lexical nesting structure of ECMAScript code
Let’s try to simplify a few things here. A lexical environment consists of two main components: the environment record and a reference to the outer (parent) lexical environment:

Simply put, A Lexical Environment it's the internal Javascript Engine construct for let-defined variables. If you define a variable with let in a function , it is only visible within the function.

To keep all things simple let's put what we have just learned into code.

let globalLet = 1;
const globalConst = 2;

function globalFunction () { ... }

ExecutionContextStack [

  ExecutionContext <global> {

    lexicalEnvironment {
       globalLet : <uninitialized>,
       globalConst : <uninitialized>,
       globalFunction : <ref to "globalFunction" function>
    }

  }
]

Each Lexical Environment has three components:

Environment Record
Reference to the outer environment,
This binding.

Environment Record

You can think of it like a dictionary in which declarations of variables and functions are stored within the lexical environment.

let globalLet = 1;
const globalConst = 2;

function globalFunction () { ... }

ExecutionContextStack [

  ExecutionContext <global> {

    lexicalEnvironment {

       EnviromentRecord {
          globalLet : <uninitialized>,
          globalConst : <uninitialized>,
          globalFunction : <ref to "globalFunction" function>
       }
    }
  }
]

There are three type subclasses inside of the Environment Record:

Declarative environment record — As its name suggests, it stores variables, modules and classes, in addition to function declarations, you can think about this concept as instantiations of something you know, like maps or tables to store declared objects in it.
Object environment record — It is an Environment Record that associated with an object called binding object and for each of its properties a corresponding entry is created in the OER.

That is why you can access global variables such as window.document that is because window object is associated global execution context's object environment record any mutation on any on window applies on the record

let globalLet = 1;
const globalConst = 2;

function globalFunction () { ... }

ExecutionContextStack [

  ExecutionContext <global> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        globalLet : <uninitialized>
        globalConst : <uninitialized>
        globalFunction : <ref to "globalFunction" function>
      }

      // binding with `window` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        globalFunction : <ref to "globalFunction" function>
      }
    }
  }
]

Reference to the Outer Environment

Every Environment Record has an [[ outerEnv ]] a reference to the outer environment ( the environment from which it was called ) to make the javascript engine able to look for variables inside the outer environment if they are not found in the current lexical environment

let globalLet = 1;
const globalConst = 2;

function globalFunction (localArgument) {
  let localLet = 3;
  this.localProperty = 4;
}

new globalFunction(5);

ExecutionContextStack [

  ExecutionContext <globalFunction> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        arguments : { 0 : <ref to "localArgument" argument>, length : 1 }
        localLet : 3
      }

      // binding with `arguments` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        localArgument : undefined
      }

      // binding with `this` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        localProperty : undefined
      }

      this: <ref to "globalFunction" object>

    }

  }

  ExecutionContext <global> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        window : <ref to "window" object>
        globalLet : <unintialized>
        globalFunction : <ref to "globalFunction" function>
      }

      // binding with `window` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        globalFunction : <ref to "globalFunction" function>
        fetch : <built-in function>
        setTimeout : <built-in function>
      }

      this: <ref to "window" object>

    }

  }

]

This Binding

In the global execution context the value of this refers to the global object ( in browsers, this refers to window object )
If it is called by an object reference, then the value of this is set to that object, otherwise, the value of this is set to the global object or undefined(in strict mode). For example:

this refers to the reference object and it's value depending on variety variables, so :

In Global Execution Context it refers to the global object ( window in browser or global in node js )
In Functional Execution Context it's referencing depends on the way that function call it. if it called by an object reference, then the value of this is set to that object. Otherwise, the value of this is set to the window object or will be of value undefined ( in strict mode )

let globalLet = 0;

function globalFunction (localArgument) {
  let localLet = 1;
  this.localProperty = 2
}

new globalFunction(3);

ExecutionContextStack [

  ExecutionContext <globalFunction> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        arguments : { 0 : <ref to "localArgument" argument>, length : 1 }
        localLet : <unintialized>
      }

      // binding with `arguments` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        localArgument : undefined
      }

      // binding with `this` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        localProperty : undefined
      }

      this: <ref to "globalFunction" object>

    }

  }

  ExecutionContext <global> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        window : <ref to "window" object>
        globalLet : <unintialized>
        globalFunction : <ref to "globalFunction" function>
      }

      // binding with `window` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        globalFunction : <ref to "globalFunction" function>
        fetch : <built-in function>
        setTimeout : <built-in function>
      }

      this: <ref to "window" object>

    }

  }

]

Variable Environment:

It's also a Lexical Environment so it has all the properties and components that defined above, the purpose beyond that is storing the variable (var) bindings only.

var globalVariable = 0;

ExecutionContextStack [

  ExecutionContext <global> {

    lexicalEnvironment { . . . }

    variableEnvironment {

      // binding with `window` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        globalVariable : undefined
      }

      this: <ref to "window" object>

    }

  }

]

Execution Phase

After Creation Phase our Execution Context walks through the Execution Phase to bind variable initializations, variable assignments, mutability and immutability checking, variable binding deletions, function call execution, etc.

let globalLet = 0;

function globalFunction(localArgument) {
  var localVariable = 2;
  this.localProperty = 3
}

new globalFunction(4);

ExecutionContextStack [

  ExecutionContext <globalFunction> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        arguments : { 0 : <ref to "localArgument" argument>, length : 1 }
      }

      // binding with `arguments` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        localArgument : 4
      }

      // binding with `this` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        localProperty : 3
      }

      this: <ref to "globalFunction" object>

    }

  }

  ExecutionContext <global> {

    lexicalEnvironment {

      EnviromentRecord {
        [[ type ]] : 'declarative'
        window : <ref to "window" object>
        globalLet : 0
        globalFunction : <ref to "globalFunction" function>
      }

      // binding with `window` object
      EnviromentRecord {
        [[ type ]] : 'objective'
        globalFunction : <ref to "globalFunction" function>
        fetch : <built-in function>
        setTimeout : <built-in function>
      }

      this: <ref to "window" object>

    }

  }

]

At the end I advice you to read this article several times to fully understanding these all concepts

Thanks