It is basically, in its simplest form, an interface to something else.
But let's take a look at what it is and how you could use it!
🧵👇🏻
1⃣ What is it?
A Proxy is a wrapper (object), that wraps another object.
Imagine it like a container that looks exactly like the object it wraps, behaves nearly the same, but may add some additional functionality.
You can imagine it, visually, like shown below.
If you need another example:
Imagine a wetsuit. It's a thin layer above your body, keeps the shape of your body, but adds the ability to keep you dry inside!
👇🏻
2⃣ What is it good for?
Proxying is a great pattern to use when you want to add additional functionality to an object, e.g.!
A very simple use case would be an access level audit log, which fires every time you access or set a property on an object or call a method on it.
Another, more complex use-case, is the usage of proxy objects in object relational mappers (short: ORMs).
You sometimes get proxy objects instead of plain objects when you fetch data.
This enables the frameworks to fetch only some of the data, and add lazy fetch functionality.
Although you might have a user object at hand, which has a relationship to multiple posts, some ORMs would only fetch the user.
As soon as you access a post or a collection of posts, the proxy fires another fetch and only then returns the real nested object!
👇🏻
3⃣ Language-level support in JavaScript
Copying each and every property, and method, and...and...and of an object may seem like way too much work to do manually, and you are right!
This is why many languages, including JavaScript have added meta programming capabilities...
...to their standard libs and runtimes.
The simplest form of a proxy in JavaScript, one that simply forwards everything to the original object, without adding any functionality, can be seen below.
The second argument here is an empty handler object.
If you want to recreate the audit logging as a Proxy, you can see a very simplified version of how you could do it below.
The properties get and set within the handler object are so-called traps.
They fire whenever a certain action on the object is registered.
In this case, 'get' fires when a property is accessed, and 'set' fires when a property is set on the object.
There are more traps, and you can, if you're interested, find out more about them here:
Dependency injection is a technique in which an object receives other objects it depends on.
It is actually one form of the broader technique inversion of control.
🧵👇🏻
1⃣ What is it?
Dependency injection is a technique where every other object (service) an object (client) depends on is injected from the outside.
So instead of simply instantiating everything on its own, a class relies on it being passed in from the outside.
You can also view it this way:
Imagine your favorite RPG character could only wear the equipment they started with. No way to change the equipment or the look of your character's equipment from the outside.
Although I am not a data scientist by any means, I was recently asked what knowledge of math someone would need to be able to efficiently get into the field.
Well, I researched a little and came up with the following course track, starting with the basics.
🧵👇
Calculus 1 will cover a lot of the basics, relevant especially to optimization problems which are quite common in data science.
The Dependency Inversion Principle is a part of SOLID, a mnemonic acronym which bundles a total of 5 design principles.
It is often associated with clean code.
But what exactly is it, is it important to you, should you even care?
🧵👇
1⃣ What does it state?
It states:
Modules that encapsulate high-level policy should not depend upon modules that implement details. Rather, both kinds of modules should depend upon abstractions.
This may sound a little complicated, but you can break it up, as follows:
1. High-level modules should not depend on low-level modules. Both should depend on abstractions (e.g., interfaces).
2. Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions.