Coding your self right into a nook
Let’s have a look at an instance. Constructing an e-commerce software is kind of commonplace. Whether or not it’s a web based web site or a bodily point-of-sale system, the app might want to course of bank cards. Now, bank card processing is a reasonably complicated factor, however it’s one thing that lends itself to abstractions.
Let’s say your system might be utilizing the PayStuff cost processor. If you’re a strict adherent to the YAGNI precept (which I wouldn’t advocate) then you definately’ll simply go forward and hard-code the implementation of PayStuff like so:
class PayStuffPaymentProcessor {
processPayment(quantity: quantity) {
console.log(`Processing $${quantity} cost by way of PayStuff...`);
}
}
class Checkout {
personal paymentProcessor: PayStuffPaymentProcessor;
constructor() {
this.paymentProcessor = new PayStuffPaymentProcessor();
}
processOrder(quantity: quantity) {
this.paymentProcessor.processPayment(quantity);
console.log("Order processed efficiently!");
}
}
// Utilization
const checkout = new Checkout();
checkout.processOrder(100);
checkout.processOrder(50);
This works superb, I suppose. You may course of and acquire cash for orders and all is properly. It’s not changeable. And by no means thoughts that you may’t unit check it in any respect. However hey, you aren’t going to wish something extra, proper? YAGNI for the win!
However oops! PayStuff goes out of enterprise! You might want to begin utilizing the ConnectBucks processor as an alternative of PayStuff. And the exact same day you understand that, your product supervisor asks you so as to add help for paying with PayPal and Google Pay. Immediately, your system just isn’t solely laborious to check, nevertheless it doesn’t even work anymore, and supplying all this new performance would require some fairly main surgical procedure to your system, proper?
Abstraction saves the day
What it is best to have finished as an alternative is understand that you’re going to want an abstraction. Thus, you create an interface and write all of your code in opposition to it and never a particular implementation. Then, as an alternative of making the implementation on the spot, you defer the implementation choice and “inject” into the constructor the implementation of the abstraction that you just need to use.
