5 promises that you as trader should not believe

Best Binary Options Brokers 2020:
  • Binarium

    The Best Binary Broker 2020!
    Perfect For Beginners!
    Free Trading Education!
    Free Demo Account!
    Get Your Sign-up Bonus Now!

  • Binomo

    Good Broker For Experienced Traders!


8 Reasons You Should Always Live Up To Every Single Promise You Make

“We must not promise what we ought not, lest we be called on to perform what he cannot” Abraham Lincoln

Remember the last time you made yourself a promise you didn’t keep? How did that feel? Did it niggle at you? Did it sap your energy? Leave you feeling depleted? Here are 8 reasons why you should lie up to the promises you make.

1. Unfulfilled promises leave open loops

When you make a promise to yourself and you don’t keep it, a part of you is painfully aware that it’s unfulfilled. It registers as an open loop in the back of your mind. And that part niggles at you. On a deep subsonscious level it eats away at you. Dealing with feelings saps your energy.

Why? Because promises made to yourself come with a certain emotional attachement. An attachement which leads to unpleasant consequences when unfulfilled. You feel discomfort, guilt, a sense of uneasiness. And these feelings make it less likely that you’ll keep your next promise. This leads to a vicious cycle of broken promises. And we all know how much that affects your ability to suceed.

The solution? Don’t make commitments to yourself that you’re not sure you will be able to fulfill. Be selective about promises you make. Only make promises that you know you can follow through on.

2. Fulfilled promises are great for motivation and success

Broken promises can lead to a vicious cycle of failure. But the reverse is also true. A fulfilled promise builds a sense of self efficacy which is one of the greatest motivators. Think back to a time you made a promise you would get something done by a certain date and you followed through on it.

How’d it feel? Pretty good I bet. It works both ways. When you make a commitment to yourself and fulfill that commitment, it builds a sense of self-esteem. A sense of self efficacy. So how do you use this information to increase your chances of succcess?

The next time you make a committment, set aside time for completing the task in your calendar. This will force you to be realistic about what you can achieve in light of all your other committments. This is a very effective way to be realistic about what you can take on. Stick to this one rule and you’ll go a long way towards building a virtuous cycle that feeds success.

3. Broken promises impact you as much as the person you make the promise to.

We’re are social creatures. When you make a commitment to someone and don’t keep it, there’s a distinct feeling of having let that person down. You know the feeling I’m talking about. It’s like there’s this pact you made with that person which you broke. Not cool.

A trail of unfulfiled promises to others leaves you feeling as disappointed in yourself as it does the other person. Break a promise to someone else and you’ll be left with this lingering feeling of dissatisfaction. You may not realise it consciously but on some level you’ll question your own integrity. It’ll impact your self belief and your chances of long term success.

Just being aware of this fact is enough stop you from making a promise to someone that you aren’t likely to keep. You’ll sleep better and feel lighter.

4. Living up to every single promise builds trust in yourself

When someone breaks a promise to you how does that impact your level of trust in them? You trust them less right? The same goes for promises you make yourself. When you don’t fulfill those promises, you lose faith in yourself and your ability to succeed at achieving your goals.

Best Binary Options Brokers 2020:
  • Binarium

    The Best Binary Broker 2020!
    Perfect For Beginners!
    Free Trading Education!
    Free Demo Account!
    Get Your Sign-up Bonus Now!

  • Binomo

    Good Broker For Experienced Traders!

So, how do you keep every single promise you make yourself? Use a minimalistic approach to promises. Treat them like sliver bullets. Say a thousand nos for every yes. If I’m starting to sound a bit repetitive then that’s good. It means you’ve been paying attention. I don’t think the point about being selective when making committments can be emphasised enough.

Choose your committments carefully. This will determine how you’re going to spend your time. Commit to fewer things that you know you can accomplish and that will have maximum impact. This will help you build faith in your own abilities like nothing else!

5. Living up to every promise teaches you to apply the Pareto principle

Ever heard of the Pareto principle? The Pareto principle states that approximately 20% of the reference yields 80% of the results. It makes sense to focus on that 20%. And the best way to focus only on the 20% is saying no to everything else that you believe doesn’t fall into that 20%. You could even take this one step further and apply the Pareto principle to the 20% implying that 4% of your efforts will yield 64% of your results.

The best way to do get good at applying the Pareto principle is through practice. A good way to do this to keep a daily journal. At the end of each day think back to the things you focused on and which of those things delivered the biggest results. Get clear on what’s working for you and make a conscious committment to focus on those things the next day. This ritual works well when done at the end of each month too.

6. Keeping your promises helps you to find a peaceful balance

Staying committed to delivering on your promises imposes certain discipline in your life. It helps you to embrace minimalism and when it comes to activities that you take on. Hopefully this will extend to a minimalistic attitude when it comes to possessions too.

Here’s the plain truth: the less stuff (read “noise”) you have whirling around in your head, the more peaceful and balanced you’re going to feel. Try it. Try focusing on only one thing at a time. Refuse to give into the urge to multitask which is not only unproductive but overwhelming.

Try getting rid of all those clothes you haven’t used in a year. Or try throwing away some of that junk that’s been collecting in your garage. Do this for a week and I can assure you that you’ll be feeling a lot lighter at the end of it.

7. Fulfilling promises keeps you on track to achieve your life goals.

It’s easy to keep a promise when you’re feeling motivated. But keeping a promise when you don’t feel like it? That’s a lot harder. So why do it? Because your feelings are as stable as a leaf in a thunderstorm! Don’t get me wrong. Feelings are important and they definitely shouldn’t be ignored. But that doesen’t mean you react to them everytime they pop up.

Feelings are transient. Being reactive to your feelings (as opposed to watching them mindfully), doesn’t serve you or your long term success. Using a mindful approach where you watch your feelings without reacting to them, makes you far more likely to keep your promises regardless of how you feel. And that’s where the power is!

When you keep promises to yourself no matter what, you’re playing to the orchestra of life. You’re working within the parameters of a disciplined routine – much like each musical instrument must play in tune for the orchestra to work. Every instrument must fulfil its purpose.

So the next time you feel the urge to run from a committment you’ve made, think to yourself that this is just a feeling. You don’t have to react to your urge to run from the task. Instead accept that you have the urge to run and go ahead and complete the task anyway. I guarantee you’ll feel better after you’ve completed it.

8. A string of unfulfilled promises can damage your self-esteem

Unfulfilled promises create an emotional reaction of shame and embarrassment of disappointment. Do this over and over again, and you’ll put your self-esteem on the line.

The solution? You guessed it! Be selective about promises you make so you can live up to your word. Use your word to generate trust in other’s and in yourself. I’m not saying it’s always easy. Fulfilling promises can sometimes be very challenging but that’s what builds your sense of integrity and your self-esteem.

Your word is your legacy. Ultimately when you’ve done your dash on planet earth, and you’re approaching the end of your life, what do you think is going to matter most? Your bank account? Your possessions? Or the relationships you’ve built and the impact you’ve had on the world?

Money and possessions make life a lot more comfortable. But in the final reckoning, the quality of the relationships we’ve cultivated and the difference we’ve made to the world are going to matter most. What’s it going to be for you?

We have a problem with promises

By: Nolan Lawson
Published: 18 May 2020

Fellow JavaScripters, it’s time to admit it: we have a problem with promises.

No, not with promises themselves. Promises, as defined by the A+ spec, are awesome.

The big problem, which has revealed itself to me over the course of the past year, as I’ve watched numerous programmers struggle with the PouchDB API and other promise-heavy APIs, is this:

Many of us are using promises without really understanding them.

If you find that hard to believe, consider this puzzle I recently posted to Twitter:

Q: What is the difference between these four promises?

If you know the answer, then congratulations: you’re a promises ninja. You have my permission to stop reading this blog post.

For the other 99.99% of you, you’re in good company. Nobody who responded to my tweet could solve it, and I myself was surprised by the answer to #3. Yes, even though I wrote the quiz!

The answers are at the end of this post, but first, I’d like to explore why promises are so tricky in the first place, and why so many of us – novices and experts alike – get tripped up by them. I’m also going to offer what I consider to be the singular insight, the one weird trick, that makes promises a cinch to understand. And yes, I really do believe they’re not so hard after that!

But to start with, let’s challenge some common assumptions about promises.

Wherefore promises?

If you read the literature on promises, you’ll often find references to the pyramid of doom, with some horrible callback-y code that steadily stretches toward the right side of the screen.

Promises do indeed solve this problem, but it’s about more than just indentation. As explained in the brilliant talk “Redemption from Callback Hell”, the real problem with callbacks it that they deprive us of keywords like return and throw . Instead, our program’s entire flow is based on side effects: one function incidentally calling another one.

And in fact, callbacks do something even more sinister: they deprive us of the stack, which is something we usually take for granted in programming languages. Writing code without a stack is a lot like driving a car without a brake pedal: you don’t realize how badly you need it, until you reach for it and it’s not there.

The whole point of promises is to give us back the language fundamentals we lost when we went async: return , throw , and the stack. But you have to know how to use promises correctly in order to take advantage of them.

Rookie mistakes

Some people try to explain promises as a cartoon, or in a very noun-oriented way: “Oh, it’s this thing you can pass around that represents an asynchronous value.”

I don’t find such explanations very helpful. To me, promises are all about code structure and flow. So I think it’s better to just go over some common mistakes and show how to fix them. I call these “rookie mistakes” in the sense of, “you’re a rookie now, kid, but you’ll be a pro soon.”

Quick digression: “promises” mean a lot of different things to different people, but for the purposes of this article, I’m only going to talk about the official spec, as exposed in modern browsers as window.Promise . Not all browsers have window.Promise though, so for a good polyfill, check out the cheekily-named Lie, which is about the smallest spec-compliant library out there.

Rookie mistake #1: the promisey pyramid of doom

Looking at how people use PouchDB, which has a largely promise-based API, I see a lot of poor promise patterns. The most common bad practice is this one:

Yes, it turns out you can use promises as if they were callbacks, and yes, it’s a lot like using a power sander to file your nails, but you can do it.

And if you think this sort of mistake is only limited to absolute beginners, you’ll be surprised to learn that I actually took the above code from the official BlackBerry developer blog! Old callback habits die hard. (And to the developer: sorry to pick on you, but your example is instructive.)

A better style is this one:

This is called composing promises, and it’s one of the great superpowers of promises. Each function will only be called when the previous promise has resolved, and it’ll be called with that promise’s output. More on that later.

Rookie mistake #2: WTF, how do I use forEach() with promises?

This is where most people’s understanding of promises starts to break down. As soon as they reach for their familiar forEach() loop (or for loop, or while loop), they have no idea how to make it work with promises. So they write something like this:

What’s the problem with this code? The problem is that the first function is actually returning undefined , meaning that the second function isn’t waiting for db.remove() to be called on all the documents. In fact, it isn’t waiting on anything, and can execute when any number of docs have been removed!

This is an especially insidious bug, because you may not notice anything is wrong, assuming PouchDB removes those documents fast enough for your UI to be updated. The bug may only pop up in the odd race conditions, or in certain browsers, at which point it will be nearly impossible to debug.

The TLDR of all this is that forEach() / for / while are not the constructs you’re looking for. You want Promise.all() :

What’s going on here? Basically Promise.all() takes an array of promises as input, and then it gives you another promise that only resolves when every one of those other promises has resolved. It is the asynchronous equivalent of a for-loop.

Promise.all() also passes an array of results to the next function, which can get very useful, for instance if you are trying to get() multiple things from PouchDB. The all() promise is also rejected if any one of its sub-promises are rejected, which is even more useful.

Rookie mistake #3: forgetting to add .catch()

This is another common mistake. Blissfully confident that their promises could never possibly throw an error, many developers forget to add a .catch() anywhere in their code. Unfortunately this means that any thrown errors will be swallowed, and you won’t even see them in your console. This can be a real pain to debug.

To avoid this nasty scenario, I’ve gotten into the habit of simply adding the following code to my promise chains:

Even if you never expect an error, it’s always prudent to add a catch() . It’ll make your life easier, if your assumptions ever turn out to be wrong.

Rookie mistake #4: using “deferred”

This is a mistake I see all the time, and I’m reluctant to even repeat it here, for fear that, like Beetlejuice, merely invoking its name will summon more instances of it.

In short, promises have a long and storied history, and it took the JavaScript community a long time to get them right. In the early days, jQuery and Angular were using this “deferred” pattern all over the place, which has now been replaced with the ES6 Promise spec, as implemented by “good” libraries like Q, When, RSVP, Bluebird, Lie, and others.

So if you are writing that word in your code (I won’t repeat it a third time!), you are doing something wrong. Here’s how to avoid it.

First off, most promise libraries give you a way to “import” promises from third-party libraries. For instance, Angular’s $q module allows you to wrap non- $q promises using $q.when() . So Angular users can wrap PouchDB promises this way:

Another strategy is to use the revealing constructor pattern, which is useful for wrapping non-promise APIs. For instance, to wrap a callback-based API like Node’s fs.readFile() , you can simply do:

Done! We have defeated the dreaded def. Aha, caught myself. :)

For more about why this is an anti-pattern, check out the Bluebird wiki page on promise anti-patterns.

Rookie mistake #5: using side effects instead of returning

What’s wrong with this code?

Okay, this is a good point to talk about everything you ever need to know about promises.

Seriously, this is the one weird trick that, once you understand it, will prevent all of the errors I’ve been talking about. You ready?

As I said before, the magic of promises is that they give us back our precious return and throw . But what does this actually look like in practice?

Every promise gives you a then() method (or catch() , which is just sugar for then(null, . ) ). Here we are inside of a then() function:

What can we do here? There are three things:

  1. return another promise
  2. return a synchronous value (or undefined )
  3. throw a synchronous error

That’s it. Once you understand this trick, you understand promises. So let’s go through each point one at a time.

1. Return another promise

This is a common pattern you see in the promise literature, as in the “composing promises” example above:

Notice that I’m return ing the second promise – that return is crucial. If I didn’t say return , then the getUserAccountById() would actually be a side effect, and the next function would receive undefined instead of the userAccount .

2. Return a synchronous value (or undefined)

Returning undefined is often a mistake, but returning a synchronous value is actually an awesome way to convert synchronous code into promisey code. For instance, let’s say we have an in-memory cache of users. We can do:

Isn’t that awesome? The second function doesn’t care whether the userAccount was fetched synchronously or asynchronously, and the first function is free to return either a synchronous or asynchronous value.

Unfortunately, there’s the inconvenient fact that non-returning functions in JavaScript technically return undefined , which means it’s easy to accidentally introduce side effects when you meant to return something.

For this reason, I make it a personal habit to always return or throw from inside a then() function. I’d recommend you do the same.

3. Throw a synchronous error

Speaking of throw , this is where promises can get even more awesome. Let’s say we want to throw a synchronous error in case the user is logged out. It’s quite easy:

Our catch() will receive a synchronous error if the user is logged out, and it will receive an asynchronous error if any of the promises are rejected. Again, the function doesn’t care whether the error it gets is synchronous or asynchronous.

This is especially useful because it can help identify coding errors during development. For instance, if at any point inside of a then() function, we do a JSON.parse() , it might throw a synchronous error if the JSON is invalid. With callbacks, that error would get swallowed, but with promises, we can simply handle it inside our catch() function.

Advanced mistakes

Okay, now that you’ve learned the single trick that makes promises dead-easy, let’s talk about the edge cases. Because of course, there are always edge cases.

These mistakes I’d classify as “advanced,” because I’ve only seen them made by programmers who are already fairly adept with promises. But we’re going to need to discuss them, if we want to be able to solve the puzzle I posed at the beginning of this post.

Advanced mistake #1: not knowing about Promise.resolve()

As I showed above, promises are very useful for wrapping synchronous code as asynchronous code. However, if you find yourself typing this a lot:

You can express this more succinctly using Promise.resolve() :

This is also incredibly useful for catching any synchronous errors. It’s so useful, that I’ve gotten in the habit of beginning nearly all of my promise-returning API methods like this:

Just remember: any code that might throw synchronously is a good candidate for a nearly-impossible-to-debug swallowed error somewhere down the line. But if you wrap everything in Promise.resolve() , then you can always be sure to catch() it later.

Similarly, there is a Promise.reject() that you can use to return a promise that is immediately rejected:

Advanced mistake #2: then(resolveHandler).catch(rejectHandler) isn’t exactly the same as then(resolveHandler, rejectHandler)

I said above that catch() is just sugar. So these two snippets are equivalent:

However, that doesn’t mean that the following two snippets are equivalent:

If you’re wondering why they’re not equivalent, consider what happens if the first function throws an error:

As it turns out, when you use the then(resolveHandler, rejectHandler) format, the rejectHandler won’t actually catch an error if it’s thrown by the resolveHandler itself.

For this reason, I’ve made it a personal habit to never use the second argument to then() , and to always prefer catch() . The exception is when I’m writing asynchronous Mocha tests, where I might write a test to ensure that an error is thrown:

Speaking of which, Mocha and Chai are a lovely combination for testing promise APIs. The pouchdb-plugin-seed project has some sample tests that can get you started.

Advanced mistake #3: promises vs promise factories

Let’s say you want to execute a series of promises one after the other, in a sequence. That is, you want something like Promise.all() , but which doesn’t execute the promises in parallel.

You might naïvely write something like this:

Unfortunately, this will not work the way you intended. The promises you pass in to executeSequentially() will still execute in parallel.

The reason this happens is that you don’t want to operate over an array of promises at all. Per the promise spec, as soon as a promise is created, it begins executing. So what you really want is an array of promise factories:

I know what you’re thinking: “Who the hell is this Java programmer, and why is he talking about factories?” A promise factory is very simple, though – it’s just a function that returns a promise:

Why does this work? It works because a promise factory doesn’t create the promise until it’s asked to. It works the same way as a then function – in fact, it’s the same thing!

If you look at the executeSequentially() function above, and then imagine myPromiseFactory being substituted inside of result.then(. ) , then hopefully a light bulb will click in your brain. At that moment, you will have achieved promise enlightenment.

Advanced mistake #4: okay, what if I want the result of two promises?

Often times, one promise will depend on another, but we’ll want the output of both promises. For instance:

Wanting to be good JavaScript developers and avoid the pyramid of doom, we might just store the user object in a higher-scoped variable:

This works, but I personally find it a bit kludgey. My recommended strategy: just let go of your preconceptions and embrace the pyramid:

. at least, temporarily. If the indentation ever becomes an issue, then you can do what JavaScript developers have been doing since time immemorial, and extract the function into a named function:

As your promise code starts to get more complex, you may find yourself extracting more and more functions into named functions. I find this leads to very aesthetically-pleasing code, which might look like this:

That’s what promises are all about.

Advanced mistake #5: promises fall through

Finally, this is the mistake I alluded to when I introduced the promise puzzle above. This is a very esoteric use case, and it may never come up in your code, but it certainly surprised me.

What do you think this code prints out?

If you think it prints out bar , you’re mistaken. It actually prints out foo !

The reason this happens is because when you pass then() a non-function (such as a promise), it actually interprets it as then(null) , which causes the previous promise’s result to fall through. You can test this yourself:

Add as many then(null) s as you want; it will still print foo .

This actually circles back to the previous point I made about promises vs promise factories. In short, you can pass a promise directly into a then() method, but it won’t do what you think it’s doing. then() is supposed to take a function, so most likely you meant to do:

This will print bar , as we expected.

So just remind yourself: always pass a function into then() !

Solving the puzzle

Now that we’ve learned everything there is to know about promises (or close to it!), we should be able to solve the puzzle I originally posed at the start of this post.

Here is the answer to each one, in graphical format so you can better visualize it:

Puzzle #1

Puzzle #2

Puzzle #3

Puzzle #4

If these answers still don’t make sense, then I encourage you to re-read the post, or to define the doSomething() and doSomethingElse() methods and try it out yourself in your browser.

Clarification: for these examples, I’m assuming that both doSomething() and doSomethingElse() return promises, and that those promises represent something done outside of the JavaScript event loop (e.g. IndexedDB, network, setTimeout ), which is why they’re shown as being concurrent when appropriate. Here’s a JSBin to demonstrate.

And for more advanced uses of promises, check out my promise protips cheat sheet.

Final word about promises

Promises are great. If you are still using callbacks, I strongly encourage you to switch over to promises. Your code will become smaller, more elegant, and easier to reason about.

And if you don’t believe me, here’s proof: a refactor of PouchDB’s map/reduce module to replace callbacks with promises. The result: 290 insertions, 555 deletions.

Incidentally, the one who wrote that nasty callback code was… me! So this served as my first lesson in the raw power of promises, and I thank the other PouchDB contributors for coaching me along the way.

That being said, promises aren’t perfect. It’s true that they’re better than callbacks, but that’s a lot like saying that a punch in the gut is better than a kick in the teeth. Sure, one is preferable to the other, but if you had a choice, you’d probably avoid them both.

While superior to callbacks, promises are still difficult to understand and error-prone, as evidenced by the fact that I felt compelled to write this blog post. Novices and experts alike will frequently mess this stuff up, and really, it’s not their fault. The problem is that promises, while similar to the patterns we use in synchronous code, are a decent substitute but not quite the same.

In truth, you shouldn’t have to learn a bunch of arcane rules and new APIs to do things that, in the synchronous world, you can do perfectly well with familiar patterns like return , catch , throw , and for-loops. There shouldn’t be two parallel systems that you have to keep straight in your head at all times.

Awaiting async/await

That’s the point I made in “Taming the asynchronous beast with ES7”, where I explored the ES7 async / await keywords, and how they integrate promises more deeply into the language. Instead of having to write pseudo-synchronous code (with a fake catch() method that’s kinda like catch , but not really), ES7 will allow us to use the real try / catch / return keywords, just like we learned in CS 101.

This is a huge boon to JavaScript as a language. Because in the end, these promise anti-patterns will still keep cropping up, as long as our tools don’t tell us when we’re making a mistake.

To take an example from JavaScript’s history, I think it’s fair to say that JSLint and JSHint did a greater service to the community than JavaScript: The Good Parts, even though they effectively contain the same information. It’s the difference between being told exactly the mistake you just made in your code, as opposed to reading a book where you try to understand other people’s mistakes.

The beauty of ES7 async / await is that, for the most part, your mistakes will reveal themselves as syntax/compiler errors rather than subtle runtime bugs. Until then, though, it’s good to have a grasp of what promises are capable of, and how to use them properly in ES5 and ES6.

So while I recognize that, like JavaScript: The Good Parts, this blog post can only have a limited impact, it’s hopefully something you can point people to when you see them making these same mistakes. Because there are still way too many of us who just need to admit: “I have a problem with promises!”

Update: it’s been pointed out to me that Bluebird 3.0 will print out warnings that can prevent many of the mistakes I’ve identified in this post. So using Bluebird is another great option while we wait for ES7!

5-Hour Rule: If you’re not spending 5 hours per week learning, you’re being irresponsible

“In my whole life, I have known no wise people (over a broad subject matter area) who didn’t read all the time — none. Zero.”
— Charlie Munger, Self-made billionaire & Warren Buffett’s longtime business partner

Why did the busiest person in the world, former president Barack Obama, read an hour a day while in office?

Why has the best investor in history, Warren Buffett, invested 80% of his time in reading and thinking throughout his career?

Why has the world’s richest person, Bill Gates, read a book a week during his career? And why has he taken a yearly two-week reading vacation throughout his entire career?

Why do the world’s smartest and busiest people find one hour a day for deliberate learning (the 5-hour rule), while others make excuses about how busy they are?

What do they see that others don’t?

The answer is simple: Learning is the single best investment of our time that we can make. Or as Benjamin Franklin said, “An investment in knowledge pays the best interest.”

This insight is fundamental to succeeding in our knowledge economy, yet few people realize it. Luckily, once you do understand the value of knowledge, it’s simple to get more of it. Just dedicate yourself to constant learning.

Knowledge is the new money

“Intellectual capital will always trump financial capital.” — Paul Tudor Jones, self-made billionaire entrepreneur, investor, and philanthropist

We spend our lives collecting, spending, lusting after, and worrying about money — in fact, when we say we “don’t have time” to learn something new, it’s usually because we are feverishly devoting our time to earning money, but something is happening right now that’s changing the relationship between money and knowledge.

We are at the beginning of a period of what renowned futurist Peter Diamandis calls rapid demonetization, in which technology is rendering previously expensive products or services much cheaper — or even free.

This chart from Diamandis’ book Abundance shows how we’ve demonetized $900,000 worth of products and services you might have purchased between 1969 and 1989.

This demonetization will accelerate in the future. Automated vehicle fleets will eliminate one of our biggest purchases: a car. Virtual reality will make expensive experiences, such as going to a concert or playing golf, instantly available at much lower cost. While the difference between reality and virtual reality is almost incomparable at the moment, the rate of improvement of VR is exponential.

While education and health care costs have risen, innovation in these fields will likely lead to eventual demonetization as well. Many higher educational institutions, for example, have legacy costs to support multiple layers of hierarchy and to upkeep their campuses. Newer institutions are finding ways to dramatically lower costs by offering their services exclusively online, focusing only on training for in-demand, high-paying skills, or having employers who recruit students subsidize the cost of tuition.

Finally, new devices and technologies, such as CRISPR, the XPrize Tricorder, better diagnostics via artificial intelligence, and reduced cost of genomic sequencing will revolutionize the healthcare system. These technologies and other ones like them will dramatically lower the average cost of healthcare by focusing on prevention rather than cure and management.

While goods and services are becoming demonetized, knowledge is becoming increasingly valuable.

“The central event of the twentieth century is the overthrow of matter. In technology, economics, and the politics of nations, wealth in the form of physical resources is steadily declining in value and significance. The powers of mind are everywhere ascendant over the brute force of things.” —George Gilder (technology thinker)

Perhaps the best example of the rising value of certain forms of knowledge is the self-driving car industry. Sebastian Thrun, founder of Google X and Google’s self-driving car team, gives the example of Uber paying $700 million for Otto, a six-month-old company with 70 employees, and of GM spending $1 billion on their acquisition of Cruise. He concludes that in this industry, “The going rate for talent these days is $10 million.”

That’s $10 million per skilled worker, and while that’s the most stunning example, it’s not just true for incredibly rare and lucrative technical skills. People who identify skills needed for future jobs — e.g., data analyst, product designer, physical therapist — and quickly learn them are poised to win.

Those who work really hard throughout their career but don’t take time out of their schedule to constantly learn will be the new “at-risk” group. They risk remaining stuck on the bottom rung of global competition, and they risk losing their jobs to automation, just as blue-collar workers did between 2000 and 2020 when robots replaced 85 percent of manufacturing jobs.

People at the bottom of the economic ladder are being squeezed more and compensated less, while those at the top have more opportunities and are paid more than ever before. The irony is that the problem isn’t a lack of jobs. Rather, it’s a lack of people with the right skills and knowledge to fill the jobs.

An Atlantic article captures the paradox: “Employers across industries and regions have complained for years about a lack of skilled workers, and their complaints are borne out in U.S. employment data. In July [2020], the number of job postings reached its highest level ever, at 5.8 million, and the unemployment rate was comfortably below the post-World War II average. But, at the same time, over 17 million Americans are either unemployed, not working but interested in finding work, or doing part-time work but aspiring to full-time work.”

In short, we can see how at a fundamental level knowledge is gradually becoming its own important and unique form of currency. In other words, knowledge is the new money. Similar to money, knowledge often serves as a medium of exchange and store of value.

But, unlike money, when you use knowledge or give it away, you don’t lose it. In fact, it’s the opposite. The more you give away knowledge, the more you:

  • Remember it
  • Understand it
  • Connect it to other ideas in your head
  • Build your identity as a role model for that knowledge

Transferring knowledge anywhere in the world is free and instant. Its value compounds over time faster than money. It can be converted into many things, including things that money can’t buy, such as authentic relationships and high levels of subjective well-being. It helps you accomplish your goals faster and better. It’s fun to acquire. It makes your brain work better. It expands your vocabulary, making you a better communicator. It helps you think bigger and beyond your circumstances. It connects you to communities of people you didn’t even know existed. It puts your life in perspective by essentially helping you live many lives in one life through other people’s experiences and wisdom.

Former President Obama perfectly explains why he was so committed to reading during his Presidency in a recent New York Times interview:

“At a time when events move so quickly and so much information is transmitted,” he said, reading gave him the ability to occasionally “slow down and get perspective” and “the ability to get in somebody else’s shoes.” These two things, he added, “have been invaluable to me. Whether they’ve made me a better president I can’t say. But what I can say is that they have allowed me to sort of maintain my balance during the course of eight years, because this is a place that comes at you hard and fast and doesn’t let up.”

6 essentials skills to master the new knowledge economy

“The illiterate of the 21st century will not be those who cannot read and write, but those who cannot learn, unlearn, and relearn.” — Alvin Toffler

So, how do we learn the right knowledge and have it pay off for us? The six points below serve as a framework to help you begin to answer this question. I also created an in-depth webinar on Learning How To Learn that you can watch for free.

  1. Identify valuable knowledge at the right time. The value of knowledge isn’t static. It changes as a function of how valuable other people consider it and how rare it is. As new technologies mature and reshape industries, there is often a deficit of people with the needed skills, which creates the potential for high compensation. Because of the high compensation, more people are quickly trained, and the average compensation decreases.
  2. Learn and master that knowledge quickly. Opportunity windows are temporary in nature. Individuals must take advantage of them when they see them. This means being able to learn new skills quickly. After reading thousands of books, I’ve found that understanding and using mental models is one of the most universal skills that EVERYONE should learn. It provides a strong foundation of knowledge that applies across every field. So when you jump into a new field, you have preexisting knowledge you can use to learn faster.
  3. Communicate the value of your skills to others. People with the same skills can command wildly different salaries and fees based on how well they’re able to communicate and persuade others. This ability convinces others that the skills you have are valuable is a “multiplier skill.” Many people spend years mastering an underlying technical skill and virtually no time mastering this multiplier skill.
  4. Convert knowledge into money and results. There are many ways to transform knowledge into value in your life. A few examples include finding and getting a job that pays well, getting a raise, building a successful business, selling your knowledge as a consultant, and building your reputation by becoming a thought leader.
  5. Learn how to financially invest in learning to get the highest return. Each of us needs to find the right “portfolio” of books, online courses, and certificate/degree programs to help us achieve our goals within our budget. To get the right portfolio, we need to apply financial terms — such as return on investment, risk management, hurdle rate, hedging, and diversification — to our thinking on knowledge investment.
  6. Master the skill oflearning how to learn . Doing so exponentially increases the value of every hour we devote to learning (our learning rate). Our learning rate determines how quickly our knowledge compounds over time. Consider someone who reads and retains one book a week versus someone who takes 10 days to read a book. Over the course of a year, a 30% difference compounds to one person reading 85 more books.

To shift our focus from being overly obsessed with money to a more savvy and realistic quest for knowledge, we need to stop thinking that we only acquire knowledge from 5 to 22 years old, and that then we can get a job and mentally coast through the rest of our lives if we work hard. To survive and thrive in this new era, we must constantly learn.

Working hard is the industrial era approach to getting ahead. Learning hard is the knowledge economy equivalent.

Just as we have minimum recommended dosages of vitamins, steps per day, and minutes of aerobic exercise for maintaining physical health, we need to be rigorous about the minimum dose of deliberate learning that will maintain our economic health. The long-term effects of intellectual complacency are just as insidious as the long-term effects of not exercising, eating well, or sleeping enough. Not learning at least 5 hours per week (the 5-hour rule) is the smoking of the 21st century and this article is the warning label.

Don’t be lazy. Don’t make excuses. Just get it done.

“Live as if you were to die tomorrow. Learn as if you were to live forever.” — Mahatma Gandhi

Before his daughter was born, successful entrepreneur Ben Clarke focused on deliberate learning every day from 6:45 a.m. to 8:30 a.m. for five years (2,000+ hours), but when his daughter was born, he decided to replace his learning time with daddy-daughter time. This is the point at which most people would give up on their learning ritual.

Instead of doing that, Ben decided to change his daily work schedule. He shortened the number of hours he worked on his to do list in order to make room for his learning ritual. Keep in mind that Ben oversees 200+ employees at his company, The Shipyard, and is always busy. In his words, “By working less and learning more, I might seem to get less done in a day, but I get dramatically more done in my year and in my career.” This wasn’t an easy decision by any means, but it reflects the type of difficult decisions that we all need to start making. Even if you’re just an entry-level employee, there’s no excuse. You can find mini learning periods during your downtimes (commutes, lunch breaks, slow times). Even 15 minutes per day will add up to nearly 100 hours over a year. Time and energy should not be excuses. Rather, they are difficult, but overcomable challenges. By being one of the few people who rises to this challenge, you reap that much more in reward.

We often believe we can’t afford the time it takes, but the opposite is true: None of us can afford not to learn.

Learning is no longer a luxury; it’s a necessity.

Start your learning ritual today with these three steps

The busiest, most successful people in the world find at least an hour to learn EVERY DAY. So can you!

Just three steps are needed to create your own learning ritual:

  1. Find the time for reading and learning even if you are really busy and overwhelmed.
  2. Stay consistent on using that “found” time without procrastinating or falling prey to distraction.
  3. Increase the results you receive from each hour of learning by using proven hacks that help you remember and apply what you learn.

Over the last three years, I’ve researched how top performers find the time, stay consistent, and get more results. There was too much information for one article, so I spent dozens of hours and created a free masterclass to help you master your learning ritual too!

Best Binary Options Brokers 2020:
  • Binarium

    The Best Binary Broker 2020!
    Perfect For Beginners!
    Free Trading Education!
    Free Demo Account!
    Get Your Sign-up Bonus Now!

  • Binomo

    Good Broker For Experienced Traders!

Like this post? Please share to your friends:
How To Do Binary Options Trading?
Leave a Reply

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: