DEV Community: Ben Matt, Jr.

[Boost]

Ben Matt, Jr. — Wed, 16 Jul 2025 15:16:15 +0000

Ben Matt, Jr.

Jul 16 '25

What are AI parameters?

#ai #chatgpt #llm #deeplearning

Comments

3 min read

What are AI parameters?

Ben Matt, Jr. — Wed, 16 Jul 2025 15:00:20 +0000

We hear a lot about parameters in modern AI models. Every time a highly performant model is released, the next thing everyone wants to know is how many parameters it has. 600 billion? 700 billion? 😋

It's almost as if the more parameters there are, the better the A.I. model performs (and to some extent, it does).

Parametric and Nonparametric learning 🥶

To understand what parameters are and their use within modern LLMs like ChatGPT and Claude, we first need to know how machines learn, because A.I parameters are closely tied to two of the major ways we train A.I model today, which includes parametric and nonparametric techniques. Understanding these two techniques will mark our first step into our understanding of A.I model's parameters.

Parametric learning 🧪

When an A.I model resort to parametric learning during training what it does is that it tries to predict an outcome base on a dataset (that constructs its base knowledge), and if the dataset is very large, that first prediction will likely be incorrect, that were the parameters come in; parameters are settings that influence the predictions of AI models, if a prediction is incorrect the parameters are adjusted and the next prediction will be done based on new parameter settings up until we get to a correct prediction, note that this happens during training not in production.

In this example, during training, the LLM takes an input that asks if the next movie starring a female actress will win an Oscar, the LLM then refers to its base knowledge, and makes a prediction based on its parameter settings.

If the LLM responds with “Yes, the next movie starring a female actress will win an Oscar”, and the movie ended up not making it to the Oscars, next time the prediction will be done with different parameter settings until we start to get more accurate predictions.

It's like telling the model when it’s wrong and then giving it another try with different parameter settings over and over.

Keep in mind that the number of parameters is fixed and does not depend on the amount of training data. By the way, ChatGPT and Claude use a parametric approach.

This is a high-level overview that aims to help you understand the inner workings of LLMs.

Nonparametric learning 😮

The funny thing about nonparametric learning is that it doesn’t mean that there are no parameters involved! We still resort to parameters, but they aren’t a fixed number of parameters that do not depend on the amount of training data.

Nonparametric learning refers to a class of machine learning methods where the model structure is not fixed in advance. That is, the model does not assume a predetermined number of parameters. Instead, it learns patterns directly from the data, and its complexity can grow as more data becomes available.

So what does that mean? How do we make sure our predictions are correct?

This time, as it relies more on the data it’s provided with, the model will have a more analytical approach, it will be more observing, and it adapts to the structure and size of the training data.

Example: Having all successful movies (Oscar winning included) starring female actresses as it dataset, the LLM will rely on the shape of the data, the structure on which the data has been form could present properties like the popularity of the actress, how much revenue she generates on average in the movies she was casted in and so on.

This way, the LLM can assume that in every Oscar-winning movie starring a female actress, the actress had above 70% in popularity and, on average, generated more than $100 million of revenue for the movies she had previously starred in.

It will then evaluate and filter movies based on those features and try to make more accurate predictions.

2 What are parameters?

They are settings that influence an AI model's predictions during training; The better those settings are, the better the predictions.
More parameters don't mean a better AI model; What if those settings do not lead to better predictions? So the quality of the settings determines the quality of the training of the model and the quality of the model itself, and even in that case, we still need a great number of parameters! So finding the right balance is key here!

That it! You made it this far! Follow me if you want more content like this in your feed! 😋

Here’s my Twitter/X 😉

How I built the most beautiful flutter app

Ben Matt, Jr. — Fri, 02 Jun 2023 14:21:50 +0000

Before telling you how I built this app, let me tell you the back story and what it is about!

Why I built this app?

Since the year 2020, I started feeling more and more unproductive, and as a result? I started feeling more and more anxious. Then I tried countless of habit tracking/productivity apps, seeing the of result I started building an app that really help me reach my goals and build the perfect daily routine!

What the app is really about

The first thing I noticed when it comes to building a daily routine is that I was doing it wrong, it was too unrealistic.

So I started studying famous people's daily routines, people like Elon Musk, Bill Gates or Oprah, because when we think of it they are the ones that inspired countless of books about productivity and habits in general.

So I created an app that would let you use successful people's daily routines! But not just that you can share your personal daily routine with other users or even use theirs and many more.

If you're interested in building the most accurate daily routine to improve the quality of your life consider checking this amazing app: https://play.google.com/store/apps/details?id=com.softwareTools.habitMaster

How NodeJS Interacts with the C/C++ language

Ben Matt, Jr. — Tue, 07 Mar 2023 20:51:56 +0000

Why node.js in the first place?

In the era of fast-growing technologies, Node.js plays a massive role in making enterprises more effective and productive. Here is an example:

In moving from a monolithic JAVA server architecture to Node.js, NETFLIX improved performance and reduced infrastructure costs.

They reduced the start-up time from 40 minutes to 1 minute.
They reduced the number of EC2 instances of Node compared with the legacy JAVA stack by 75% while serving the same number of subscribers at lower latencies.

Node.js is great at building fast network applications that scale. Using node.js, you'll be able to handle a vast number of connections simultaneously with high throughput, which equates to high scalability. Understanding how Node.js works under the hood will help you enhance the quality of your following Node.js applications.

Where do nodeJS take its superpower from?

Well, Node.js takes the best out of C and C++ languages as they are part of the fastest and most used low-level languages out there, but how are such interactions made possible?
For that, we need to examine both the V8

The v8 project:

The V8 project is a JAVASCRIPT engine created by Google to enable JAVASCRIPT code to run outside the browser, primarily built to run inside the Chrome browser. The cool thing is that the V8 engine is independent of the browser that runs it. This key feature enabled the rise of Node.js. The V8 engine was the technology built to be the engine that powered Node.js back in 2009. As the popularity of Node.js exploded, V8 became the engine that now powers an incredible amount of server-side code written in JAVASCRIPT.

The Node.js ecosystem is enormous thanks to the V8 engine that also powers desktop applications with projects like Electron.

The libuv project:

Libuv is the C library that implements the Node.js event loop, the asynchronous behaviors, and worker threads. It also gives Node access to the operating system, and as a result, actions like interacting with the file system and accessing device information are now possible.

The V8 engine and the Libuv library are with C and C++ programs. So the purpose of Node is to provide you with an API for accessing functionalities implemented inside V8 and Libuv. See the diagram below.

A closer look at this relation would look a bit different. The following diagram introduces a new concept called native extensions, more on that later.

Node.js interaction with other languages such as C and C++ is made possible by the AddOn and FFI(foreign function interface) technologies. Let have a look at them!

What are addOns?

in C++ that give Node.js access to specific functionalities. We can load them using the require() function just like any Node.js module out there! AddOns are a bridge between Javascript and C++ libraries.

Some of the common ways of implementing addons are Node-API, direct use of internal V8.

When not using Node-API, implementing addons is complicated, involving knowledge of several components and APIs

What is a foreign functions interface (FFI)?

Foreign Function Interfaces are ways to call into native code from a higher-level language. Among all the reasons for resorting to native code, performance is the most important.

🎉🎉🎉 Thank you for reading the third part of this article! 🎉🎉🎉

And if you want more in depth knowledge about your favorite programming languages find me on Twitter as well😃.

Do you really understand JS functions? (part 1)

Ben Matt, Jr. — Mon, 01 Aug 2022 14:40:00 +0000

As the book Effective JavaScript put it, “functions are JavaScript’s workhorse”, and one of the reasons I think that’s true is that while other languages resort to different techniques to manipulate data, JS functions alone plays the role of: procedures, methods, constructors, and even classes and modules. So having a deep understanding of JS functions and knowing how to use them effectively in different context will help you master a significant portion of JavaScript.

What’s the difference between Function, Method, and constructor calls in JS?

In other languages that uses OOP we know that functions, methods, and class constructor or three different things, but in JavaScript they are just different patterns of one single construct: functions.

Functions

 function serverListen(port){
     return `The server is listening at ${port}`;
 }```



## Methods

Meanwhile, methods in JavaScript are just functions that happen to be object properties.



```javascript
const server = {
    startServer: function(){
        try{
            serverConnexion(this.databaseName, this.serverPort);
            console.log(`The server has started listening on port: ${serverPort}`);
        }catch(error){
            throw new Error(error);
        }
    },

    databaseName: "auth_db",
    serverPort: 4937,
};


server.startServer(); // The server has started listening on port: 4937

javascript
But using the this keyword on a nonmethod function is mostly unnecessary as it it would refer to the global object(or window object):

 function runServer(){
    return `The server is listening on port: ${this.serverPort}`
 }

console.log(runServer()); // The server is listening on port: undefined

Since there is no serverPort property on the global object it will be set to undefined.

A good practice in order to quickly catch this kind of mistakes is the use of ES15’s strict mode that sets the default binding of this to undefined.


 function runServer(){
    "use strict"; // 👈
    return `The server is listening at port: ${this.serverPort}`
 }

console.log(runServer()); // error: cannot read property "serverPort" of undefined

Constructors

Unlike functions a constructor passes a brand-new object as the value of this:

function UserData(password, email){
    this.password = password;
    this.email = email;
}

const user = new UserData("@#*&*87*#IOI*&^", "will@gmail.com");

user.email; // will@gmail.com

The primary goal of a constructor call is to initialize an object, using the new keyword we are able to return a new Object.

Thank you if you've read this far! 🎉🎉🎉

Don't forget to follow me if you want to read the upcoming episodes 😉

Follow me on tweeter

The truth about Event Loop 🍦 (Part 1)

Ben Matt, Jr. — Thu, 09 Sep 2021 21:51:23 +0000

JavaScript was designed as an embedded scripting language. JavaScript programs do not run as stand-alone applications, but as scripts in the context of a larger application. The flagship example is, of course, the web browser. A browser can have many windows and tabs running multiple web applications, each responding to various inputs and stimuli: user actions via keyboard, mouse, or touch, the arrival of data from the network, or timed alarms. These
events can occur at any point—even simultaneously—during the lifetime of a web application. And for each kind of event, the application may wish to be notified of information and respond with custom
behavior.
JavaScript’s approach to writing programs that respond to multiple concurrent events is remarkably user-friendly and powerful, using a
combination of a simple execution model, sometimes known as event-
queue or event-loop concurrency, with what are known as asynchronous APIs. Thanks to the effectiveness of this approach, as well as the
fact that JavaScript is standardized independently of web browsers, JavaScript is used as the programming language for a variety of other
applications, from desktop applications to server-side frameworks such as Node.js.
Curiously, the ECMAScript standard has, to date, never said a word
about concurrency. Consequently, this chapter deals with “de facto” characteristics of JavaScript rather than the official standard. Nevertheless, most JavaScript environments share the same approach to concurrency, and future versions of the standard may standardize on
this widely implemented execution model. Regardless of the standard,
working with events and asynchronous APIs is a fundamental part of
programming in JavaScript.

Don't block the Event queue on I/O 🥞

JavaScript programs are structured around events: inputs that may
come in simultaneously from a variety of external sources, such as interactions from a user (clicking a mouse button, pressing a key, or touching a screen), incoming network data, or scheduled alarms. In
some languages, it’s customary to write code that waits for a particular input:

var text = downloadSync("http://example.com/file.txt");
console.log(text);

The console.log API is a common utility in JavaScript platforms for
printing out debugging information to a developer console.

Functions such as downloadSync are known as synchronous, or blocking:
The program stops doing any work while it waits for its input in this case, the result of downloading a file over the internet. Since the computer could be doing other useful work while it waits for the download to complete, such languages typically provide the programmer with a way to create multiple threads: subcomputations that are executed
concurrently, allowing one portion of the program to stop and wait for (“block on”) a slow input while another portion of the program can carry on usefully doing independent work.

In JavaScript, most I/O operations are provided through asynchronous, or nonblocking APIs. Instead of blocking a thread on a result, the programmer provides a callback (see Item 19) for the system to invoke once the input arrives:

downloadAsync("http://example.com/file.txt", function(text) {
    console.log(text);
});

Rather than blocking on the network, this API initiates the download process and then immediately returns after storing the callback in an internal registry. At some point later, when the download ha s completed, the system calls the registered callback, passing it the text of the downloaded file as its argument.
Now, the system does not just jump right in and call the callback the instant the download completes. JavaScript is sometimes described as providing a run-to-completion guarantee: Any user code that is currently running in a shared context, such as a single web page in a browser, or a single running instance of a web server, is allowed to finish executing before the next event handler is invoked. In effect, the system maintains an internal queue of events as they occur, and invokes any registered callbacks one at a time.

The image below shows an illustration of example event queues in client-side and server-side applications. As events occur, they are added to the end of the application’s event queue (at the top of the diagram). The JavaScript system executes the application with an internal event loop, which plucks events off of the bottom of the queue—that is, in the order in which they were received—and calls any registered Java Script event handlers (callbacks like the one passed to downloadAsync above) one at a time, passing the event data as arguments to the handlers.

Example event queues in a) a web client application and
b) a web server.

The benefit of the run-to-completion guarantee is that when your code runs, you know that you have complete control over the application state: You never have to worry that some variable or object property will change out from under you due to concurrently executing code. This has the pleasant result that concurrent programming in Java-Script tends to be much easier than working with threads and locks in languages such as C++, Java, or C#.

Conversely, the drawback of run-to-completion is that any and all code you write effectively holds up the rest of the application from proceeding. In interactive applications like the browser, a blocked event handler prevents any other user input from being handled and can even prevent the rendering of a page, leading to an unresponsive user experience. In a server setting, a blocked handler can prevent other network requests from being handled, leading to an unresponsive server.

The single most important rule of concurrent JavaScript is never to use any blocking I/O APIs in the middle of an application’s event queue. In the browser, hardly any blocking APIs are even available, although a few have sadly leaked into the platform over the years. The XMLHttpRequest library, which provides network I/O similar to the downloadAsync function above, has a synchronous version that is considered bad form. Synchronous I/O has disastrous consequences for the interactivity of a web application, preventing the user from interacting with a page until the I/O operation completes.

By contrast, asynchronous APIs are safe for use in an event-based setting, because they force your application logic to continue processing in a separate “turn” of the event loop. In the examples above, imagine that it takes a couple of seconds to download the URL. In that time, an enormous number of other events may occur. In the synchronous implementation, those events would pile up in the event queue, but the event loop would be stuck waiting for the JavaScript code to finish executing, preventing the processing of any other events. But in the asynchronous version, the JavaScript code registers an event handler and returns immediately, allowing other event handlers to process intervening events before the download completes

In settings where the main application’s event queue is unaffected, blocking operations are less problematic. For example, the web platform provides the Worker API, which makes it possible to spawn concurrent computations. Unlike conventional threads, workers are executed in a completely isolated state, with no access to the global scope or web page contents of the application’s main thread, so they cannot interfere with the execution of code running in from the main event queue. In a worker, using the synchronous variant of XMLHttpRequest is less problematic; blocking on a download does prevent the Worker from continuing, but it does not prevent the page from rendering or the event queue from responding to events. In a server setting, blocking APIs are unproblematic during startup, that is, before the server begins responding to incoming requests. But when
servicing requests, blocking APIs are every bit as catastrophic as in the event queue of the browser.

Things to Remember 🧠

Asynchronous APIs take callbacks to defer processing of expensive operations and avoid blocking the main application.
JavaScript accepts events concurrently but processes event handlers sequentially using an event queue.
Never use blocking I/O in an application’s event queue

Master Objects in JS 🍨 (Part 3)

Ben Matt, Jr. — Wed, 08 Sep 2021 09:12:01 +0000

Make your Constructors new-Agnostic 🏗️

When you create a constructor such as the User function, you rely on callers to remember to call it with the new operator. Notice how the function assumes that the receiver is a brand-new object:

function User(name, passwordHash) {
  this.name = name;
  this.passwordHash = passwordHash;
}

If a caller forgets the new keyword, then the function’s receiver

becomes the global object:

var u = User("baravelli", "d8b74df393528d51cd19980ae0aa028e");
u; // undefined
this.name; // "baravelli"
this.passwordHash; // "d8b74df393528d51cd19980ae0aa028e"

Not only does the function uselessly return undefined, it also disas-
trously creates (or modifies, if they happen to exist already) the global
variables name and passwordHash.

If the User function is defined as ES5 strict code, then the receiver

defaults to undefined:

function User(name, passwordHash) {
  "use strict";
  this.name = name;
  this.passwordHash = passwordHash;
}
var u = User("baravelli", "d8b74df393528d51cd19980ae0aa028e");
// error: this is undefined

In this case, the faulty call leads to an immediate error: The first line
of User attempts to assign to this.name, which throws a TypeError. So,
at least with a strict constructor function, the caller can quickly dis-
cover the bug and fix it.

Still, in either case, the User function is fragile. When used with new
it works as expected, but when used as a normal function it fails. A
more robust approach is to provide a function that works as a con-
structor no matter how it’s called. An easy way to implement this is to
check that the receiver value is a proper instance of User:

function User(name, passwordHash) {
  if (!(this instanceof User)) {
    return new User(name, passwordHash);
  }
  this.name = name;
  this.passwordHash = passwordHash;
}

This way, the result of calling User is an object that inherits from User.prototype, regardless of whether it’s called as a function or as a constructor:

let x = User("baravelli", "d8b74df393528d51cd19980ae0aa028e");
let y = new User("baravelli", "d8b74df393528d51cd19980ae0aa028e");
x instanceof User; // true
y instanceof User; // true

One downside to this pattern is that it requires an extra function call, so it is a bit more expensive. It’s also hard to use for variadi c functions, since there is no straightforward analog to the apply method for calling variadic functions as constructors. A somewhat more exotic approach makes use of ES5’s Object.create:

function User(name, passwordHash) {
  let self = this instanceof User ? this : Object.create(User.prototype);
  self.name = name;
  self.passwordHash = passwordHash;
  return self;
}

Object.create takes a prototype object and returns a new object that inherits from it. So when this version of User is called as a function, the result is a new object inheriting from User.prototype, with the name and passwordHash properties initialized.

While Object.create is only available in ES5, it can be approximated
in older environments by creating a local constructor and instantiat-
ing it with new:

if (typeof Object.create === "undefined") {
  Object.create = function (prototype) {
    function C() {}
    C.prototype = prototype;
    return new C();
  };
}

Note that this only implements the single-argument version of Object.create. The real version also accepts an optional second argument that describes a set of property descriptors to define on the new object.

What happens if someone calls this new version of User with new?
Thanks to the constructor override pattern, it behaves just like it does with a function call. This works because JavaScript allows the result of a new expression to be overridden by an explicit return from a constructor function. When User returns self, the result of the new expression becomes self, which may be a different object from the one bound to this.

Protecting a constructor against misuse may not always be worth the trouble, especially when you are only using a constructor locally.
Still, it’s important to understand how badly things can go wrong if a constructor is called in the wrong way. At the very least, it’s important to document when a constructor function expects to be called with new, especially when sharing it across a large codebase or from a shared library.

Things to Remember 🧠

Make a constructor agnostic to its caller’s syntax by reinvoking itself with new or with Object.create.
Document clearly when a function expects to be called with new.

🎉🎉🎉 Thank you for reading the third part of this article! 🎉🎉🎉

And if you want more in depth knowledge about your favorite programming languages checkout my personal blog to become an on demand developer 😉, and you can find me on twitter as well😃.

Master objects in JS 🍨 (Part 2)

Ben Matt, Jr. — Mon, 06 Sep 2021 21:23:10 +0000

Objects and Prototypes

Like many object-oriented languages, JavaScript provides support for implementation inheritance: the reuse of code or data through a dynamic delegation mechanism. But unlike many conventional languages, JavaScript’s inheritance mechanism is based on prototypes rather than classes. For many programmers, JavaScript is the first object-oriented language they encounter without classes.

In many languages, every object is an instance of an associated class, which provides code shared between all its instances. JavaScript, by contrast, has no built-in notion of classes. Instead, objects inherit from other objects. Every object is associated with some other object, known as its prototype. Working with prototypes can be different from classes, although many concepts from traditional object-oriented languages still carry over.

Understand the difference between `prototype`, `getPrototypeOf` and `proto`

Prototypes involve three separate but related accessors, all of which are named with some variation on the word prototype. This unfortunate overlap naturally leads to quite a bit of confusion. Let’s get straight to the point.

C.prototype is used to establish the prototype of objects created by new C().
Object.getPrototypeOf(obj) is the standard ES5 mechanism for retrieving obj’s prototype object.
obj.__proto__ is a nonstandard mechanism for retrieving obj’s prototype object

To understand each of these, consider a typical definition of a JavaScript datatype. The User constructor expects to be called with the new operator and takes a name and the hash of a password string and
stores them on its created object.

function User(name, passwordHash) {
  this.name = name;
  this.passwordHash = passwordHash;
}

User.prototype.toString = function () {
  return "[User " + this.name + "]";
};

User.prototype.checkPassword = function (password) {
  return hash(password) === this.passwordHash;
};

let u = new User("sfalken", "0ef33ae791068ec64b502d6cb0191387");

The User function comes with a default prototype property, containing an object that starts out more or less empty. In this example, we add two methods to the User.prototype object: toString and checkPassword. When we create an instance of User with the new operator, the resultant object u gets the object stored at User.prototype
automatically assigned as its prototype object. The image below shows a diagram of these objects

Notice the arrow linking the instance object u to the prototype object
User.prototype. This link describes the inheritance relationship.
Property lookups start by searching the object’s own properties; for example, u.name and u.passwordHash return the current values of immediate properties of u. Properties not found directly on u are looked up in u’s prototype. Accessing u.checkPassword, for example, retrieves a method stored in User.prototype.

This leads us to the next item in our list. Whereas the prototype property of a constructor function is used to set up the prototype relationship of new instances, the ES5 function Object.getPrototypeOf() can
be used to retrieve the prototype of an existing object. So, for example, after we create the object u in the example above, we can test:

Object.getPrototypeOf(u) === User.prototype; // true

This illustrates the prototype relationships for the User constructor and
instance.

Some environments produce a nonstandard mechanism for retrieving
the prototype of an object via a special __proto__ property. This can
be useful as a stopgap for environments that do not support ES5’s Object.getPrototypeOf. In such environments, we can similarly test:

u.__proto__ === User.prototype; // true

A final note about prototype relationships: JavaScript programmers will often describe User as a class, even though it consists of little more than a function. Classes in JavaScript are essentially the combination of a constructor function (User) and a prototype object used to share methods between instances of the class (User.prototype).

This is a conceptual view of the User “class”.

The image above provides a good way to think about the User class conceptually. The User function provides a public constructor for the class, and User.prototype is an internal implementation of the methods shared between instances. Ordinary uses of User and u have no need to access the prototype object directly.

Things to Remember 🧠

C.prototype determines the prototype of objects created by new C().
Object.getPrototypeOf(obj) is the standard ES5 function for retrieving the prototype of an object.
obj.__proto__ is a nonstandard mechanism for retrieving the prototype of an object.
A class is a design pattern consisting of a constructor function and an associated prototype.

Prefer `Object.getPrototypeOf` to `proto` 🦄

ES5 introduced Object.getPrototypeOf as the standard API for retrieving an object’s prototype, but only after a number of JavaScript engines had long provided the special __proto__ property for the same purpose. Not all JavaScript environments support this extension, however, and those that do are not entirely compatible. Environments differ, for example, on the treatment of objects with a null prototype. In some environments, proto is inherited from Object.prototype, so an object with a null prototype has no special proto property:

var empty = Object.create(null); // object with no prototype
"__proto__" in empty; // false (in some environments)
// In  others,  __proto__  is  always  handled  specially,  regardless  of  an object’s state:

var empty = Object.create(null); // object with no prototype
"__proto__" in empty; // true (in some environments

Wherever Object.getPrototypeOf is available, it is the more standard and portable approach to extracting prototypes. Moreover, the __proto__ property leads to a number of bugs due to its pollution of
all objects. JavaScript engines that currently support the extension may choose in the future to allow programs to disable it in order to avoid these bugs. Preferring Object.getPrototypeOf ensures that code will continue to work even if __proto__ is disabled.

For JavaScript environments that do not provide the ES5 API, it is easy to implement in terms of __proto__:

if (typeof Object.getPrototypeOf === "undefined") {
  Object.getPrototypeOf = function (obj) {
    var t = typeof obj;
    if (!obj || (t !== "object" && t !== "function")) {
      throw new TypeError("not an object");
    }
    return obj.__proto__;
  };
}

This implementation is safe to include in ES5 environments, because it avoids installing the function if Object.getPrototypeOf already exists.

Things to Remember 🧠

Prefer the standards-compliant Object.getPrototypeOf to the non-
standard __proto__ property.
Implement Object.getPrototypeOf in non-ES5 environments that

support __proto__.

Never modify `proto` 🍕

The special proto property provides an additional power that Object.getPrototypeOf does not: the ability to modify an object’s prototype link. While this power may seem innocuous (after all, it’s just another property, right?), it actually has serious implications and should be avoided. The most obvious reason to avoid modifying
__proto__ is portability: Since not all platforms support the ability to
change an object’s prototype you simply can’t write portable code that does it.

Another reason to avoid modifying __proto__ is performance. All modern JavaScript engines heavily optimize the act of getting and setting object properties, since these are some of the most common operations that JavaScript programs perform. These optimizations are built on the engine’s knowledge of the structure of an object. When you change the object’s internal structure, say, by adding or removing properties to the object or an object in its prototype chain, some of these optimizations are invalidated. Modifying __proto__ actually changes the inheritance structure itself, which is the most destructive change possible. This can invalidate many more optimizations than modifications to ordinary properties.

But the biggest reason to avoid modifying __proto__ is for maintaining predictable behavior. An object’s prototype chain defines its behavior by determining its set of properties and property values. Modifying an object’s prototype link is like giving it a brain transplant: It swaps the object’s entire inheritance hierarchy. It may be possible to imagine exceptional situations where such an operation could be helpful, but as a matter of basic sanity, an inheritance hierarchy should remain stable.

For creating new objects with a custom prototype link, you can use ES5’s Object.create. For environments that do not implement ES5, Item 33 provides a portable implementation of Object.create that does not rely on __proto__.

Things to Remember 🧠

Never modify an object’s __proto__ property.
Use Object.create to provide a custom prototype for new objects.

🎉🎉🎉 Thank you for reading the second part this article! 🎉🎉🎉

Don't forget to checkout the third part of this serie! 🥳 Make your Constructors new-Agnostic.

And if you want more in depth knowledge about your favorite programming languages checkout my personal blog to become an on demand developer 😉, and you can find me on twitter as well😃.

Master Objects in JS 🍨 (Part 1)

Ben Matt, Jr. — Mon, 06 Sep 2021 15:35:48 +0000

Objects

Objects are JavaScript’s fundamental data structure. Intuitively, an object represents a table relating strings to values. But when you dig deeper, there is a fair amount of machinery that goes into objects.

Most strongly typed languages such as Java use isEquals() to check whether two objects
are the same. You may be tempted to simply use the == operator to check whether two
objects are the same in JavaScript.
However, this will not evaluate to true.

let firstEmptyObject = {};
let secondEmptyObject = {};

firstEmptyObject == secondEmptyObject; // returns false
firstEmptyObject === secondEmptyObject; // returns false

Although these objects are equivalent (same properties and values), they are not
equal. Namely, the variables have different addresses in memory.
This is why most JavaScript applications use utility libraries such as lodash or
underscore, which have the isEqual(object1, object2) function to check two objects
or values strictly. This occurs via implementation of some property-based equality
checking where each property of the object is compared.
In this example, each property is compared to achieve an accurate object equality result.

let personOne = {
  name: "Will",
  lastName: "Owen",
};

let personTwo = {
  name: "Will",
  lastName: "Owen",
};


function isEquivalent(a, b) {
    // arrays of property names
    var aProps = Object.getOwnPropertyNames(a);
    var bProps = Object.getOwnPropertyNames(b);

    // If their property lengths are different, they're different objects
    if (aProps.length != bProps.length) {
        return false;
    }

    for (var i = 0; i < aProps.length; i++) {
        var propName = aProps[i];

        // If the values of the property are different, not equal
        if (a[propName] !== b[propName]) {
            return false;
        }
    }

    // If everything matched, correct
    return true;
}

However, this would still work for objects that have only a string or a number as the
property.

let obj1 = { prop1: "test", prop2: function () {} };
let obj2 = { prop1: "test", prop2: function () {} };
equivalenceCheck(obj1, obj2); // returns false

This is because functions and arrays cannot simply use the == operator to check for
equality.

let function1 = function () {
  console.log(2);
};
let function2 = function () {
  console.log(2);
};
console.log(function1 == function2); // prints 'false'

Although the two functions perform the same operation, the functions have

different addresses in memory, and therefore the equality operator returns false.
The primitive equality check operators, == and ===, can be used only for strings and
numbers. To implement an equivalence check for objects, each property in the object
needs to be checked.

Now let dig a little bit deeper 😋.

Freezing an object 🥶

The first thing you need to know about objects in JavaScript is that they are mutable (meaning they can be changed). That flexibility it one the most powerful things about JavaScript! 🤩 However in order to make your code more robust 💪

you sometimes need to create objects that are immutable, for example perhaps you use an object to keep track of data that are constant and need to remain constant, in a case like that you need to freeze the object to prevent it from being changed.

Another common application is in functional programming using such a of paradigm you want to avoid mutating data. let's look at an example of how to freeze an object.

let courseInfo = {
  question: 10,
  possScore: 100,
  active: true,
  startPage: "./page1.html",
};

Now let say you want to modify the courseInfo object, you would write something like this.

delete courseInfo.possScore;
console.log(courseInfo); // {question: 10, active: true, startPage: "./page1.html"};

As you can see we can't access the possScore property anymore as we deleted it, But let's look at how we would prevent that from happening.

const courseInfo = Object.freeze({
  question: 10,
  possScore: 100,
  active: true,
  startPage: "./page1.html",
}); // Our object is now freezed!🥶

Let's do a step by step analysis.

step 1. We changed courseInfo variable from let to a constant variable because we don't want it to be reassigned either.

step 2. We make use of the Object.freeze static method to prevent all the properties and values of the object from being changed.

But now how do we check if our courseInfo is actually frozen? Well you can try to delete or add new things to it but one simple way of doing is to use the isFrozen method like so.

console.log(Object.isFrozen(courseInfo)); // This returns true 😉

Create a copy of an object 🧪

One of the problems JavaScript developers usually faces when working with objects is creating a copy of them. This happens because they try to assign the variable that they want to assign a variable X to a variable Y thinking that this would help them in anyway, but the truth is by doing so, we are just using a reference to the original object, as the result when ever the original object is modified the so called "copy" will change as well.

A simple and efficient way of achieving that task is making use of both the JSON.parse() and JSON.stringify() methods like so.

let courseInfo = {
  question: 10,
  possScore: 100,
  active: true,
  startPage: "./page1.html",
};
// Create a copy of the courseInfo object
let copyOfCourseInfo = JSON.parse(JSON.stringify(courseInfo));

// Modify the original object
delete courseInfo.question;

console.log(courseInfo); // {possScore: 100, active: true, startPage: "./page1.html"};

console.log(courseInfo); // {question: 10, possScore: 100, active: true, startPage: "./page1.html"};

🎉🎉🎉 Thank you for reading the first part this article! 🎉🎉🎉

Don't forget to checkout the second part of this serie because we dig even deeper 🥳! JS Objects and Prototypes.

And if you want more in depth knowledge about your favorite languages checkout my personal blog to become an on demand developer 😉, and you can find me on twitter as well😃.

Recursion explained 🎉

Ben Matt, Jr. — Wed, 23 Jun 2021 15:12:35 +0000

In this article we will break down all the concept you need to know before saying that you fully understand recursion. The goal is to talk about those concepts so that you can come up with your own definition of what recursion is 😋.

Definition : Recursion is mostly described as a process that calls it self.
It can also be described by a function that calls it self.

Call Stack : In case we're calling a function or more multiple times in a program,
their is a thing called "Call Stack" that is an actual stack in witch functions are placed
on top of each other in terms of execution,
so the call stack can hold informations about all the functions that are placed on it.

So when using a recursive function what happen is we keep pushing the same function onto the "Call Stack".

What's the main structure of a recursive function ? :

A recursive function has two essential parts wich are the base case and a different input (or function argument).

1) The base case :
For the base case you can, think of it as a condition that causes the function to stop calling it self, in other words it stops the recursion.

2) Different input : Everytime a recursive function is being called, we need to make sure that the input aren't the same.

If one of the two or both are missing the process can resolve in what called a
"Stack overflow" forcing you to spend hours looking for answers on stackoverflow.com 😉.

Now let play a game!

The followings are two examples of recursive functions and your goal is to.
1) Find the "base case".
2) Find the the difference input.
3) Leave your answers in the comment section 😋.

Ex 1:

Ex 2:

How to remove duplicates from an array in Dart

Ben Matt, Jr. — Sun, 13 Jun 2021 22:22:15 +0000

removeDuplicates(){
final list = [1, 2, 2, 3, 4, 4, 4];

return list.toSet().toList();
}

Output: [1,2,3,4]

Explanations: First we initialized a variable called list to an array that contains some duplicates, then we converted it to a set(as sets can not contain duplicates) and then back to a list.

Don't forget to follow me if you like tips like this 😉

How To Run VS Code In Your Browser

Ben Matt, Jr. — Fri, 02 Oct 2020 16:29:00 +0000

If you like VS Code then you'll surely like this brand feature on VS Code!
Because yes! You can actually run VS Code on your browser!
And here is how!

First you need to check this repo : https://github.com/cdr/code-server

This is the official repo to get VS Code in your browser, once you get there you'll just need to copy & past those two command in your command prompt(You need to be administrator or sudo depending on what OS you're currently using).

First Copy & past this command: curl -fsSL https://code-server.dev/install.sh | sh -s -- --dry-run

Now that you have code-server installed you need to copy & past this one: curl -fsSL https://code-server.dev/install.sh | sh

And after all that you're ready to go!
You just need to tape the following : code-server.

That will generate a log for you and you should search for this line right here: HTTP server listening on http://127.0.0.1:8080.

Copy & past that URL in your browser and see the magic!

This link will take you to a YouTube video that talks about it:
https://youtu.be/gB1Pg5ge06g

DEV Community: Ben Matt, Jr.

[Boost]

What are AI parameters?

What are AI parameters?

Parametric and Nonparametric learning 🥶

Parametric learning 🧪

Nonparametric learning 😮

2 What are parameters?

How I built the most beautiful flutter app

Why I built this app?

What the app is really about

How NodeJS Interacts with the C/C++ language

Why node.js in the first place?

Where do nodeJS take its superpower from?

The v8 project:

The libuv project:

What are addOns?

What is a foreign functions interface (FFI)?

🎉🎉🎉 Thank you for reading the third part of this article! 🎉🎉🎉

Do you really understand JS functions? (part 1)

What’s the difference between Function, Method, and constructor calls in JS?

Functions

Constructors

Thank you if you've read this far! 🎉🎉🎉

Don't forget to follow me if you want to read the upcoming episodes 😉

The truth about Event Loop 🍦 (Part 1)

Don't block the Event queue on I/O 🥞

Things to Remember 🧠

Master Objects in JS 🍨 (Part 3)

Make your Constructors new-Agnostic 🏗️

Things to Remember 🧠

🎉🎉🎉 Thank you for reading the third part of this article! 🎉🎉🎉

Master objects in JS 🍨 (Part 2)

Objects and Prototypes

Understand the difference between prototype, getPrototypeOf and __proto__

Things to Remember 🧠

Prefer Object.getPrototypeOf to __proto__ 🦄

Things to Remember 🧠

Never modify __proto__ 🍕

Things to Remember 🧠

🎉🎉🎉 Thank you for reading the second part this article! 🎉🎉🎉

Don't forget to checkout the third part of this serie! 🥳 Make your Constructors new-Agnostic.

Master Objects in JS 🍨 (Part 1)

Objects

Freezing an object 🥶

Create a copy of an object 🧪

🎉🎉🎉 Thank you for reading the first part this article! 🎉🎉🎉

Don't forget to checkout the second part of this serie because we dig even deeper 🥳! JS Objects and Prototypes.

Recursion explained 🎉

How to remove duplicates from an array in Dart

How To Run VS Code In Your Browser

Understand the difference between `prototype`, `getPrototypeOf` and `proto`

Prefer `Object.getPrototypeOf` to `proto` 🦄

Never modify `proto` 🍕