Calling latest version number of my own functions from one of my other functions?

Hello!

I don't use git, but modify functions I write by appending a version number: e.g., "myfunc_3()" for the third version of myfunc().

When I update myfunc_#(), I then need to update any function that calls myfunc_#(). If I always use the same syntax, is there a workable, intelligent (simple?) way to do this? I would figure that I need no more than 99 versions of anything I write (God, I hope not!)

Thanks!

Doug Anderson

[Voss]

When I need to make a new version of a function and I want to keep the old one I rename the old one first by appending _old or _backup to the name. This way the newest version always has the same name.

Of course this doesn't help in your situation, but maybe to avoid this situation in the future.

[Stephen23]

"If I always use the same syntax, is there a workable, intelligent (simple?) way to do this?"

The approach given by _ in the previous comment is much better: I guess that most experienced MATLAB users do some version of that. Another simpler approach is to just push the older versions into an "archive" subfolder which is not on the MATLAB search path. Incrementing the working function name like you are doing creates an unusual type of very high coupling between your fuctions (but in this case due to their names, not their functionality):

https://en.wikipedia.org/wiki/Coupling_(computer_programming)

The 1st and 2nd points given in the "Disadvantages" section exactly describe your approach.

Note that your approach has no (easy) way to confirm that all references to a function were correctly updated, i.e. you could easily call different versions of a function and you would never know.

"I would figure that I need no more than 99 versions of anything I write"

You will.

But most likely this approach will be a lesson that is best learned the hard way.

Answer 1

[DGM]

I'm sure someone has a better way, but here's this. This just looks at all the .m files in a specified directory and replaces instances of myfunc_35() with myfunc_36(). The results are dumped into a bucket directory to avoid overwriting things.

Note the following:

• This example only looks one directory level deep
• Any files that aren't .m files won't be in the output directory.
• The matching is case-sensitive and looks at preceding and following characters
• This can't tell if it's a function call or a variable of the same name
• This won't ignore quoted or commented instances of the pattern

oldfunction = 'myfunc_35';
newfunction = 'myfunc_36';

indir = 'mydirectoryofstuff'; % the directory to process

% you'll need to decide how you want to handle the output
% i'm just going to write all the modified files to a bucket directory
% note that this will only contain .m files!
outdir = [indir '_edit'];
if ~exist(outdir,'dir')
    mkdir(outdir);
end

S = dir(fullfile(indir,'*.m'));
for fn = 1:numel(S)
    alltext0 = fileread(fullfile(indir,S(fn).name)); % read the file
    alltext0 = split(alltext0,newline); % split into a cell array
    
    % replace all instances of 'myfunc_35' preceded by zero or more non-alpha
    % characters, and followed immediately by a (
    alltext0 = regexprep(alltext0,['(?<=[^a-zA-Z]*)' oldfunction '(?=\()'],newfunction);
    
    fid = fopen(fullfile(outdir,S(fn).name),'w');
    fprintf(fid,'%s\n',alltext0{:});
    fclose(fid);
end

I've attached a test directory containing a handful of files to process.

[Douglas Anderson]

I will try this out and let you know, DGM! Thanks.

[DGM]

I knew well enough that I'm not the one to recommend best practices, but that having a means to do the bulk-renaming should be useful even if you decide to eventually transition to a different version-handling approach.

Answer 2

[Steven Lord]

The "workable, intelligent" solution would be to use a source control management system like Git.

If for whatever reason that's not an option, you could write a "canonical" version of that function that accepts inputs, passes them into an implementation function of your choice, receives the outputs from that implementation function, and returns those outputs to the caller of the canonical function.

x = myfun(0:90:360)                  % never changes

x = 1×5

0 1 0 -1 0

function out = myfun(in)             % never changes
out = myfun1(in);
end                                  % never changes
function out = myfun1(in)            % never changes
out = sind(in);                      % never changes
end                                  % never changes
function out = myfun2(in)            % never changes
out = cosd(in);                      % never changes
end                                  % never changes

If you wanted your script to compute the cosine of the input rather than the sine, you would change just the call inside myfun from myfun1 to myfun2. The code in the script itself would not need to change, and neither would myfun1 or myfun2. This is kind of like the facade pattern.

[John D'Errico]

This is a problem just made for GIT.

[Douglas Anderson]

I have been going through this, and see that using GIT probably is a much simpler answer to my question. However, my work is done solo (aside from the outstanding help from the MATLAB community), and figuring out how to GET GIT and USE GIT is like going into BestBuy or looking on Amazon for speakers. Too much information to see how to get it and use it!

I looked up "Use Source Control with Projects", and it's all incomprehensible. I know how to write code in the Editor, and have had successful projects, and love the environment.

Any thoughts on how to start with GIT and git back on the right track? Thanks!

[Stephen23]

Avoid GIT, too many special "features" to be worth the hassle for one person managing their own files.

I have used several revision control systems (professionally and personally) and they all suffer from exactly the same problem: designed by computer programmers for large (generally distributed) projects, intented to be used exclusively by other computer programmers (or in GIT's case: themselves**). Various have-to-write-code academics I know who just want to manage their own files for their own projects are completely overwhelmed by the ... special thinking of GIT, and its totally unrelated, superfluous, convoluted capabilities. I abandoned GIT for my own projects after realizing that I wasted more time trying to figure out how to do things in GIT (read: rescue my code from GIT) than actually doing anything productive. GIT is fun only if you like reading copious forums trying to find out how to do X (and then reading the related flame wars because even the people who use GIT cannot agree on how to do X), and you love the cryptic Unixy commands written like it was the 1970s with only 80 characters on your terminal's two-line display. The various GUI wrappers are not much of an improvement (I tried them).

Realistic alternatives that might suit your needs better:

• use your OS's file/folder versioning. Modern Mac and Windows offer hourly/daily/whatever backups of your data. They are AFAIK basically reliable, are built in, require nothing to learn, nothing to do other than enable that feature... and bingo you have backups galore.
• use TeraCopy (or other file copying application) that has the option to replace older files only and also to number conflicting filenames. Use this with a simple ARCHIVE directory: copy and paste into ARCHIVE, bingo you have a folder containing numbered backup files. Simple and intuitive, minimal effort.
• use a better-designed revision control system. Even fans of GIT eventually admit that it is very very ... warty. There are better designed revision control systems out there (hint: internet search), popularity in this case is not a sign of quality. Mercurial is often described as easy to learn (I have not tried it). More effort than the first two suggestions, but of course more powerful in its features.

** It evolved/mutated/developed into existence by the Linux kernel team purely for their own needs.

[Walter Roberson]

I used to use rcs and cvs, both of which were not difficult to use. rcs did not handle binary objects though.

[Douglas Anderson]

Thank you all for your thoughts... and I do fit generally into the "have-to-write-code" subset! I am not a programmer, but I program, just as I am not a violist but play the viola. DGM's "I'm sure someone has a better way" is going to work for me. But, once again, thank you!

Answer 3

[Walter Roberson]

Write a small class with a bunch of static properties, one for each function you need to put under the scheme. The class initialization should read a configuration file to determine which file to use the implementation for each function, and set the property to a handle to the corresponding function. Then the code would be written in terms of ClassName.GenericName such as Funs.myfunc and that would have the effect of pulling out the stored handle.

As an alternative implementation, instead of a class, write a function that returns a struct with one field for each generic, such as

function funs = Funs
  funs = struct('myfunc', @myfunc_3, 'myinit', @myinit_4)
end

This would be invoked the same way as I showed for class implementation. If you added a layer with a persistent variable, it might even be faster than the class implementation.

Either way you would have to edit a control file as you moved between versions. You would not typically want to assume that the newest (highest number) is the one to use. When you are doing debugging it is very common to need to execute the latest stable version in order to compare the results of the experimental version to the stable version to be sure that you get consistent results.

That said, it might plausibly be reasonable in your situation to have initialization code that filled out the newest version automatically by examining the files, and then have a small section of fix-ups to allow reference to older versions.