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.
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.
- NicK 05-Dec-2020 09:48 PM
Automating the workforce is the main challenge for established companies as well as startups.
Continue reading on The Startup Â»
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)
https://www.instagram.com/p/CIa-8asnkzS/?igshid=s4516nf8acm7
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:
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.
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.
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.
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.
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.
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.
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
The Probability Density function of Gamma distribution is
The mean of Gamma distribution is
The Variance of Gamma distribution is
Summary
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Â .
Understanding Probability Distribution was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.
Machine Learning is making the computer learn from studying data and statistics
Continue reading on The Startup Â»
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 Â»
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.
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.
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.
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?
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.
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.
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
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.
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);
Code:
0: iload_1
1: iconst_2
2: irem
3: ifne 10
6: iconst_1
7: goto 11
10: iconst_0
11: ireturn
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.
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.
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:
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!
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!
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.
âAll problems in computer science can be solved by another level of indirectionâ ButlerÂ Lampson
WellâŠ 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:
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 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() {
this.stripe.processpayment();
}
}
class Stripe() {
public void processpayment() {
System.out.println(âEarned $10 through Stripeâ);
}
}
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.
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() {
this.paymentGateway.processpayment();
}
}
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();
}
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.
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!
Dependency Inversion Principle: was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.
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.
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.
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.
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.
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.
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.
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.
One small change to my recruiting method tripled the willing participants among a tough B2B audience
Continue reading on The Startup Â»
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
https://www.instagram.com/p/CIa4SpfjMWU/?igshid=14384s0nwxu57
No two individuals are alike. Focus on each otherâs differences and use them to complement strategic plans in the long-run. Thank you, @dharmeshpot for this reminder!