Many of us have followed the dramatic rises and precipitous falls of bitcoin, and cryptocurrencies in general, over the past few years. Some may have written them off entirely after 80% declines in 2018, only to see them roar back into investors’ collective consciousness in 2020.

Certainly sentiment has shifted over a short two years—more institutional investors are taking a hard look at crypto and previous naysayers have softened their view. This all leads to one question: How much cryptocurrency should I own?

Math to the rescue.

It goes without saying that this is a hard question to answer. But, we can borrow a page from modern quantitative finance to help us arrive at a potential answer.

For years, Wall Street “quants” have used a mathematical framework to manage their portfolios called the Black-Litterman model. Yes, the “Black” here is the same one from the famous Black-Scholes options pricing formula, Fischer Black. And “Litterman” is Robert Litterman, a long-time Goldman Sachs quant.

Without getting into too much detail, the model starts with a neutral, “equilibrium” portfolio and provides a mathematical formula for increasing your holdings based on your view of the world. What’s amazing is that it incorporates not just your estimate about how an investment might grow, but also your confidence in that estimate, and translates those inputs into a specific portfolio allocation.

Your starting point: 0.50%

The Black-Litterman model uses the global market portfolio—all the asset holdings in the world—as its starting point for building a portfolio. This means that, if you don’t have any other views on what investments might perform better or worse, this is the portfolio you should consider holding.

In early 2021, the global market for stocks totaled $95 trillion and the global bonds market reached $105 trillion. The cryptocurrency market as a whole was valued at roughly $1 trillion. This means that cryptocurrency represents 0.50% of the global market portfolio.

The Global Market Portfolio In Early 2021

Source: Betterment sourced the above cryptocurrency data and stock and bond data from third parties to produce this visualization. 

Just as there are plenty of arguments to hold more cryptocurrency, there are also many arguments to hold less. However, from the model’s standpoint, 0.50% should be your starting allocation.

Now, add your views.

This is where the mathematical magic comes into play. For any given growth rate in cryptocurrency (or any investment for that matter), the Black-Litterman model will return the amount you should hold in your portfolio. What’s more, you can specify your level of conviction in that assumed growth rate and the model will adjust accordingly.

In the below chart are the portfolio allocations to bitcoin derived from the Black-Litterman model. This chart can serve as a useful, hypothetical guideline when thinking about how much cryptocurrency you might want to hold.

How to use it: Select how much you think bitcoin will overperform stocks, from +5% to +40%. Each return expectation corresponds to a line on the chart. For example, if you think that bitcoin will outperform stocks by 20%, this corresponds to the purple line. Now, follow the line left or right based on how confident you are. If you’re at least 75% confident (a solid “probably”), the purple line lines up with a 4% allocation to bitcoin.

Graph represents a hypothetical rendering of confidence of return value based on inputs to the Black-Litterman model. Image does not represent actual performance, either past or present. 

One of the most interesting things to note is how high your return estimate needs to be and how confident you need to be in order to take a sizable position in bitcoin. For example, for the model to tell you to hold a 10% allocation you need to be highly confident that bitcoin will outperform stocks by 40% each year.

Also of note, it does not take much to drive the model’s allocation to 0% allocation, ie: no crypto holdings. If you don’t think that there’s a 50/50 chance that bitcoin will at least slightly outperform, the model says to avoid it entirely.

How we got here.

The inputs to the Black-Litterman model tell an interesting story in and of themselves. The main inputs into the model are global market caps, which we discussed earlier, asset volatility, and the correlation between assets.

It goes without saying that cryptocurrencies are risky. Over the last five years, bitcoin’s volatility was six times that of stocks and 30 times that of bonds. At its worst, the digital coin saw an 80% drop in value, while stocks were down 20%. Other cryptocurrencies fared even worse.

Source: Betterment sourced the above ACWI data and Cryptocurrency data from third party sources to create the above visualization. Visualization is meant for informational purposes only and is not reflective of any Betterment portfolio performance. Past performance is not indicative of future results.   

If an asset is volatile, and one is not able to diversify that volatility away, then investors will require a higher rate of return on that investment, otherwise they will choose not to invest.

The fact that bitcoin is so volatile, but has such a small number of investors (relative to stocks or bonds) suggests that many investors still do not see the potential returns worth the risks. On the other hand, cryptocurrencies are at their core a new technology, and new technologies always have an adoption curve. The story here may be less about expected return versus risk and more about early adoption versus mass appeal.

The final ingredient in the model is bitcoin’s correlation with stocks and bonds. Bitcoin has some correlation with both stocks and bonds, meaning that when stocks go up (or down), bitcoin may do so as well. The lower the correlation, the greater the diversification an asset provides to your portfolio. Bonds have a low correlation with stocks, which makes them a good ballast against turbulent markets.

Bitcoin’s correlation is higher, meaning that it can provide some diversification benefit to a portfolio, but not to the same degree as bonds.

Cryptocurrencies can be a component of your financial plan—but it shouldn’t be the only thing.

While it can’t tell you if bitcoin will be the next digital gold, this mathematical model can help you think about what kind of allocation to crypto might be appropriate for you and what assumptions about risk and return might be underlying it.

Even though Betterment currently doesn’t include cryptocurrency in our recommended investment portfolios, you can learn more about how to invest appropriately in it using our cryptocurrency guide.

Since crypto should only comprise a small percentage of your overall portfolio, you should still have a diversified portfolio and long-term investment plan that will help you meet your financial goals. Betterment can help you plan for the short and long term, recommending the appropriate investment accounts that align with your financial goals and allowing you to select your preferred risk-levels. You can also align your investments with your values by using one of our three socially responsible investing portfolios.

Invest with Betterment
Join us>

At Betterment, we’re using Julia to power the projections and recommendations we provide to help our customers achieve their financial goals. We’ve found it to be a great solution to our own version of the “two-language problem”–the idea that the language in which it is most convenient to write a program is not necessarily the language in which it makes the most sense to run that program. We’re excited to share the approach we took to incorporating it into our stack and the challenges we encountered along the way.

Working behind the scenes, the members of our Quantitative Investing team bring our customers the projections and recommendations they rely on for keeping their goals on-track. These hard-working and talented individuals spend a large portion of their time developing models, researching new investment ideas and maintaining our research libraries. While they’re not engineers, their jobs definitely involve a good amount of coding. Historically, the team has written code mostly in a research environment, implementing proof-of-concept models that are later translated into production code with help from the engineering team.

Recently, however, we’ve invested significant resources in modernizing this research pipeline by converting our codebase from R to Julia and we’re now able to ship updates to our quantitative models quicker, and with less risk of errors being introduced in translation. Currently, Julia powers all the projections shown inside our app, as well as a lot of the advice we provide to our customers. The Julia library we built for this purpose serves around 18 million requests per day, and very efficiently at that.

Examples of projections and recommendations at Betterment. Does not reflect any actual portfolio and is not a guarantee of performance.

Why Julia?

At QCon London 2019, Steve Klabnik gave a great talk on how the developers of the Rust programming language view tradeoffs in programming language design. The whole talk is worth a watch, but one idea that really resonated with us is that programming language design—and programming language choice—is a reflection of what the end-users of that language value and not a reflection of the objective superiority of one language over another. Julia is a newer language that looked like a perfect fit for the investing team for a number of reasons:

Speed. If you’ve heard one thing about Julia, it’s probably about it’s blazingly fast performance. For us, speed is important as we need to be able to provide real-time advice to our customers by incorporating their most up-to-date financial scenario in our projections and recommendations. It is also important in our research code where the iterative nature of research means we often have to re-run financial simulations or models multiple times with slight tweaks.Dynamicism. While speed of execution is important, we also require a dynamic language that allows us to test out new ideas and prototype rapidly. Julia ticks the box for this requirement as well by using a just-in-time compiler that accommodates both interactive and non-interactive workflows well. Julia also has a very rich type system where researchers can build prototypes without type declarations, and then later refactoring the code where needed with type declarations for dispatch or clarity. In either case, Julia is usually able to generate performant compiled code that we can run in production.Relevant ecosystem. While the nascency of Julia as a language means that the community and ecosystem is much smaller than those of other languages, we found that the code and community oversamples on the type of libraries that we care about. Julia has excellent support for technical computing and mathematical modelling.

Given these reasons, Julia is the perfect language to serve as a solution to the “two-language problem”. This concept is oft-quoted in Julian circles and is perfectly exemplified by the previous workflow of our team: Investing Subject Matter Experts (SMEs) write domain-specific code that’s solely meant to serve as research code, and that code then has to be translated into some more performant language for use in production. Julia solves this issue by making it very simple to take a piece of research code and refactor it for production use.

Our approach

We decided to build our Julia codebase inside a monorepo, with separate packages for each conceptual project we might work on, such as interest rate models, projections, social security amount calculations and so on. This works well from a development perspective, but we soon faced the question of how best to integrate this code with our production code, which is mostly developed in Ruby. We identified two viable alternatives:

Build a thin web service that will accept HTTP requests, call the underlying Julia functions, and then return a HTTP response.Compile the Julia code into a shared library, and call it directly from Ruby using FFI.

Option 1 is a very common pattern, and actually quite similar to what had been the status quo at Betterment, as most of the projections and recommendation code existed in a JavaScript service.

It may be surprising then to learn that we actually went with Option 2. We were deeply attracted to the idea of being able to fully integration-test our projections and recommendations working within our actual app (i.e. without the complication of a service boundary). Additionally, we wanted an integration that we could spin-up quickly and with low ongoing cost; there’s some fixed cost to getting a FFI-embed working right—but once you do, it’s an exceedingly low cost integration to maintain. Fully-fledged services require infrastructure to run and are (ideally) supported by a full team of engineers.

That said, we recognize the attractive properties of the more well-trodden Option 1 path and believe it could be the right solution in a lot of scenarios (and may become the right solution for us as our usage of Julia continues to evolve).

Implementation

Given how new Julia is, there was minimal literature on true interoperability with other programming languages (particularly high-level languages–Ruby, Python, etc). But we saw that the right building blocks existed to do what we wanted and proceeded with the confidence that it was theoretically possible.

As mentioned earlier, Julia is a just-in-time compiled language, but it’s possible to compile Julia code ahead-of-time using PackageCompiler.jl. We built an additional package into our monorepo whose sole purpose was to expose an API for our Ruby application, as well as compile that exposed code into a C shared library. The code in this package is the glue between our pure Julia functions and the lower level library interface—it’s responsible for defining the functions that will be exported by the shared library and doing any necessary conversions on input/output.

As an example, consider the following simple Julia function which sorts an array of numbers using the insertion sort algorithm:

In order to be able to expose this in a shared library, we would wrap it like this:

Here we’ve simplified memory management by requiring the caller to allocate memory for the result, and implemented primitive exception handling (see Challenges & Pitfalls below).

On the Ruby end, we built a gem which wraps our Julia library and attaches to it using Ruby-FFI. The gem includes a tiny Julia project with the API library as it’s only dependency. Upon gem installation, we fetch the Julia source and compile it as a native extension.

Attaching to our example function with Ruby-FFI is straightforward:

From here, we could begin using our function, but it wouldn’t be entirely pleasant to work with–converting an input array to a pointer and processing the result would require some tedious boilerplate. Luckily, we can use Ruby’s powerful metaprogramming abilities to abstract all that away–creating a declarative way to wrap an arbitrary Julia function which results in a familiar and easy-to-use interface for Ruby developers. In practice, that might look something like this:

Resulting in a function for which the fact that the underlying implementation is in Julia has been completely abstracted away:

Challenges & Pitfalls

Debugging an FFI integration can be challenging; any misconfiguration is likely to result in the dreaded segmentation fault–the cause of which can be difficult to hunt down. Here are a few notes for practitioners about some nuanced issues we ran into, that will hopefully save you some headaches down the line:

The Julia runtime has to be initialized before calling the shared library. When loading the dynamic library (whether through Ruby-FFI or some other invocation of `dlopen`), make sure to pass the flags `RTLD_LAZY` and `RTLD_GLOBAL` (`ffi_lib_flags :lazy, :global` in Ruby-FFI).If embedding your Julia library into a multi-threaded application, you’ll need additional tooling to only initialize and make calls into the Julia library from a single thread, as multiple calls to `jl_init` will error. We use a multi-threaded web server for our production application, and so when we make a call into the Julia shared library, we push that call onto a queue where it gets picked up and performed by a single executor thread which then communicates the result back to the calling thread using a promise object.Memory management–if you’ll be passing anything other than primitive types back from Julia to Ruby (e.g. pointers to more complex objects), you’ll need to take care to ensure the memory containing the data you’re passing back isn’t cleared by the Julia garbage collector prior to being read on the Ruby side. Different approaches are possible. Perhaps the simplest is to have the Ruby side allocate the memory into which the Julia function should write it’s result (and pass the Julia function a pointer to that memory). Alternatively, if you want to actually pass complex objects out, you’ll have to ensure Julia holds a reference to the objects beyond the life of the function, in order to keep them from being garbage collected. And then you’ll probably want to expose a way for Ruby to instruct Julia to clean up that reference (i.e. free the memory) when it’s done with it (Ruby-FFI has good support for triggering a callback when an object goes out-of-scope on the Ruby side).Exception handling–conveying unhandled exceptions across the FFI boundary is generally not possible. This means any unhandled exception occurring in your Julia code will result in a segmentation fault. To avoid this, you’ll probably want to implement catch-all exception handling in your shared library exposed functions that will catch any exceptions that occur and return some context about the error to the caller (minimally, a boolean indicator of success/failure).

Tooling

To simplify development, we use a lot of tooling and infrastructure developed both in-house and by the Julia community.

Since one of the draws of using Julia in the first place is the performance of the code, we make sure to benchmark our code during every pull request for potential performance regressions using the BenchmarkTools.jl package.

To facilitate versioning and sharing of our Julia packages internally (e.g. to share a version of the Ruby-API package with the Ruby gem which wraps it) we also maintain a private package registry. The registry is a separate Github repository, and we use tooling from the Registrator.jl package to register new versions. To process registration events, we maintain a registry server on an EC2 instance provisioned through Terraform, so updates to the configuration are as easy as running a single `terraform apply` command.

Once a new registration event is received, the registry server opens a pull request to the Julia registry. There, we have built in automated testing that resolves the version of the package that is being tested, looks up any reverse dependencies of that package, resolves the compatibility bounds of those packages to see if the newly registered version could lead to a breaking change, and if so, runs the full test suites of the reverse dependencies. By doing this, we can ensure that when we release a patch or minor version of one of our packages, we can ensure that it won’t break any packages that depend on it at registration time. If it would, the user is instead forced to either fix the changes that lead to a downstream breakage, or to modify the registration to be a major version increase.

Takeaways

Though our venture into the Julia world is still relatively young compared to most of the other code at Betterment, we have found Julia to be a perfect fit in solving our two-language problem within the Investing team. Getting the infrastructure into a production-ready format took a bit of tweaking, but we are now starting to realize a lot of the benefits we hoped for when setting out on this journey, including faster development of production ready models, and a clear separation of responsibilities between the SMEs on the Investing team who are best suited for designing and specifying the models, and the engineering team who have the knowledge on how to scale that code into a production-grade library. The switch to Julia has allowed us not only to optimize and speed up our code by multiple orders of magnitude, but also has given us the environment and ecosystem to explore ideas that would simply not be possible in our previous implementations.

Did you miss our previous article…
https://diyinvestorresources.com/?p=525

…

The post Speculation is the new entertainment appeared first on The Reformed Broker.

Did you miss our previous article…
https://diyinvestorresources.com/?p=518

Key 401(k) Compliance Dates

While many of these responsibilities are handled by Betterment, as a 401(k) plan sponsor it’s important that you are aware of important dates and deadlines associated with administering your plan.

DateResponsibilityPrevious Plan YearCurrent Plan YearJan 31BettermentIRS Forms 1099-R available to participants.Feb 10BettermentAnnual Return of Withheld Federal Income Tax (Form 945) due.Mar 1ParticipantDeadline for employees who participated in multiple plans to notify sponsors of excess deferrals (402(g) excess).Mar 15BettermentDeadline for refunds to participants for failed ADP/ACP tests(s). Failure to meet this deadline could result in a 10% tax penalty for plan sponsors.Mar 15Plan SponsorEmployer contributions (e.g., profit sharing, match, safe harbor) due for deductibility for incorporated entities.¹ Failure to meet this deadline could preclude plan sponsor from tax deductibility.Deadline to establish plan for the prior tax yearApr 1Plan SponsorDeadline to confirm that Initial Required Minimum Distributions (RMDs) were taken by participants who: turned 72 ² before previous year-end; are retired/terminated; and have a balanceApr 15 ³Plan SponsorEmployer contributions (e.g., profit sharing, match, safe harbor) due for deductibility for LLCs, LLPs, sole proprietorships (unincorporated entities).¹ Failure to meet this deadline could preclude plan sponsors from tax deductibility.Apr 15BettermentDeadline to complete corrective distributions for 402(g) excess deferrals.Jul 29 ⁴Plan SponsorDeadline to distribute Summary of Material Modifications (SMM) to participants (only if plan was amended).Jul 31 ³Betterment ⁴Deadline to electronically submit Form 5500 (and third-party audit if applicable) OR request an extension (Form 5558).Sep 30Plan SponsorDeadline to distribute Summary Annual Report (SAR) to participants and beneficiaries (unless Form 5500 extension filed; deadline to distribute will be December 15).Oct 1Plan SponsorDeadline to establish a new safe harbor match 401(k) plan.Oct 15 ³Plan SponsorDeadline to electronically submit Form 5500 and third-party audit, if applicable, if granted a Form 5558 extension.Dec 1Plan Sponsor (Notices prepared by Betterment)Deadline to distribute supplemental safe harbor notice to participants for safe harbor (“maybe”) plans. ⁵Dec 1Plan Sponsor (Notices prepared by Betterment)If applicable, distribute to participants for next plan year: Safe harbor notice, Qualified default investment alternative (QDIA) notice, Automatic enrollment noticeDec 1Plan Sponsor (Amendment drafted by Betterment)Deadline to execute amendment to make a traditional plan any type of safe harbor plan (match or nonelective).Deadline to execute amendment to make a traditional plan a safe harbor match plan for following plan yearDec 15Plan Sponsor (SAR prepared by Betterment)Deadline to distribute Summary Annual Report (SAR) to participants, if granted a Form 5558 extension.Dec 31Plan SponsorDeadline to make safe harbor and other fixed employer contributions.Deadline for Annual Required Minimum Distributions (RMDs). ArtDec 31Plan SponsorDeadline to execute amendment to make traditional plan a 3% safe harbor nonelective plan for the current plan year

 

¹ Assumes calendar tax year. Additionally, if your company files a tax extension, you have until the extension deadline to fund the contributions.

² This was increased from 70½ in 2019 and earlier years.

³ Or first business day thereafter.

⁴ 210 days after the year end of the effective amended date, which is July 28 in leap years.

⁵ Safe harbor “maybe” Plans (specified in the plan document) are able to adopt a safe harbor nonelective plan 30 days before the end of the plan year. Please review your plan document to confirm if the plan has adopted such a provision.

Did you miss our previous article…
https://diyinvestorresources.com/?p=481

Five short years ago, Avery Carl didn’t own ninety-six rental units. She didn’t have her real estate license, she hadn’t founded The Short Term Shop or The Mortgage Shop, and […]
Did you miss our previous article…
https://diyinvestorresources.com/?p=446

Over the last several months there’s been a lot of hype about Wall Street driving up the housing market. I’ve seen a few dozen headlines about how no one can […]
Did you miss our previous article…
https://diyinvestorresources.com/?p=428

Learn more about the psychology behind decumulation.
Did you miss our previous article…
https://diyinvestorresources.com/?p=416

Back in 2004, Jude Bernard was sitting at a blackjack table in Vegas. This wasn’t his first game of the day, nor his second, or even his third. Jude had […]
Did you miss our previous article…
https://diyinvestorresources.com/?p=323