Unfortunately, 4876/4766 is just 2.3% for the last 3 years.  That's not great compared to even interest after taxes.  You might have done better by perfectly timing the dips, but most dip buying is on the sides of the dip. The index fund craze could have made them more volatile or it could have diluted the gains.  For now, it seems to have diluted the gains. 

The S&P would have to be 6300 to hit the much hyped 10% annual average for the last 3 years.  Maybe it'll eventually double.  Those doublings tend to happen overnight.  1 way of looking at it is 6300 is where it should be right now & it's trading at a discount.  As long as the inflation target is an average, they're hitting 2% now.  Housing is rising a lot faster & microchips are falling.

The forecast is for interest to drop to 3% by the end of the year so the S&P could easily hit 6300.  With the stonk market now at record highs, the lion kingdom is currently 54% cash, 37% stonk, & 9% bond funds.  The plan to let the stonk position naturally grow to 50% continues, though bonds & stonks tend to move in the same direction these days.  Lions previously combined those to get 46% stonk.  Much of the stonk positions contain significant bonds, so it's still a fuzzy definition.

Despite the 37% in stonk, it's a lot of money by lion standards.  It's nowhere near enough for a house near any jobs, but it is what a younger lion before Bidenflation would have considered a terminal stonk position for retirement.  It's hard to justify increasing the 401k's stonk percentage, given the current stonk position & the limitations of the account.

Lions consider the stonk position a forever position never to be sold until all the cash is gone.  It'll go wherever it goes.  The only changes will be new stonk purchases during dips.  There's probably no need to buy any more stonks during a bull market like right now.  During a significant crash, the stonk position could grow well beyond 50%.

-------------------------------------------------------------------------------------------------------------------------------

1 solution to the extremely heavy lenses.  It seems to be heat shrink or silicone tubing around an iron plug, which is connected to a cord, hardly worth $1.35.  A thinner cord or shoelace would be better with a mane.  If it doesn't have to be removable, it can be permanently heat shrunk around the glasses.

---------------------------------------------------------------------------------------------------------------

Cinelerra finally enters the 21st century with a way to run user functions in the run_window thread.  Basically, every window already had its own GUI thread but it was only accessible by other functions in the GUI library & only able to process X Events.  It was just a matter of making this system run pointers to functions.

Passing around a pointer to a function was not the C++ way, 25 years ago.  You would have overridden a virtual function & passed the class.  Since then, the trend has really been away from virtual functions & passing around bare functions in the form of lambdas.

The mane motivation was the case where a file preview thread needs to draw in a file dialog. It would have to lock the pointer to the file dialog, then lock the X window, which could lead to a deadlock.  The previous workaround was to never delete any windows which were asynchronously drawn on.  That was impractical in the case of many file dialogs.

An intermediate thread is required to accept drawing commands from the file preview thread without locking the X window, then lock the X window on its own for drawing.  At this rate, Cinelerra may have modern memory management & user interface patterns in another 100 years.  

Lions believe peak development ended in 2003.  There were big evolutions with X264, GPU playback, ffmpeg usage, command line rendering, GPU rendering, plugin visualizers, but the biggest leap was before 2003.  Everything since then has been sporadic.

To be sure, it was started in a time of much resistance to modern languages & bloat.  Pure C was the rage on Linux, in the late 90's.  They wanted to do things with the least instructions possible.  Being able to run Linux on obsolete hardware was a big deal.  It might have also been an early vintage computing craze.  The modern philosophy is the complete opposite of that.

Lions were originally early adopters, using threads & C++ when no-one else did.  The thrill seems to have faded.

A quick test showed lambda functions to be interchangeable with traditional pointers to functions.

void put_event(void (*user_function)(void *), void *data);

 

Either a lambda function or a traditional static function can be passed to the same function pointer argument.  It just requires passing -std=c++11 to the compiler.

put_event([](void *ptr){ printf("test\n"); }, filebox);

void preview_not_available_(void *ptr)
{
    printf("test\n");
}

put_event(preview_not_available_, filebox);

There are ways to pass filebox as an argument to the lambda function, but since the function is being put in an array of lambda functions, it seems easier to pass it separately.