By chaining yourself to a format preferred by a machine, you free yourself of having to understand how and why another human thinks the way they do and prefers what they prefer.
1) This is painful. There are tools to help, but the most effective means I've found are having a policy to only commit notebooks in a reset, clean state (enforced with githook).
2) I don't understand. I've written full testing frameworks for applications as notebooks as a means of having code documentation that enforced/tested the non-programmatic statements in the document. Using tools like papermill (https://papermill.readthedocs.io/en/latest/), you can easily write a unit test as a notebook with a whole host of documentation around what it's doing, execute, and inspect the result (failed execution vs. final state of the notebook vs. whatever you want)
3) Projects like ipynb (https://ipynb.readthedocs.io/en/stable/) allow you to import notebooks as if they were python modules. Some projects have different opinions of what that means to match different use cases. Papermill allows you have an interface with a notebook that is more like a system call than importing a module. I've personally used papermill and ipynb and found both enjoyable for different flavors of blending applications and notebooks.
> Project Management, Quality Control and even formal real-time system analysis
While powerful and topics that need to be taught somewhere, that's not the takeaways I would've expected from a masters in computer science. I suppose we're talking about a masters of software engineering, which makes those topics feel more relevant. Perhaps that shows the importance of program selection and concentration.
Correct. I specifically did not want an MSCS since I didn't think it would be very relevant for me.
TBH, I didn't intend to get a degree when I started. I took a couple of interesting courses, but then all the other ones that looked good (like real time systems analysis) had required prerequisites. Once you've taken those prerequisites, you might as well just take all the credits required for the degree.
Software Project Management was one of the required classes and it turned out to be one of the most interesting ones of all!
Just as a layperson often underestimates the true depth of a PhD's expertise in their field of study, many people often underestimate the skill of someone who has spent a similarly long time meditating on the "soft skills" that actually glue a good idea into a successful business.
That's not an argument against MBA's having hard skills. It's an argument for a finely standardized product.
MBAs are a commodity, but they do or at least can have hard skills. I've wasted plenty of time and money on subpar market entry and expansion that could have been saved had I worked with people with some theoretical background on those.
You could write an encyclopedic book of counter intuitive organizational dynamics. While I don't know that this is the case with all of them, perhaps MBAs could be understood as internalizing the combination of such an encyclopedia with a few others besides and gaining insight into how they interplay with supply line logistics.
The insight mostly comes from experiences; the knowledge of what to reference to find where to find where to find what to find could be (boringly) boiled down to rote memorization and distributed through your standard classroom practices.
Bulldozers breed vetocracies which breed bulldozers in turn. Stable, long lasting power counter-balances itself with a host of ongoing concessions to each side of this coin.
Choosing to recognize the causal impact of one's actions of one type on another's freedom of some type is itself a political decision. Being able to argue a causal chain of one action to another impact does not make it the sole narrative -- only a more likely narrative than some other non-coherent chain.
Your choice of raising your child under one religion directly impacts the cultural environment my child enters into at a minimum, if not the outright practices my child would be forced to participate in. The US government recognizes a freedom of religion and therefore does not recognize any impact from that freedom as an infringement on others.
My understanding is that a custom lambda image is the nuclear option; having everything fit cleanly into a normal lambda archive is the preferred option; and lambda layers are a type of middle ground if you've outgrown one but don't quite need the other.
> as if it is some highly abstract, complicating, high-level feature
But symbol calculus is a highly abstract, complicating, high-level system assembled out more reality-based systems beneath it. If it seems simple to you, you're just under the curse of knowledge.
I'm not sure what a "symbol calculus" is. Do you mean "lambda calculus"? I think that's a lot less complicated and abstract than a fabled machine with an infinite tape that's controlled by a transition graph of symbolic states. :)
And I don't know what a "reality-based system" is.
Oof, and to think one could helpfully inform the other! :) To be clear, I am a programmer, not a computer scientist, so my opinions are based off writing code and managing teams to write code that works, and less so about abstract machinations of computer scientific thinking.
For the record, I generally think that people exaggerate the complexity of Functional styles.
I think the reason that stateful, imperative code is the default is because that is how we tend to "think". Example, if I wanted to get a list of items for the grocery store, I get a piece of paper (instantiate an array), go through the list of things I might need (loop through a source array) and write down the ones I definitely need (append onto the destination array). If I run out of space, I get a new piece of paper and continue the process.
With that algorithm, I can stop and test each individual statement; I don't need to "think about it" because I can write and execute a tiny part of it (even if I'm only executing it in my mind).
In a functional style, I have to think more declaratively. Given all my items, filter out the ones that need replacing and give me that list. It's much easier to reason about abstractly, but I have no details about w how that's actually happening.
I think this kind of thinking is superior most of the time: I would rather read map.filter.reduce more than a for loop with branch statements any day of the week, but I am trusting the implementations of the mapping and filtering and reducing functions. Of course, for any non-trivial algorithm one is still passing a function into the map/filter/reduce anyway so I can still reason about those smaller stateful sections without worrying about the map/filter/reduce piping.
Perhaps I've never worked in a truly pure functional style so I may not be dealing with the mountains of abstractions others seem to complain about
Which without side effects can be very heavily optimized (probably even better) than imperative code? Hell, the pipelining inside GPUs, and CPUs are perhaps closer to lambda calculus than Turing machines.
It’s not like the machine code will look much closer to your C code either. That’s also a spell of “compiler writers and hardware vendors trying to uphold the view that C programmers are so close to hardware and that memory access is flat”.
At long last! I've been waiting for your emergence!