What secrets are hidden away in your init.m and where do you place it? Please help me build the ideal init.m

Question

My init.m Feels Like it's Missing Something

Although I am familiar with about a dozen or so programming languages I am only sort of, kind of, halfway competent in about three. MMA with it's boxes, expressions, patterns, symbols, and cells is a whole new beast to me. It forces you to forget everything you think you know about programming and think differently. Then it throws a wrench into the whole mess hy introducing the init.m without a good explanation.

The following working code is what I have so far. It is what I call my pre-alpha init.m. My concerns are that it may be missing something that MMA experts normally place in there. For example is this a good place to clean out old temp files, remove obsolete symbols or delete obsolete objects, create persistent objects, set new paths, set $HistoryLength, ClearSystemCache, is using Once here okay, etc.? My other concern is where should I drop copies of init.m if I want it to survive a refreshed Kernel or a crashed FrontEnd?

(* overload immediately needed repository resources *)
Once@(
   Quiet@PersistResourceFunction["PersistResourceFunction"];
   Quiet@PersistResourceFunction["SymbolQ"];
   Quiet@PersistResourceFunction["ResourceFunctionMessage"];
   Quiet@ResourceUpdate[ResourceObject["PersistResourceFunction"]];
   );
(* overload immediately needed packages *)
Once@Map[Get,{"Alphas", "NBEssentials", "NBTaskmate","NBStyles"}];
(* other cool tasks TBD *)

Since I have your attention is it okay to do this: Once@Get /@ {"Alphas", "NBEssentials", "NBTaskmate","NBStyles"};?

There is Almost No Help Published by Wolfram

Some of our most essential code is hidden away in a file that we can just drop 'n' forget. Although the proper contents of this infamous file is expected to be well understood by all seasoned programmers the official documentation at Wolfram only hints at but gives no solid examples of the kind of things to put in there. This would help coders like me who are not programmers but come from a different field like physics and engineering who need to employ coding with their work and must adhere to best practices to go with it.

What Mathematica Stack Exchange Has to Offer

As of this writing a search for init.m yields 419 help posts. However these are all about fixing specific-area applications or broken code not about building a proper init.m.

There are a few "big-list" posts such as the ambitious undisputed world heavyweight that grew into Godzilla which I really like, Where can I find examples of good Mathematica programming practice?, unfortunately in its quest to answer all best practices under the sun it forgets to even mention the init.m. Another one I really like is the more focused Getting serious about Mathematica programming but it too omits the init.m. There are others. This is just a very small sampling that stood out to me as expected to have a dedicated category on the init.m.

The Five Secondary Goals of this Post Are to Help Build Best Practices

Of course the primary goal is to examine my init.m which will help me figure out what is good to put in there and what not to put in there. Along the way we can help many others by identifying some best practices.

1. Let others learn from your best practices by sharing your code in an Answer.
2. Let others share their expertise in how to improve your shared code.
3. By identifying what every init.m file should have and why.
4. By identifying what what every init.m file should NOT have and why.
5. By identifying in which directories we should drop 'n' forget our init.m and why.

With posts like these there are no losers, everybody wins. The only catch is we all need to participate to win.

Answer 1

I am an init.m ascetic. And I doubt after 30+ years of using Mathematica I will change. Everyone else, who wishes to, may proclaim how it is indispensable to their workflow, and I will accept their pronouncements without comment or criticism.

My Kernel init.m has nothing in it. My Front End init.m has whatever the FE puts in there from setting preferences, some history from the SEUploader palette, and hopefully little else. I try to avoid SetOptions[$FrontEnd,...] and use SetOptions[$FrontEndSession,...] instead.

I do have a notebook I always use to open Mathematica with some standard things, like $HistoryLength = 5, tucked away in section called "Init" that I select and execute whenever the Kernel starts or restarts. Many years ago I put something in one of the init.m files that caused bugs in something I was working on. It took me a long time to figure out what was causing the problem, because it's hard to remember everything you put in a file you never see. Once I had something in init.m that caused the kernel to crash. After few problem like that, I decided sometime in the 1990s to ditch using init.m and perform initializations optionally and separately from starting the kernel. Since then I've generally come to realize that learning to use a tool as it was designed is easier than trying to make a tool into something else. That's not an absolute rule though, and this tool, Mathematica, comes designed with init.m and SetOptions[], among other things. So others may have different opinions as well as good reasons for their particular setup. I will add this: If you are working with others, it's helpful for everyone to have the same setup.

Here are the "Init" codes I use:

$HistoryLength = 5;
Needs["NDSolve`FEM`"];
Needs["GeneralUtilities`"];
Needs["CompiledFunctionTools`"];
traceView2[..] := ... (*https://mathematica.stackexchange.com/a/29340/4999*)
traceView2i[..] := ... (*=traceView2[] + TraceInternal->True*)
BoxForm`UseApproximations = False;
(* add Okabe-Ito colorblind palette to ColorData[]
     per https://mathematica.stackexchange.com/a/57893/4999 *)
Typeset`$InformationGridOpen = False;(* start ?symbol closed *)
qlink[..] := ... (* create link to Mma.SE question;
     see https://mathematica.stackexchange.com/questions/87375/plotting-the-tangent-of-a-curve#comment237773_87375 *)
echo = (Print[#]; #) &; (* for debugging (don't like Echo[]) *)
dbecho[lbl_] := (Print[lbl -> #]; #) &; (* ditto *)

Plus a few useless utilities I won't mention because I've never used them. In fact I forgot they were there, until looking up my "Init" codes for this answer.

---

P.S. I think this Q&A might ought to be a "Community Wiki." I feel my answer is strongly opinionated and what is best will depend on individual situations. So what seems the best answer to one person may seem a bad answer to another.

---

Update 2022.06.12

Here's one of those useless things I used today....

I hate it when users leave off semicolons that would suppress unnecessary output on a dozen or two input lines. I'd only use this function on this site, so more useful to someone like me.

addsemis[c_CellObject] := Module[{ce},
  ce = NotebookRead@c;
  SelectionMove[c, After, Cell];
  NotebookWrite[ParentNotebook[c],
   Replace[ce, {
     e : RowBox[{_, ";"}] :> e,
     e_RowBox :> RowBox[{e, ";"}]}, 3]];
  NotebookDelete[c]
  ]

Example usage: addsemis[PreviousCell[]].

Caveat: 1. It writes in a notebook, so I'd use it only on a temporary notebook in case I trashed it. 2. In a month or two, I'll forget all about this function again, or forget its name, and then think it's faster to type 20 semicolons than to look up the function again.

Acknowledgement: I probably got the idea from Cell splitting in mathematica, since a couple of the lines are identical.

Answer 2

I tend to put a lot of little functions in my init.m file, functions that take arguments and use module variables. I found that I would now have Global symbols like x, var, date, name, etc, before even running any commands.

So the interesting thing I have in my init.m file is a package structure:

BeginPackage["Init`"]
<exported functions list>
Begin["Private"]
<implement functions>
End[]
EndPackage[]

never regretted it.

Answer 3

(** User Mathematica initialization file **)

$PrePrint = Replace[# , mat_?MatrixQ :> MatrixForm[mat]] &;

Needs["Let`"];

Needs["sprintf`"];

Get["AcademicTheme`"];

• Matrix formatting as in this answer.
• Let as in LetL
• My (imperfect) attempt at sprintf
• A customized Academic plot theme.

The reason to keep it relatively empty is to avoid problems when sharing a notebook with someone else (who may not have the same init.m customizations).

One thing I used to have was a hook in $Pre (or maybe $PreRead?) that removed some front-end formatting. It's usually a mistake if eg. MatrixForm is in the input if you use the above $PrePrint. I ultimately removed it. The combination can be good for new users who are sometimes mistakenly learn that the construction // MatrixForm is a formatting directive, rather than // is a form of composition.

Answer 4

SetOptions[$FrontEnd, 
  EvaluationCompletionAction->{"ShowTiming"}, 
  CodeAssistOptions->{"FloatingElementEnable" -> False, "MaxGlobalMatches" -> 10}, 
  ShowPredictiveInterface->False, 
  TranslationOptions -> {"Enabled" -> False},
  FractionBoxOptions->{AllowScriptLevelChange->False},
  Graphics3DBoxOptions -> {SphericalRegion -> True},
  "EvaluationQueueActions"->{"Icon","Flash","NotificationCenter","ProgressIndicator"},
  MessageOptions -> {"InsufficientVersionWarning" -> False, "KernelMessageAction" -> "PrintToNotebook"},
  "NotebookSecurityOptions" -> {"TrustByDefault" -> True},
  PrivateFrontEndOptions->{"ShowAtStartup"->"NewDocument"},
  RenderingOptions->{"HardwareAntialiasingQuality"->1},
  CellLabelPositioning -> Left
];

If[$VersionNumber>=12,SetSystemOptions[ "TypesetOptions" -> "NumericalApproximationForms" -> False]];

Related link:
When calculating, the taskbar icon will not change in Mathematica 12.2
Magnification messing up styles

Answer 5

As I mentioned in a comment, I do not use an init.m file, I paste my frequently used functions from project notebook to project notebook as an initialization cell. That having been said, my initialization cell is:

If[False, {(* 
  true for saving to PDF at true dimensions and ImageResolution of \
1200 PDI, false for large graphs for screen and saving as PNG, 
  see  https://mathematica.stackexchange.com/a/234591/43662*)
  ftsz = 12,(*fontsize 12 for graph publication quality PDFs*)
  imgsz = 100, 
  imgrez = 2400}(*imagesize coefficient 57/was100 equal to one inch*)
\
, {ftsz = 38, imgsz = 267, 
  imgrez = 72}];(else for large images and publishing PNG graphs 

42/200)
fntandsz = {FontFamily -> (fntFam = "Georgia")("Times"), 
  FontSize -> ftsz};
$HistoryLength = 5;
txt[a_, b_, c : {?NumericQ, _?NumericQ} : {0, 0}, 
  d : {?NumericQ, ?NumericQ} : {1, 0}, opt : OptionsPattern[]] := 
 Text[Style[a, opt, FontFamily -> "Georgia"("Times"), 
   FontSize -> ftsz], b, c, 
  d](* This simplifies the input for text in raphics to avoid the 

need to nest Text[Style[ ] ] in every graphic. The options at the end 

get passed to Style[]. The previous arguments are made optional by 

getting a default value ":{0,0}" while a test prevents the code from 

confusing an option for those with ":{?NumericQ,NumericQ}" ) 
fpath = (NotebookBrowseDirectory /. Options[$FrontEnd]) <> 
  "\";(save in notebook path)
(stop evaluation if the path does not end in \Documents*)
If[StringTake[fpath, -11] != "\Documents\",
 (Remove cells from evaluation queue)(
  SelectionMove[EvaluationNotebook[], All, Notebook, 
   AutoScroll -> False];
  FrontEndExecute@FrontEndToken@"RemoveFromEvaluationQueue";
  SelectionMove[EvaluationCell[], After, Cell, AutoScroll -> False];
  (set $Pre to abort current cell but before that schedule a task to 

un-define $Pre)
  SessionSubmit[ScheduledTask[$Pre =., {Quantity[3, "Seconds"]}]];
  MessageDialog[
   "Wrong working directory! Open and close a file in /Documents and 

rerun."];
  $Pre = Abort[] &; 
  Abort[];)];(end of sequence stopping evaluation if the directory 

is false)
droptrailingperiod[x] := 
 If[Round[x] == x,(is the rightmost a period, from some precision?)
Round[x](then use Round to drop the trailing period)
  , x](else not)
adollartick[
  x_] := {x,(define a function that creates a tick label pair for 

dollar amounts)
  NumberForm[droptrailingperiod@x, NumberSigns -> {"-$", "$"}, 
   DigitBlock -> 
    3](put dollar sign and comma and drop the trailing period)
  }
dollarticks[min_, max_] := 
 adollartick[#] & /@ 
  N[FindDivisions[{min, max}, 
    3]](to produce dollar amounts as tick marks with three tickmarks)
dollarticks7[min_, max_] := 
 adollartick[#] & /@ 
  N[FindDivisions[{min, max}, 
    7]](to produce dollar amounts as tick marks with seven tickmarks)
apercenttick[x_] := {x,(function of tick pair for percentages)
  ToString[
    droptrailingperiod[
     100 x]](multiply by 100 and drop trailing period)
   <> "%"}(and append a % sign)
percentticks[min_, max_] := 
 apercenttick[#] & /@ N[FindDivisions[{min, max}, 7]]
fewpercentticks[min_, max_] := 
 apercenttick[#] & /@ N[FindDivisions[{min, max}, 4]]
fewticks[min_, max_] := 
 droptrailingperiod[#] & /@ N[FindDivisions[{min, max}, 4]]
acommatick[x_] := {x, AccountingForm[x]}
commaticks[min_, max_] := 
 acommatick[#] & /@ FindDivisions[{min, max}, 7]
fewcommaticks[min_, max_] := 
 acommatick[#] & /@ FindDivisions[{min, max}, 4]
seagreen = 
 RGBColor[{46/255, 139/255, 
   87/255}];(also define some extra colors)
yellowgreen = RGBColor[{173/255, 1, 47/255}];
darkyellow = RGBColor[{204/255, 204/255, 0}];
(a very complex function for placing text in 3D:)
text3D[str_, location_ : {0, 0, 0}, 
  scaling : {?NumericQ, _?NumericQ} : { 1, 1}, 
  longitude : _?NumericQ : 0, elevation : _?NumericQ : 0, 
  tilt : _?NumericQ : 0, opt : OptionsPattern[]] := 
 Module[{mesh = 
    DiscretizeGraphics[
     Text[
      Style[str, opt, FontFamily -> "Georgia"("Times"), 
       FontSize -> 12(don't scale with ftsz)]], _Text, 
     MaxCellMeasure -> 0.04],
   rotmatrx = 
    RotationMatrix[longitude, {0, 0, 1}] . 
     RotationMatrix[-elevation, {0, 1, 0}] . 
     RotationMatrix[tilt, {1, 0, 0}]}, 
  Join[{EdgeForm[]}, 
   MeshPrimitives[mesh, 
     2] /. {x?NumberQ, 
      y_?NumberQ} :> (rotmatrx . (scaling~Join~{1} {x, y, 0}) + 
       location)
   (,{Black},MeshPrimitives[BoundaryMesh[mesh],1]/.{x_?NumberQ,y_?
   NumberQ}[RuleDelayed](rotmatrx.(scaling~Join~{1} {x,y,0})+
   location)REMOVE REM IF NEEDING OUTLINES, see https://
   mathematica.stackexchange.com/a/131842/43662)]]
twoYrDigitAbbrev[yr_] := 
 "[CloseCurlyQuote]" <> 
  StringTake[ToString[yr], -2](Show 1964 as '64)
twoDgNo[x_] := 
 NumberForm[
  x, {5, 2}](Show 3.1415923 as 3.14; no not use for numbers with 

over 5 digits)
numericOrPercent[num_, digits_ : {2, 0}] := Which[
  0 <= num <= 1 && NumericQ[num], 
  Style[PercentForm[num, digits], FontSlant -> Plain],
  NumericQ[num], Style[num, FontSlant -> Plain],
  True, num]
tblFm2Dgt[x_List, opt : OptionsPattern[]] /; Length@Dimensions@x > 1 :=
  TableForm[Map[twoDgNo[#] &, x, {2}], 
  opt](to make tables show two digits while exportable with built-in 

precision)
(define the chi-squared test)
chiSquareTest[obs_List, exp_List] /; 
  Dimensions[obs] == Dimensions[exp] := 
 Block[{t}, t = Total[(Flatten@obs - Flatten@exp)^2/Flatten@exp] // N;
  {Rule["chisqr", t], 
   Rule[pval, 
    SurvivalFunction[
     ChiSquareDistribution[
      Times @@ 
       Table[Dimensions[exp][[i]] - 1, {i, Length@Dimensions@exp}]], 
     t]]}]
expTable[u_List] := Module[(Create null hypothesis matrix)
  {rs = Plus @@ u,
   cs = Plus @@ Transpose[u],
   n = Total[Flatten[u]]},
  Transpose@Outer[Times, rs, cs]/n]
lineAndPoints[lst_List] := {Line[lst], 
  Tooltip[Point[#], #[[2]]] & /@ lst}
percent[n_] := 
 If[n > 1 || n < 0, "Erroneous use of percent.", 
  If[n == 1, "100%", StringTake[ToString[twoDgNo[n]], -2] <> "%"]]
SetOptions[AccountingForm, 
  DigitBlock -> 3];(Use AccountingForm to see 
numbers with commas and spaces every third decimal digit.)

I also have some functions for abbeviations according to the Blue Book citation system that legal practice uses, if anyone is interested I 'd gladly share.

Answer 6

The documentation for init.m is functional, if sparse. There are no Examples, and there is no Applications section.

The init.m documentation points to Wolfram System Setup under "Related Guides", but that topic apparently doesn't point back to init.m, or at least, not directly.

The "See Also" for init.m contains four items, three of which are not helpful in the least. Those three are wolfram, mathematica, and Mathematica, all of which appear to be largely nonsensical in this context.