#entrepreneur Tumblr posts

  • Digging up More Knowledge from Entrepreneurial Minds

    The past 2 weeks of lectures have poured us an overflowing knowledge about some of the most important aspects in start up and as an entrepreneur. In the series 3 and 4 lectures that we had, I have learned first about an overview of intellectual property and intellectual property right. But first, let’s define what is intellectual property. It was quoted on the lecture and the speaker as a creation of mind. Our ideas, invention, literary and artistic work , symbols, names, images and design that lives within human intellect serves as intellectual property. Intellectual property is very important for the reason that it can be monetize by transforming ideas into tangible products such as soaps, shampoo.or those products that can be touch. Intellectual property also plays an important role for businesses since it prevent competitors from copying one’s trademark, technology or product. There are Intellectual Property Rights such as Trademarks and Service Marks, Geographic Indications, Patents, Utility Model, Industrial Designs, Lay-out Designs, Undisclosed Information, New Plants Varieties as provided in Republic Act No. 9168 ans Copyright and Related Rights. These Intellectual Property Rights are very essential to all businesses. The second thing that I have learned was the process in Pre-Incubatee Registraion. As stated by the speaker, incubatee is a natural person, unregistered asscoiation , or a juridical entity who has the desire to undergo the incubation program.

    The next topic was all about doing things that don’t scale. I have learned that an entrepreneurs or even the companies must consider the feed backs, demand and the relationship to the customers because they are the utmost important factor in the business. Another one was the statement that start-up success are those who followed the process correctly and appropriately, it can be learned and taught. The outcome is less important than taking the right process by doing such thing. And I guess, it is what more important.

    The last but not the least is about the fund raising and pitching. Startups needs to raise money in order to grow fast. It was said and done that startup need a bigger amount of capital for the costs it will take. In the lecture of this topic, I have learned that there are many sources of funds whenever me and my team pursue our startup. I am able to know where I can get some help, financially. There are TF, F.F.F., Angel Investors, Venture Capitalist and Public Investors. There are also rules that stated in pitching. Another thing that most important in promoting the startup is the pitching. It is the setting where the team present startup to the investors and pursuing them to invest with the startup.There are also rules that stated in pitching. This kind of activity serves as the beginning in engaging the real world of business industry where you are like in an actual setting trying to convince the investors with many competitors. The team needs to compete and give the best they can. I am able also to know the components on what to pitch to have a clear and have guide on how to present a pitch.

    Speaking of pitching, we are going to pitch the startup we created. Hoping that the team can pass this activity but I know and I believe in my team that the outcome of this activity will gives us the smile on our faces.

    Insights on our Startup Journey

    From the beginning, I was so nervous and I have some doubts regarding on the thought that we are going to create a startup. I did some research and all with my team. We came up with the product and decided to make it as our final startup. At the first activity which is an interview, the team really exerted effort considering on what the the situation right now. But still, we made it. It lasted a month. We validated the product. We even rejected and it feels like being rejected by the whole world. I have realized that it really hard to create or invent such product that is new to the customer. I guess, it takes time, effort, and even money to pursue this. I have also experienced ups and downs in this journey because of lack of motivation to continue with what we created. I even doubted to myself that we will not gonna make it. But here we are, pursuing what we started, believing to ourselves and accepting the things that may come in this journey. This journey is unforgettable. It is true. It really teaches me to prepare in the real world where I am going to. This also serves as charge to experience even though this is a course, I didn’t think it as compliance but instead, It feels like a training and seminars, preparing and molding the business’ students. I am very thankful and blessed to experienced this journey. Whatever the result of our startup, I am always be grateful.

    View Full
  • Are you a writing enthusiast? Let’s make this pandemic more productive, polish your skills & your resume heavy with certificates! đŸ”„


    Skill Vancer is Hiring Interns for Content writing✍

    Duration: 1 Month Internship, Work from home.

    Perks: Internship Certificates and L.O.R.✹

    Why Skillvancer & not any other content writing internship?

    We are working on the Business and Entrepreneurship niche, its not same as any other casual content writing internship, it will also add value to your CV. 💯


    We’ll also provide you the free training for writing content. (Optional)


    Fill the registration forms now👇



    For more details & queries, DM me or contact on the given number. ⏳


    View Full
  • I don’t like the memories because the tears come easily, and once again I break my promise to myself for this day. It’s a constant battle.
    A war between remembering and forgetting.

    - NicK 05-Dec-2020 09:48 PM

    View Full
  • View Full
  • Brands worn
    Shirt: @reiss
    Tie: @etonshirts
    Blazer: @ateliermunro

    A Fashionable Gentleman
    The Elle Edwards Experience

    “Enhance Your Life” - The Elle Edwards Experience. #lifestyle #elleedwards #fashion #guyswithstyle #menwithstyle #gentlemen #passion #success #stylist #fashionstylist #personalshopper #personalstylist #fashionable #dapper #stylish #wealth #business #entrepreneur #toronto #creativedirector #marketing #model #luxury #brand #director #Toronto #Canada #sprezzatura #pitti #menswear @suitsharks @melaninattires @blarkfashion @blackmenswear @blackmanblacktie @menofcalibre @brotherhoodofstyle @thefashionablemen @backinspiredalphas
    @the_blacknarrative (at Toronto, Ontario)

    View Full
  • Wealth Is Amazing When You Use It In The Right Way:

    Check Out Our Latest Video, You Definitely Want To Know Who Our Number One Muslim Billionaire Is:

    Top 10 Richest Muslim Billionaires In The World:


    View Full
  • Image by Brett Jordan available at Unsplash

    What is Probability Distribution? What are different types of Probability distributions? How will it help in framing Data Science Solutions?.

    Let me try to explain it in very simple words

    Definition:-A probability distribution is the mathematical function that gives the probabilities of occurrence of different possible outcomes for an experiment.

    Rolling a Dice gives me a set of outcomes distributed in a particular way , where as the marks of a particular subject of a class gives me another distribution and occurrence of car accidents in a particular year follows an entirely different distribution and so on. Type of distribution is useful when you need to know which outcomes are most likely, the spread of potential values, and the likelihood of different results.

    Probability Distribution is broadly classified into two Discrete Probability Distributions and Continuous Probability Distributions.

    Probability Distributions

    Discrete Probability Distributions

    When you toss a coin you will have either Heads or Tails .Your outcome is discrete. You cant have any value in between. Here counts of events are discrete functions. Same is the case with rolling a dice. Likelihood of rolling a specific number is discrete. Your output will be 1,2,3,4,5 or 6.Discrete probability functions are also known as probability mass functions. For discrete probability distribution functions, each possible value has a non-zero likelihood. Also, the sum of probabilities for all possible values will be equal to one. Binomial Distribution, Poisson Distribution, Uniform Distribution etc are the examples of Discrete Probability Distributions

    Continuous Probability Distributions.

    In the case of measurement of Height or weight of a class, the values or outcomes we observe wouldn’t be a discrete number. It could be continuous values .A person’s weight could be 48.050 and another could be 46.063.It can be calculated to as many decimals as you need based on the scale of the machine used for measurement. Continuous probability functions are also known as probability density functions. Sum of probabilities in a continuous probability function remains one .However we cannot confirm that each possible value/outcome will have non-zero likelihood. Hence probabilities for continuous distributions are measured over ranges of values rather than single points. Area under curve for a probability plot of continuous probability distribution is one. Normal distribution , Weibull distribution, Log Normal distribution are examples of Continuous probability Distributions

    Now let’s look at Distributions in details

    Uniform Distribution

    A uniform distribution is a distribution where all the outcomes (between maximum value and minimum value)has an equally likely probability. Uniform distribution can be Continuous uniform distribution and Discrete Uniform distribution.

    Continuous uniform distribution.

    Continuous uniform distribution also called as rectangular distribution describes an experiment where there is an arbitrary outcome that lies between certain bounds, a and b, which are the minimum and maximum values.

    You have entered your apartment and are about to take an elevator to your floor .You call and elevator takes between 0 and 40seconds to reach you after you press the button. This is a classic example of continuous uniform distribution with Minimum value zero and maximum value 40 seconds.

    Continuous Uniform Distribution function (source: Wikipedia)

    The probability density function of Continuous Uniform Distribution is

    Expected Value of Continuous Uniform Distribution is

    Variance of Continuous Uniform Distribution is

    In the above problem E(X) =Âœ*(40) = 20s and V(X) = 1/12*(40)ÂČ=400/3

    Discrete Uniform distribution.

    Discrete uniform distribution is a symmetric probability distribution wherein a finite number of values are equally likely to be observed; every one of n values has equal probability 1/n

    Drawing a heart, a club, a diamond or a spade from a pack of card is an example for Discrete Uniform distribution.

    Discrete Uniform Distribution function (source: Wikipedia)

    The probability density function of Discrete Uniform Distribution is

    Expected Value of Discrete Uniform Distribution is

    Variance of Discrete Uniform Distribution is

    In the above problem E(X) =(1+6)/2 = 3.5 and

    V(X) = ((6–1+1)ÂČ-1)/12=35/12=2.9

    Bernoulli Distribution

    The Bernoulli distribution is the discrete probability distribution of a random variable which takes a binary output: 1 with probability p, and 0 with probability (1-p). Few examples for Bernoulli distribution is , when you toss a coin, you will either get a Heads or Tails, if you associate getting Heads with winning or success and getting Tail with loosing , then it is a Bernoulli distribution. Same with success or failure , Gender male or female, passing or failing in an exam etc.

    Imagine getting a head while flipping a fair coin is considered as success, then head is equated to 1 and tail is equated to 0 . Probability of getting head is œ.Probability of success is

    The expected value of a Bernoulli random variable is

    The Variance of Bernoulli distributed X is

    Bernoulli distribution is when we do experiment only once, like flipping a coin once or throwing a die once. So what if the experiments are repeated for multiple times? The distribution for that is Binomial Distribution. Bernoulli distribution is a special case of the binomial distribution where a single trial is conducted (so n would be 1 for such a binomial distribution).

    Binomial Distribution

    The binomial distribution is used when there are exactly two mutually exclusive outcomes of a trial, like Heads or Tails while flipping a coin, raining or not raining tomorrow ,winning or losing a match. These outcomes are appropriately labeled as “success” and “failure”. The binomial distribution is used to obtain the probability of observing x successes in N trials, with the probability of success on a single trial denoted by p. The binomial distribution assumes that p is fixed for all trials.

    Binomial Distribution(source: Wikipedia)

    The probability of getting exactly x successes in n independent Bernoulli trials is given by the probability mass function:

    Suppose we are flipping a coin for 6 times, if probability of getting head is considered as success and getting tail as failure .Each trial has a probability of success 1/2 . What will be the probability of getting heads 4 times.

    Each Trial is a Bernoulli and it’s probability of occurrence is p

    Getting 4 heads in flipping coin 6 times is 6c4. Which is equal to 15 and probability of success is 1/64. P(X=4) = 15/64

    If X ~ B(n, p), that is, X is a binomially distributed random variable, n being the total number of experiments and p the probability of each experiment yielding a successful result, then the expected value of X is:

    The variance of binomial distribution is

    Poisson Distribution

    We now know how binary distribution works. Imagine a case where the number of events is near to infinity or is very very large number and also the probability of event is very very low or near to zero ,like number of emails you receive in a year, number of accident claims that a insurance company receives etc. In above cases you may not have exact ’n’ and ‘p’ value but you know that n is near to infinity and p is near to zero. In such cases we use Poisson distribution. In Poisson distribution we consider the parameter λ.

    A Poisson Process is a model for a series of discrete event where the average time between events is known, but the exact timing of events is random. The arrival of an event is independent of the event before .

    Poisson distribution is the distribution that expresses the probability of a given number of events occurring in a fixed interval of time or space, if these events occur with a known constant mean rate and independently of the time since the last event.

    Poisson Distribution(source: Wikipedia)

    When λ becomes bigger, the graph looks more like a normal distribution

    A discrete random variable X is said to have a Poisson distribution with parameter λ > 0, if for k = 0, 1, 2, 
, the probability mass function of X is given by

    The Poisson distribution can be applied to systems with a large number of possible events, each of which is rare.

    The positive real number λ is equal to the expected value of X and also to its variance

    Normal Distribution

    Normal distribution is most common distribution which we see in our daily life . There are lot of examples around us for this distribution which is other wise called Bell-curve like distribution of heights of students in the calls, blood pressure, measurement error, and IQ scores.

    Normal Distribution(source: Wikipedia)

    The Probability Density function of Normal distribution is

    The parameter ÎŒ is the mean or expectation of the distribution (and also its median and mode), while the parameter σ is its standard deviation. The variance of the distribution is σ^2

    Empirical rule of Normal distribution is that, the 68.27% values lies within one standard deviation ,the 95.45% values lies within two standard deviation and the 99.73% values lies within two standard deviation

    Gamma Distribution

    What is Gamma Distribution? Where is it used ?Gamma distribution helps to predict the wait time till the ’n’ th event occurs. Gamma distribution has two parameters, alpha- which represents the shape , and beta- which represents the scale. Shape Parameter as name suggests define the shape of distribution and scale parameter defines the statistical dispersion . If s is large, then the distribution will be more spread out; if s is small then it will be more concentrated. Few examples of Gamma distribution are amount of rainfall accumulated in a reservoir , size of loan defaults or aggregate insurance claims, load on web servers etc

    Gamma Distribution(source: Wikipedia)

    The Probability Density function of Gamma distribution is

    The mean of Gamma distribution is

    The Variance of Gamma distribution is


    I have covered the main distributions which are useful for Data scientists in their analysis and modelling. Please share your thoughts and questions in the comments section. I will be happy to respond to your questions .

    External image

    Understanding Probability Distribution was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

    source https://medium.com/swlh/understanding-probability-distribution-b5c041f5d564?source=rss—-f5af2b715248—4
    View Full
  • image

    As a developer, DevOps is critical to the survival of your business but deployment is a tricky situation. With so many options out there

    Continue reading on The Startup »

    source https://medium.com/swlh/docker-101-what-would-docker-do-1895a2bd75df?source=rss—-f5af2b715248—4
    View Full
  • Introduction to Java BytecodePhoto by Kelly Sikkema on Unsplash

    Every Java developer is familiar with the role of JVM in the language’s ecosystem. However, most don’t understand how JVM works under the hood. While that knowledge is not necessary to become a Java developer, having a better understanding of JVM will help you to write better code because, then, you would know how every line of the code you write impacts the process that’s going on inside the JVM.

    To understand how JVM works, though, you need to understand what Java Bytecode is. So, in this article series, I’m going to lead you through the ins and outs of Java bytecode and how it matters to the JVM when you finally run your program.

    What is Java Bytecode?

    If you have heard how Java raves about the platform independence of Java programs at one point in your programming life, you have Java bytecode to thank for it.

    Java bytecode is the instruction set JVM uses to run your program. Since the bytecode generated for your program is independent of the platform it’s running on, as long as you have JVM to interpret the bytecode, you can run your program on any platform without an issue.

    How is bytecode generated?

    Bytecode is simply the output you get when you compile a Java class. The .class file you get when you compile a class is actually the set of bytecode instructions your code translates into. It needs an interpreter like JVM to interpret and execute the instructions.

    How can you view Java bytecode?

    If you have tried opening a .class file, you must know from experience that it’s impossible unless you are using a decompiler. With a decompiler in play, however, you are not actually seeing the bytecode but the Java code the decompiler retranslates the bytecode into.

    If you really want to see the bytecode itself, the easiest way to do so is using the command-line.

    You can run the following command to see the actual bytecode of a class file.

    javap -c -p -v [path to the .class file]

    What are the used flags?

    • -c is used to disassemble the Java class. If you want to see the actual bytecode, use this flag.
    • -p is used to expose the private members of the class.
    • -v is used to view verbose information like stack size and constant pool.

    A bit about how JVM works

    Before going deep into Java bytecode, we have to understand a bit about how JVM processes bytecode.

    Methods are one of the most important parts of a Java code for JVM. The runtime of a Java program is, in fact, a collection of methods called by the JVM. It creates something called a frame for each method it invokes and puts the created frame on top of the current thread’s stack for execution.

    A frame consists of the local environment that is required to sustain its execution. Mainly, it contains a local variable array and an operand stack. Let’s see what each of them are.

    Local variable array

    The local variable array, as the name says, is used to store the local variables used in the method. In addition, it stores the arguments accepted by the method as well.

    In the zero-indexed local variable array, the first indexes are used to store the method arguments. After they are stored, the other local variables are stored in the array. If the method is an instance method, instead of a static one, the zeroth index is reserved to store the this reference which points to the object instance that is used to call the method.

    Let’s define two methods: one static and one instance method but similar in all the other ways.

    The local variable arrays of the two will look like this.

    Introduction to Java Bytecodelocal variable arrays in JVM method frames

    Operand stack

    The operand stack is the workspace inside a method frame. Since it’s a stack as the name suggests, you can only push and pop values from the top of the operand stack. Most bytecode instructions belonging to a particular method either engage in pushing values to the stack or popping values from the stack to process them.

    Bytecode instruction loadand its extensions are used to push a value stored in the variable array onto the stack. Instruction store is used to pop values from the stack and store them in the variable array. In addition, there are other instructions that pop values from the stack to process them.

    Examples of such scenarios are the add command which pops the two top-most values from the stack and adds them together, and method invocation instructions that pops the top-most values (the number depends on the number of parameters accepted by the method) from the stack to pass them as arguments to the method. If these commands have resulting values they are pushed back onto the stack.

    aload_0 //push the reference to non-primitive data value at index 0 of the variable array
    iload_2 //push the int value at index 4 of the variable array
    iconst_3 //push the int 3 on to the stack
    iadd //add the two top-most int values on the stack
    istore_3 //pop the result of the add operation and store at index 6 of the variable array
    Introduction to Java BytecodeHow the operand stack and local variable array changes with the above instructions

    Let’s view bytecode

    I have written a simple Java class so that we can see its bytecode.

    Now, run let’s compile the class using the javac command and view the bytecode with javap command. Without verbose, the result looks like this.

    When you look at these bytecode instructions, you’ll identify a few familiar ones, including load and const commands. The rest, though, may leave you a more than little baffled.

    Deconstructing bytecode

    It isn’t as intimidating as it looks. Let’s try to deconstruct the SimpleClass’s bytecode one-by-one. Let’s start with the simplest method, isEven.

    private boolean isEven(int num) {
    return num % 2 == 0;

    And its bytecode:

    private boolean isEven(int);
    0: iload_1
    1: iconst_2
    2: irem
    3: ifne 10
    6: iconst_1
    7: goto 11
    10: iconst_0
    11: ireturn
    1. First, the iload_1 instruction pushes the value at index 1 of the local variable array onto the operand stack. Since the isEven method is an instance method, reference to this is stored at index 0. Then, we can easily understand that the value stored at index 1 is, in fact, the accepted int parameter value.
    2. iconst_2 pushes the int value 2 on to the top of the operand stack.
    3. irem instruction is used to find the remainder from the division between 2 numbers. It’s the instruction that represents the logic of the % operator. It pops the 2 top-most values in the stack and pushes the result back to the stack.
    4. ifne command tells the JVM to move to the instruction at the given offset, in this case, 10, if the value processed by the command is not equal to 0. The command pops the top element of the stack to implement this logic on. If the number passed was even, the top element will be 0, in which case JVM is instructed to move to the instruction at index 6. However, if the stack value is not zero, which happens when the number is not even, JVM moves to the instruction at index 10.
    5. iconst_1 pushes int value 1 to the stack. This happens only if the result of irem is 1. Here, 1 is used to represent the boolean true value.
    6. goto instructs the JVM to go to the instruction given in the offset, which is 11 in this case. goto instruction is used to jump from one place in the instruction table to another.
    7. iconst_0 pushes value 0 to the stack. This instruction is used when the if condition turns out to be false. The passed value 0 acts as the boolean false. The instructions at 3, 6, 7 handles the case when the if condition is true.
    8. ireturn returns the int value on the top of the stack.

    Another important thing to note here is the indexes given to the bytecode instructions. You can see that they aren’t incremented by one for every new instruction.

    Each number before an instruction indicates the index of its starting byte. And every bytecode is made of a one-byte opcode followed by zero or more operands.

    The opcodes are the commands like iload, iconst, etc. Depending on the size of the operands the size of the bytecode can vary from one byte to more. Hence, the gaps you see in the indexes of the instruction table. Here, the only two-byte instruction is ifne.

    In the bytecode of our SimpleClass.class file, we can see other instructions like invokespecial, invokeinterface, and invokestatic which are method invocation instructions. We’ll talk about those in the next part of this article series.

    In the meantime, if you want to understand what each instruction in your bytecode means, you can refer to this excellent Wikipedia article which provides an instructions listing.


    I hope you managed to learn a lot about how Java bytecode works in this article. In the next articles of the series, we’ll discuss more complex method invocation instructions and how JVM handles method invocation.

    With this clearer knowledge of Java bytecode and JVM, you’ll be able to write better code. You can even experiment with manipulating bytecode itself at the program’s runtime using libraries like ASM. But like I said, we’ll talk more about them later.

    External image

    Introduction to Java Bytecode You Didn’t Know You Needed was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

    source https://medium.com/swlh/introduction-to-java-bytecode-you-didnt-know-you-needed-22654cc34ab8?source=rss—-f5af2b715248—4
    View Full
  • Whenever any code is executed in JavaScript, it runs inside an Execution Context. The Global Execution Context is the very first Execution Context on the the call stack. The first thing JS Engine does is, it creates Global Execution Context and gives you two things:

    1. Global Object
    2. ‘this’ keyword

    Suppose if we create a user object with some properties and methods,

    on calling the login function , we can see that the this keyword is nothing but user object!

    Now suppose we attach any new method on user, and call it ,

    Then also the this keyword points to user object!

    Thus , the ‘this’ keyword is nothing but the object that the function is a property of!

    Now suppose we have a regular function ,

    on calling the function we can see that the this keyword points to global object.

    But that’s not the case with constructor function.

    Lets see this constructor function f2,

    Now if create an object of f2 and log it to the console we get,

    Thus we can say that , when dealing with regular functions ,the ‘this’ keyword points to the global object. But in case of constructor function ,it will point to that respective object itself.

    Now see the below object obj1,

    since the ‘anotherfunction’ is not really associated with obj1(it behaves like a regular function)directly, the ‘this’ keyword inside it points to global object.

    so in this case , how can we make that ‘this’ ,point to obj1?

    Well this can be achieved by arrow functions.

    Before arrow function, this was done by using bind function,

    This was all about ‘this’ keyword!!!

    Hope it helps!

    Happy learning!

    External image

    More About ‘this’ Keyword in JavaScript was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

    source https://medium.com/swlh/more-about-this-keyword-in-javascript-e966429ea637?source=rss—-f5af2b715248—4
    View Full
  • “All problems in computer science can be solved by another level of indirection” Butler Lampson

 not all I bet but probably a lot of them! What does ‘indirection’ here mean? It actually means the act of referencing something (an object etc) instead of the actual value itself. How does it come into play here? —While not the same meaning of simply setting up an abstraction layer, the key idea is there. Simply put, it may benefit us to set up some sort of intermediary reference instead of directly interacting with an object. In this case, an abstraction layer.

    The Dependency Inversion Principle (DIP) further emphasizes this point. It is a principle that encourages further abstraction such that higher-level modules are not dependent on lower-level modules. But I’m getting a little ahead of myself
 Before we talk about the specifics - a little background about DIP:

    What is DIP?

    DIP is one of the 5 SOLID principles promoted by Robert C. Martin.

    DIP is basically the idea that high-level modules/implementations should not depend on lower level modules/implementations. If that is the case — that our high-level modules depend on lower level modules means that there is an inversion of dependencies! Hence the name of the principle.

    The Idea behind DIP

    The idea behind DIP is to promote higher abstraction of lower-level modules such that should the lower level modules change, the higher-level modules should not be affected.

    Well, you may ask why should we not depend on lower level modules
 Is it really that bad?

    Well, I think the best way to explain this is through an example!

    Let’s say that you are creating an e-commerce application. On your e-commerce application, you have to install a payment gateway (If not how else are you going to earn $). There are multiple options such as Stripe and Paypal. So let’s say that you decide to use Stripe’s API first to implement the payment gateway on your application!

    And so look at the code below:

    public class Store {
    Stripe stripe;

    class Store() {
    this.stripe = new Stripe();
        public void sellItem() {
    class Stripe() {
        public void processpayment() {
    System.out.println(“Earned $10 through Stripe”);
    UML Class diagram of Store and Stripe relationship

    In this case, you are directly calling methods from the Stripe API itself. You may ask well but it works right?

    There’s an issue here — do you realise that the higher-level module (Store) is depending on the lower level module (Stripe payment gateway)?

    What if Stripe suddenly goes under maintenance but your store is still online! There are still many people who want your product and so you have to implement a new payment gateway (Paypal). However what is happening now? There is an issue — we have to change the code from our Store class which is a higher-level module.

    While this looks alright since it is a small class in this example, in a bigger application, there are definitely going to be multiple instances where our ‘stripe’ variable is used and the API is called. So that means we have to switch every single one of them. This could mean LOTS of time wastage, convoluted code and a huge amount of potential errors.

    Solving the problem

    So how do we avoid this problem? As mentioned above and to adhere to DIP, we should set up an abstraction layer!

    public class Store {
    PaymentGateway paymentGateway;
        class Store() {
        public void setPaymentGateway(PaymentGateway pg) {
    this.paymentGateway = pg;
        public void sellItem() {
    class Stripe() implements PaymentGateway {
        public void processpayment() {
    System.out.println(“Earned $10 through Stripe”);
    class Paypal() implements PaymentGateway {
        public void processpayment() {
    System.out.println(“Earned $10 through Paypal”);
    interface PaymentGateway {
        public void processpayment();
    UML class diagram for Store, PaymentGateway, Paypal, Stripe

    We set up an interface ‘PaymentGateway’ and we make our Stripe and Paypal classes implement this interface. An interface is basically a contract — when a class implements the interface, a class must use all the methods dictated by that interface. We also added a new method setPaymentGateway which allows us to reset our Payment Gateways if needed.

    Now if Stripe goes under maintenance and we want to switch to Paypal we can simply reset our Payment Gateway with setPaymentGateway! Simple!

    Thus as we can observe, our higher-level module (Store) is not directly dependent on any changes in lower level modules (Stripe or Paypal). Instead, it is dependent on an abstraction layer we have created. Now if Stripe goes under maintenance, we can switch payment gateways easily.

    Thus we have now fulfilled the DIP principle — there is no more inversion of dependencies — our store does not depend on the Stripe or Paypal API directly. Instead, our Store now depends on an abstraction layer.

    Further Notes

    Also, a rather confusing quote you may hear about DIP is

    Details should depend on Abstractions — not the other way around

    Well, what does this mean? In our class previously we had our Store class depend on the Details of the Stripe API — since should anything happen to the Stripe methods, we might have to change our code in the Store class directly. In other words, previously our Abstractions were dependent on the Details. This should not be the case!

    However, now, with the new PaymentGateway interface, the Details are dependent on the Abstractions. This is because the details of implementation in the Stripe and Paypal class are now dependent on the abstractions that we require — such as the ‘processpayment’ method. Now we can change the code in Stripe and Paypal accordingly depending on what further abstraction we need!

    I hope you have enjoyed this little explanation on DIP! Do leave any thoughts you have about it in the comments below!

    External image

    Dependency Inversion Principle: was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

    source https://medium.com/swlh/dependency-inversion-principle-5187ea8b3332?source=rss—-f5af2b715248—4
    View Full
  • 5 questions product managers should ask when shipping for feature parity

    Two women side by side holding iphonesPhoto by You X Ventures on Unsplash

    It’s common for startups to launch their product on one platform before expanding to another. For example a company could choose to launch their IOS app before an Android one or vice versa. Whichever platform comes first, product managers are then tasked with ensuring platforms reach feature parity before early adopters churn. Here are 5 questions PMs can ask to ruthlessly prioritise the parity backlog.

    Are users asking for it? Why?

    Once the product is live on your second platform product managers should be regularly speaking to this new segment of users. Surveys, interviews, and posts on online communities will give a good indication of how the product is doing and the features new users feel they are missing. When users ask for certain features, PMs need to dig deeper to understand the reason why they want that feature. Is it simply because it exists on another platform, or is there a missing feature that is preventing them from getting a job done? By understanding the why behind specific feature demands PMs can shortlist those that will deliver the highest value to the end user and reduce the risk of these early adopters churning.

    What does the data say?

    Whilst your qualitative data will help you pinpoint key parity themes, the quantitative data will allow product managers to quantify the impact of prioritising specific parity features over others. Product managers can analyse the usage and ROI of these features on their existing platform to help them understand whether it’s worth shipping in the second. For example, if a number of users feel they need a specific feature, but you analyse the data and realise it gets less engagement than another, which one should you prioritise? Similarly, if one feature directly impacts an existing business OKR compared to another, which should you ship first? Analysing the data allows PMs to prioritise features that will deliver the highest business impact. Additionally, this also exposes any features that get low engagement and should instead be removed from the original platform — a simpler (but not always risk averse) route to parity that reduces feature debt.

    Do these platform users behave differently?

    One caveat to looking at the data available for one platform to help prioritise the features you ship in the next is to be cognisant of the differences between the two platforms and how this can influence changes in user behaviour. For example Apple phones and Android phones are very different and this could influence how users interact with certain features on your product. Product managers should be regularly using the latest product on the latest platform so that they become embedded in the user journey and understand how this could influence differences in behaviour between platforms. Whether it highlights platform specific limitations or benefits, keeping this question and information top of mind will further inform the decision making and prioritisation of the next parity features.

    What’s the MVP?

    Time is of the essence when you’re trying to get platforms to feature parity which is why it’s useful to break down specific parity features into smaller, shippable increments of work. By working directly with designers and engineers and challenging them to think about what the MVP of larger features looks like, product managers can begin to break down bigger features into smaller iterations that can get prioritised for upcoming sprints and delivered to users much sooner. This approach also gives PMs the opportunity to get further validation to build out the feature fully at a time when they still have little data to lean on.

    Does it make sense to build this now or later?

    You also need to consider parity features alongside other development work that might be going on. The final question for PMs to consider is whether there is a better time for your engineers to work on this feature. What else is your team currently working on? What area of the code does this feature touch? Does it make sense to work on this now or later when there is more resource? Bringing engineers into this conversation and being willing to question the most pragmatic time for engineers to work on a specific parity feature is the final important piece when prioritising for feature parity and could save valuable development time in the future.

    There can be a lot of pressure to get platforms to feature parity before early users churn with the best approach to prioritisation being multifaceted. Questioning the why, the data, the timing and adopting an iterative mindset allows product managers to ruthlessly prioritise the parity backlog and focus the team on delivering the features that deliver the highest value first.

    External image

    Feature Parity: How to Ruthlessly Prioritise Your Backlog was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.

    source https://medium.com/swlh/feature-parity-how-to-ruthlessly-prioritise-your-backlog-c1301555ee47?source=rss—-f5af2b715248—4
    View Full
  • When R&B was R&B
    #CastMe #iAct #iTeach #CombatVeteran #ArmyStrong #IAmAnActor #entrepreneur #actorlife #teacherlife #film #method #passion #characteractor #blackrodneydangerfield #emote #savethearts #happiness #art #steadygrinding #alwaysdowhatyoulove #actingismylife #staysafe #staystrong #staypositive #doitforyoufirst #SAGAFTRA #HOUATXSAGAFTRA #SAGAFTRAMember #RIPGeraldLevert #RJAtkins


    View Full