Look at Imba. If you are strong enough to avoid cargo culting and try things which aren't popular, they are some of the best ways to build frontend apps out there: https://imba.io/
It's an init program — written in Rust — that changes the UID of an account (including home directory) inside the container to match that of the host. It takes care of corner cases such as what happens if there's a conflicting account, or when the user wants to run as root, or when chowning the home directory is too slow, etc.
For the past 6 years, I've operated a software engineering school[1] that uses ISAs and I have some thoughts about them. There are two main stated benefits to using ISAs (there are others, but those seem overblown):
a) commission based pricing (aka, incentive alignment pricing)
b) deferred payment
Of the two, imo the second is by far the most important thing for students. To the first bullet, I don't personally find commission based pricing to be all that incentive aligning. For example, it's not uncommon for me to advise someone to take a much lower offer because it seemed like a better long-term opportunity. This is in line with Sean's observation that quality education outcomes is difficult to reduce to salary numbers alone.
To the second bullet, the major problem of deferring all payments, however, is that you attract a lot of people looking for a shortcut. This is exactly the opposite attribute top employers are looking for. This is the "adverse selection problem" Sean mentioned.
Ultimately, the solution here is in selecting for the right type of students into the ISA-based program. Sean mentions that credit scores track with the type of students they're looking for. Other ISA-based programs have stated that they've found a secret sauce other than credit scores for detecting the right students.
We've found a different selection criteria:
We ask students to do a lot of work before we engage them with an ISA. I'm calling this model the ISA-later model, just so we can contrast this with an ISA-first model, which is what Sean and everyone else is doing.
An ISA-later program solves nearly all the problems associated with an ISA-first approach:
- adverse selection is mitigated since you have a long track record of student behavior and performance
- can still be egalitarian, without relying on credit scores or degrees or any socioeconomic markers
- still possible to defer all payments, without the lock-in of an ISA-frst approach
There are many other student-friendly benefits of an ISA-later model, but I'll stop here as this comment is getting long.
Show me your flowcharts [code], and conceal your tables [schema], and I shall continue to be mystified; show me your tables [schema] and I won't usually need your flowcharts [code]: they'll be obvious. -- Fred Brooks, "The Mythical Man Month"
SICP for CS and programming. That book (and its exercises) really instilled in me the thought patterns that drastically improved my programming skills and made me realize how important fundamental CS knowledge is to being a good programmer. What I learned from that book was: becoming comfortable with recursion, realizing the importance of abstractions, functional programming concepts and it gave me insights into how interpreters and the machine work.
I studied math in university and the book that really improved me mathematically was baby rudin. I really struggled with this the first time I worked through it and had to also fall back on Abott's analysis book, but after my first analysis course I worked through Rudin again and it just clicked. The exercises are really well chosen and the text is just so on point. Every sentence in the book is extremely carefully chosen and of fundamental importance to what Rudin wants to teach you.
It's really rare that you find textbooks that almost kind of have a certain magic to them, like you are directly taught by one of the greatest minds in that field. These two books definitely meet that criteria.
First of all, I agree there are gotchas. We have roadmap items that will eliminate this problem in the medium term.
I do however disagree that this is any worse than idle RDS hosts sitting around when you have no traffic, costing you huge sums for a service that is basically `apt-get install mysql-server` on top of EC2.
k0s is my personal favorite and what I run, the decisions they have made align very well with how I want to run my clusters versus k3s which is similar but slightly different. Of course you also can't go wrong with kubeadm[0][1] -- it was good enough to use minimally (as in you could imagine sprinkling a tiny bit of ansible and maintaining a cluster easily) years ago, and has only gotten better.
If you're tailing logs, can I suggest that you try out the Logfile Navigator (https://lnav.org). It really is possible to do better than tail/less/whatever when you just want to look at a local log file:
Very early on in my vim journey, I used to use fugitive[1], which is sort of a lighter equivalent of magit for vim. However, I found that too overkill and unwieldy. I never really found any benefits to forcing myself to stay inside vim to run some git command.
These days, I just use git in a tmux split rather than trying to force vim to show some arbitrary git UI. For a nice interactive git UI, I use tig[1]. Tig is essentially like fugitive/magic insofar as it allows me to interactively view a nice graphical log, stage/commit, traverse a file's historical blame, etc. It's a nicer UI compared to something like `gitk`.
I have these mappings in my `~/.vim/vimrc` for git/tig functionalities:
Humans have a larger neocortex compared to other mammals, which gives them more storage, working memory, and computational potential than other animals.
The curses of the human condition are anxiety and regret, the conditions that render people unable to engage in the present moment. The former is characterised as being stuck in the future psychologically, and the latter is being stuck in the past. Since neither the future or the past can be changed by obsessive thoughts in the present, these psychological conditions are a recipe for unhappiness, because happiness can only ever happen in the present moment, which is lost.
What characterises flow state and mindfulness is total absorption in the present moment.
What if animals that are not burdened by human quantities of neocortex, such as insects and canines, which exist in the present moment, are actually experiencing flow and mindfulness?
The spider weaves its web in perfect concentration, not stopping to contemplate, plan, or exercise executive judgement. Might not that be akin to flow?
The dog and the cat and the cow and the horse, given physical comfort, do not seem to worry about the future or regret the past. Might they not be blessed with a form of mindfulness that humans in the rat race rarely manage to experience?
Clojure's lispyness is massively underrated. At Hyperfiddle we have a fully reactive Clojure/Script dialect, backed by a functional effect system https://github.com/leonoel/missionary. Our reactive clojure can also distribute across the client/server system, like distributed map reduce. Imagine React.js but full stack, incremental view maintenance all the way from database views to DOM views as one streaming computation. We implement a custom analyser like core.async for full compatibility with host clojure, including preexisting macros, so it gets destructuring, control flow, higher order logic, it's a first class Clojure in every way. What you are measuring I think is that metaprogramming is hard, the books and papers about it are hard, the intersection of metaprogramming with functional programming isn't even well understood in research, and businesses don't invest in hard things so you won't get paid to learn any of this.
I was planning to start writing the software to analyze causations when I have 10k entries. But I recently started already. It turned out to become a new project that feels a lot like a javascript based jupyter alternative running in the browser.
