ths's comments

Hardware resources are definitely an issue. That's why we generally recommend using remote development environments, which aren't as resource-constrained as the local dev machine. Making that comparably smooth to the local dev experience (e.g. for live reloading of services without rebuilding containers) needs some clever tooling (which is partly the reason we're building our product).

With production-like remote dev environments, you get the same capabilities as your CI environment, but can run test suites ad-hoc (and without having to spin them up and tearing them down for every test run).

There's no fundamental reason why CI environments should have capabilities that individual dev environments can't have—it's all a matter of automation in the end.

> The real challenges, like determining seed data etc is too project specific to be abstracted away.

Very much agree with that! The generic stuff (dependencies, parallel processing, waiting for things to spin up etc.) should be taken care of by the tooling, but without constraining the project-specific stuff (which is highly individual).

Good automation around preparing/provisioning the testing environment is a necessary companion to the testing tools/frameworks themselves.

Most commonly, fully-capable testing environments aren't available during the inner loop of development (where the dev setup can usually only run unit tests or integration tests for 1-2 services + a database).

Because of this, people tend to rely solely on their CI pipelines to run integ/e2e tests, which can slow things down a lot when one of those tests fails (since the write/run/debug loop has to go through the CI pipeline).

As an industry, I think we should start taking automation and developer productivity more seriously—not least when it comes to writing and debugging tests for complex distributed systems. The more we can lower the marginal cost of writing and running tests, the more effective our test suites will become over time.

Shameless plug: My company (https://garden.io/) is developing a framework and toolchain to bring the full capabilities of a CI pipeline to the inner loop of development, so that developers can efficiently run all/any test suites (including integ/e2e tests) in their personal dev environments.

We do this by capturing the full dependency graph (builds, deploys, tests, DB seeding etc.) of the system in a way that can power CI, preview environments and inner-loop development.

The motivation behind Garden was that, like you, we had built our own home-grown kubernetes dev environments, but felt like there should be a polished, general-purpose framework + tool for this sort of thing.

Garden supports in-cluster building, using buildkit or kaniko.

This way, you don't need to have Docker or k8s running on your dev machine as you're working.

It also automates the process of redeploying services and re-running tests as you're coding (since it leverages the build/deploy/test dependencies in your stack).

We also provide hot reloading of running services, which brings a similarly fast feedback loop as with local dev.

The idea is to have a dev environment that has the same capabilities as the CI environment, and to be able to run any/all of your tests without having to go through your CI system (which generally involves a lot more waiting).

But as we know (or at least currently believe), the separation of disorders into "hardware" (non-moral/impersonal) and "software" (moral/personal) is ultimately an illusion: The material substrate for our personality is precisely our neurobiology.

For example, ΔFosB overexpression in the Nucleus Accumbens following repeated reward stimulus is "the most significant biomolecular mechanism in addiction since its viral or genetic overexpression (through chronic addictive drug use) in D1-type medium spiny neurons in the nucleus accumbens is necessary and sufficient for many of the neural adaptations and behavioral effects (e.g., expression-dependent increases in self-administration and reward sensitization) seen in drug addiction" (https://en.wikipedia.org/wiki/FOSB#Role_in_addiction)

If we reach a point where we also find sufficiently convincing neural correlates for the more "high-level" aspects of addictive psychology and personality, wouldn't that eventually lead to us treating the whole complex in non-moral terms?

My feeling is that we intuitively choose the conceptual structure that we feel is most functional, given our state of knowledge. Morality is just another model for predicting and interacting with the behaviour in question, albeit less formal and more heuristic-based.

I haven't tried Evil, in my last emacs phase it wasn't mature yet IIRC - maybe I should give that a go and see if it tips the balance yet again.

Sublime is really pretty, and has great functionality out of the box.

Ultimately, vi/vim's contribution is the modal editing method (and derived things like motions), which can be transplanted to any other IDE or editor that cares to support it. But for the fundamendals - editing and switching between files - I've so far found vim to be the cleanest, most natural vim.

I do see your point that anarcho-capitalism isn't really anarchism, though. The societies they envision are radically different.

A state is not necessary for enforcing contracts - that could be done by private parties, as in anarcho-capitalism. Also: Cooperatives can exist within a capitalist system, but the converse is not true. So I guess it comes down to whether or not all property as defined by the status quo should be redistributed or reallocated, presumably by force; if that were not the case, there wouldn't really be any disagreement between left-anarchists and anarcho-capitalists, right?

Yeah, I agree. That was inaccurate on my part. What I said really only applies to the code management side.

    So under its expressive covers, everything about Clojure is strongly
    conservative, with a core overriding bias towards protecting
    programmers from mistakes.

I had fun reading Yegge's post, as with most of his posts. But the part about Clojure really missed the mark. Which is a shame, given Yegge's arguing for lisp in the past and Clojure being a really cool, viable lisp for getting stuff done in the 21st century.

While this is obviously a matter of taste, I do like vim's minimalism in that you start off with a simple core with sensible defaults and just add any features you want (I use tcomment, command-t, and fuzzyfinder for switching buffers - that's pretty much it, my .vimrc is less than one page). I found vim much easier to get into than emacs (which I'm currently using for most heavyweight coding sessions) where the defaults are (imho) not as sensible and you have to dig through tons of stuff that comes bundled with it, instead of understanding everything from the beginning and building from there. Of course, it's great to be able to extend emacs with elisp to do any stuff you feel is missing, and I've generally felt it easier to integrate the whole dev experience (minus the browser) into it than with vim - but such usage was of course never in harmony with vim's philosophy in the first place.

On top of that the whole "language of editing" and combining noun,verb,adjective commands, etc... doesn't really appeal to me because I'm too visual when I'm editing code. I can't stop to think about the right semantics about what I want to do, I just do it visually.

Like the rest of vim, these things just become muscle memory - you will completely stop thinking about what command to use after a bit. The reward is getting all those micro-level text editing tasks done with fewer keystrokes, minimizing the time you spend typing and therefore the disconnect with the thought that preceded the typing. I think this dynamic is really great when you get into the zone and want to let stuff flow out with as little neuromuscular obstruction as possible :P

I think the vi/vim editing model is a genuinely important contribution to text editing technique, much more so than vim the program, but of course you can use vim keybindings in lots of other editors and IDEs and still get the core benefits, assuming the most important vim-powers have been implemented.

Scheme

  (let ((x 2) (y 3))
    (let ((x 7) (z (+ x y)))
      (* z x)))

  (let [x 2 y 3]
    (let [x 7 z (+ x y)]
      (* z x)))