Adarq.org

sick but man did i LOL when that pole broke.

<a href="http://www.youtube.com/watch?v=HW9MtoMpRzs" target="_blank">http://www.youtube.com/watch?v=HW9MtoMpRzs</a>

<a href="http://www.youtube.com/watch?v=rYcSaNiaHsg" target="_blank">http://www.youtube.com/watch?v=rYcSaNiaHsg</a>

<a href="http://www.youtube.com/watch?v=vOwedV1enNA" target="_blank">http://www.youtube.com/watch?v=vOwedV1enNA</a>

haha

Its like your dancing or some thing when you dribble around deserted malls. DESERTED MALLS!!!

The Road.

good point...lets speed up the evolution by deleting users survivor style who are only bringing the forum down 

that's why there is a journal graveyard






another thing, it's interesting to me that, plenty of people who start trying to improve their athleticism, they completely lack an assessment/evaluation function.. If they lack an assessment/evaluation function, then the feedback_t returned from trainingFunc() becomes useless.. If you don't journal, you might as well give up before you try, because that is the basis for eval/assessment.

plenty of people that do have an assessment/eval function, have a problem understanding the feedback returned from trainingFunc(), i mean, we've all seen people just journal, pages upon pages, of just doing the same old thing over and over without a real focus on results.. You can't reFormTrainingPlan() if feedback_t is useless.. Some people never reform their training plan, they lack that function also, their training just becomes a loop of trainingFunc() without any filters, this usually is devastating.

another interesting concept here, is this.. we are looking at this from the micro level, but, say we look at it on the macro level. It becomes Genetic Programming, using evolutions and populations.

The population, such as our community of forum users (athlete structures), comes here with their own training histories, injury histories, etc.. Each user generally creates their own evaluation functions, assessment functions, etc, the degree to which each user does this varies with experience etc.. But basically, these are random "individuals" making up the population, the degree of variety exists, and eventually becomes refined/phased out after each evolution through the training process..

For example, we may have 40 athletes in the population, utilizing 40 different training ideologies.. After evolution #1, each athlete will have different results, the athletes with the best results tend to continue what they are doing, while the athletes with the worst results tend to incorporate ideologies based on what the best are using.. Evolution after evolution, the OVERALL asessment/evaluation/trainingFunc/filters are enhanced on a macro level, which each athlete incorporates on the micro level.. So basically, after years and years of evolution, this forum will have some pretty refined functions & filters regarding performance training, that will get people to where they need to go ALOT faster than a forum that people frequent only to "train to train"..

The key here is learning from each individual, taking into account their differences, similarities, etc, then creating branches in the assessment/eval/training functions so that each person goes down the optimal code path.

This is actually what is happening, slowly..

This forum now becomes the evolutionary algorithm of athletic performance enhancement, that is, as more & more journals are created and kept up with, it will happen.

The entire s&c industry is an evolutionary algorithm, but the problem is, so much scam/fluff has been injected, that the branches most people take, lead to failure, which then makes the s&c evolutionary algorithm a DEVOLUTIONARY algorithm. WTF. We need to demonstrate the optimal paths to success, over and over again, in order to make a dent in this massive population.

lolzozozlzo

so, this programming actually seems pretty simple, it's all just a loop with filters/assessment/analysis functions, then your training function.. I think the next trick is learning how to optimize the actual trainingFunc() code, without changing anything structural.

For example, something like smolov can improve squat form simply by improving motor patterns involved with squatting, that's code optimization.. I don't think that's the key though, I think the key in code optimization comes from accurately predicting supercompensation. Our program must very accurately be able to:

1. create dips in performance which result in supercompensation
2. accurately predict exactly when peak supercompensation results
3. create nutritional strategies that coincide with the above 2 points, that result in the utmost strength/alertness.. integrate those strategies with supercompensation so to enhance the effect.

Any injury that is sustained in our training would then be considered a bug, so to would sub optimal training systems based on the analysis functions.

A bug causes some kind of crash, an injury is a crash.. The hardest types of bugs to find are those which cause data inconsistency way down the road, such as memory allocation bugs / data corruption bugs and crap like that.. Data corruption would involve ineffective programming of the various analysis/evaluation bugs, because it would prime our trainingFunc() with the incorrect/suboptimal road to success.

Too much overcomplication of the trainingFunc() would easily lead to bugs down the road, because it would create too many code paths, bulky code in general, & too much interference. The analysis functions could be very bulky, as their job is to organize all of the information (past & present) and make decisions based on that data, to supply to our streamlined trainingFunc().

llozlzolzozl

struct UltimateTrainer
{
     int assesmentFunc();



assessmentFunc() would also go through all of the *analysis substructures, and based on the bioanalysis of the person on that day, would filter out exercises that would be less effective, for example, using limb lengths, extremely long SHR'd athletes would have ATG squatting downvoted in favor of half squatting.. Based on explosive to maximal strength ratios, ie, RVJ to SVJ to static SVJ, plyometric/reactive/explosive exercises would be filtered/added to the list of available exercises, sets/reps/durations would also be calculated based on work capacity values taken from the training history analysis substructs.

so trainingFunc() feeds off of assessmentFunc() as the athlete matures chronologically.


so, before you get to trainingFunc(), you go through assessmentFunc()/evaluationFunc(), then you apply extra filters based on reFormTrainingPlan();, then and only then, may you apply trainingFunc().. optimal training, every day, no exceptions.

lulzcakes.