After reading this and thinking through the problem, I've realized that, at least for non-trace-level logging, I should invert the dependency, and expose the logger as a wrapper... wait a second, is this a monadic pattern!?!?
foo = function(params) ...
foo_with_logs = Logger(foo)
foo_with_logs(params)
//results in something like
//foo called with (params)
//foo result: (results)
while
Logger(foo) looks a lot like the unit operation, i don't think foo_with_logs(params) is like the bind operation
Yeah that's closer we want something that follows this signature:
bind = m a -> (a -> m b) -> m b logger a = logs -> (a, logs) result = foo_with_logs(params) => params -> logs -> (result, logs) 
One pattern I quite like is using f# computation expressions to build up a series of operations to perform, which I can then pass conditionally into a function that either just executes those, or into one that executes each step and logs it in sequence. It's somewhat comparable to the interpreter pattern in OO languages. It also allows you to easily change out the "interpreter" to do different things, like only log the start and end of the operation flow, or trace each individual function call, or have it log how long each step took, etc.
Monads are very cool for error handling though. Just having result monad that is defined as
result a = a | error bind :: result a -> (a -> result b) -> result b
bind error _ = error
bind a fn = fn alisp is both older and better than the portable assembler for unix (mostly useful for making new garbage collectors so it's a nice language but in an ideal world we would have infinite-memory computers that don't need these)
yeah it's neat but many languages include exceptions and they end up doing a lot of the same shit that error monads do
That one has the drawback of unwrapping and re-wrapping the result at each step though, which usually doesn't really matter, but can be a problem in a hot loop.
the standard cope here is that The Compiler Will Definitely Figure This One Out™
Which is where the interpreter pattern comes in, to short circuit the evaluation.
let evaluate currentValue remainingFunctions =
match currentValue with
| Ok a ->
match remainingFunctions with
| h::t -> evaluate (h a) t
| [] -> currentValue
| Error _ -> currentValueTwo most common programming advices:
If by "using" C you also count embedding compiled bytecode from another language in a C byte array and passing that to the interpreter (written in C), yeah sure.
Really depends on what is meant by "enough". The soydevs have to raise their standards.
"the compiler is smarter than you" does not paint the full picture because it's way better than you at some things (extremely specific micro-optimizations) and completely useless at other things (not making your algorithm run in O(n!))Two most common programming advices:
- Python is fast enough
- Compiler is smarter than you
I hope they play along nicely
python actually is fast enough if your program is i/o bound and you don't do something extremely retarded, which happens to include an incredibly large number of programs
All python really needs to be fast at, is calling c/c++ libraries.
the compiler is a tool that can automatically apply a number of advanced optimizations that assembly programmers stay away from because it makes shit really hard to understand, and no human is capable of consistently and efficiently making all the logical jumps that smart compilers make when they are optimizing code, which is why they are frequently called "smarter than you"
Yes, humans are smarter than compilers, BUT not with the local optimizations, most of the time. Instead macro optimizations are what humans are good at. Like not using an O(n^2) algo when you can do an O(n * log(n)) one. (Well, that still has other caveats, but I digress).
and such optimizations often matter a bit more in the grand scheme of things than how exactly you juggle your registers
it's like that in an overwhelming number of programs; even many video games spend a lot of their wallclock time telling the gpu what to do, because most of the number crunching is happening on there