convolvatron

I've done animations at the Tcl layer before with composition of Tk objects. for little visualizations its just fine, certainly not AAA

every time I get to use lisp syntax I feel a sense of relaxation, as if the background stress of thinking about precedence and the meaning of all these magic sigils and control flow constructs just melts away and I can finally see clearly what's going on. my first professional programming language was lisp, and almost every single project in the 35 years afterwards was C style. but it still feels like home.

I have that same Bosch. for me its just for cutting down ply and making crates and janky stuff, but it has very little torque, tends to cut ragged (slow I guess?) and a yes a shallow cut. a better saw would help a lot here I think.

I always just defined these types in a per-platform portability header myself.

Im not saying arrival order isn't a key consequence of concurrency in many cases, it's just not the same as concurrency itself. I guess the point for me is that when we're programming or when we're using models, we define the partial ordering. so if an event arrives from outside and causes a message to be put in the queue, the read of that event by another thread is still after the external event.

so our job is really to kind of look at all the possible topological sorts of that 'after' ordering, and ensure that they are all correct, and if not, add additional edges by using locks or whatever mechanism.

kind of more interested are techniques like mvcc and crdt, which make _any_ causal ordering of events (topo sort) result in a meaningful answer.

but if you look at classical simd for example, we have concurrency (and parallelism) without additional constraints, because the threads are strongly synchronized at the hardware level.

I don't like the essential characteristic of concurrency being nondeterminism. its really that multiple processes are running concurrently. if we don't have serializing operations, we have arbitrary execution order. but if we do then we can introduce the necessary determinism while still being (largely) concurrent in evaluation. and if those logically concurrent processes are physically concurrent then we have parallelism. so the first is necessary but not sufficient for the latter.

so I find saying that we have one or the other to pretty misleading.

the sandwich shop in dogpatch has been closed for years. their building was remodeled for startups (kind of a meh patchwork of steel panels, some corten and some not), and they tried to move over a couple blocks, but the pandemic got them.

no, its not really learned helplessness, and I don't know the industry that well, but I move a certain amount of scrap and there's methheads all over the neighborhood where I work. once they started being more careful at the scrapyard the tweakers started selling their copper to a guy I call 'mr froggy'. he's around a lot of the time, and he's a larger scale copper thief. I don't know who mr froggy sells to.

I think you even need to be careful about working Al too much during installation. it will bend in one direction just fine, and even back another direction, but after that cracks are going to start developing.

requiring some kind of license doesn't really fix the problem of theft at all. it just adds layers of middlemen to collect up the copper from the layer below and further legitimize it. so it does reduce the street price for stolen copper, but since copper and stolen bikes (which also have almost no value now) are one of the few income sources available, it could conceivably increase the volume of stolen copper.

looks like the one time cost for doing a renovation is around $1m per car, and are funded by spot grants rather than the general budget. I was unable to find the overhead involved in ongoing maintenance, but it looks like killing the F line is already on the table.

the lab I was at got on this train right around the beginning of the sparc architecture. yellow pages. nfs based swap, nfs based boot. 10Mbit thinnet. we suffered for a few months and then moved to xterms for the cheap seats (which was a much better place to cut services) and went back to buying self-sufficient workstations.

the best was having everyone with a disk cross-mount each other. any failure snowballed into a global failure.

no one bothered to clone Sherline. Cheap mini mills and lathes that were the same cost, but were made out of actual castings and used more standard tools totally undercut Sherline.

the sherline designs aren't particularly notable, and they're pretty easy to replicate if you have working machine tools that are larger. any machinist could make a sherline mill or lathe, but without that floorspace and capex and skill, one really can't.

I spent overly long trying to learn on sherline tools and once I gave up and bought a Bridgeport and an old Logan, I realized that I was just banging my head against the limitations of the tools.

the value they had was that they were cheaper than the smaller version of the standard toolroom machines, and they were a way to bootstrap yourself without having the heavy power and the floorspace. so pretty much the storefront, not the IP. I still have their 4" rotary, and its actually not bad. the mill had a huge amount of flex in the column that made it pretty unusable for me unless you took really really tiny passes.

I had an old Unimat for a couple years, and while that was even _more_ dodgy than the sherline the fact that it was all steel and a combined mill/lathe made it a lot more interesting. would rather see some community standards for tooling on a platform like that. maybe a 50% larger so setup isn't so fiddly.

actually large programs that are persistent is where you really care. kernels and databases often use explicit allocators because there is so much policy wrapped up in allocation.

this goes back decades, its not just a feature of the 2020s. as a systems programmer I always want this, and the idea that allocator state should be completely hidden and implicit is shortsighted.

but yes, it is a bit onerous to pass around allocator(s). the real complaint that I have is that if 'malloc' is global and a compiler primitive, then we can do things like coalesce allocations and have compiler managed lifetimes when appropriate.

explicit allocators are an important lever, its not clear to me that we could never find a way to make them possible without the minor downsides.

I'm anti IP in theory and practice. If this results in undermining vengeful protection of the Annas and the Aarons of the world, I'm all for it. But it's not, is it. If the corpus and the models were all free, that would be lovely, and qualitatively quite different.

but its not, the old IP model is still intact, except these guys get an exception. and they get to scream bloody murder about distillation. they get to use their massive funding to try to draw a moat around that knowledge and expression with the goal of rent seeking from this point onwards. I'm not supposed to be able to access the original works anymore, but instead the proprietary, newly biased, blender output that contains a little bit of it.

also not at fan of what its doing to the creative process, but you're right here. that's on us for being so easily seduced and not being able to limit ai usage to solving rote problems instead of creative ones.

maybe its the other way around. my wife and I are pretty 'special', but when we step in to try to make up the different for each other we're a little more basically functional.

Im mildly confused as well, there is an even more immediate shortcut that I've certainly implemented before. in arp its not unusual to to just create a ip->mac binding from the source information in the ethernet header. where this potentially breaks down if we start looking at issues of trust. but its already the case in ND that we trust the endpoint to have executed the state machine to search for duplicates. so what's preventing us from doing the same thing here? maybe just layering concerns?

oh. I'm talking about authoring OS and boot loaders from an absolute blank slate. like starting from the world where you toggled them in from switches, and later by burning proms

until very recently you couldn't even do OS development without a boot loader, so asserting that that would be the last thing you would write is just nonsensical

in the bad olden times you definitely started to write your operating system for your new computer from the first instruction executed upwards. it wasn't at all common to have a comprehensive virtualization/simulation environment.

I just don't think it's gotten to the point that anyone is interested. I wonder if we did do a better job that the aggressive filtering and monitoring wouldn't naturally move down the stack.

for example we could completely obviate Facebook by having a standard mechanism for something like an rss feed. individuals or organizations could publish my stream(s) from their own leaf connections, set up cloud instances, or pay someone to host them. there could be a whole ecosystem of readers with various UIs and policy filters. people/organizations could add value by aggregating trusted streams or filtering them for content some people might find offensive. and at the end of the day it doesn't require people who just want to use it to set up persistent networking and storage.

in any case we just got suckered into handing the keys to the internet to companies like Meta and Google, which make vast amounts of money to control the discourse in corrosive ways. all because we bought into the notion that nothing is real unless someone is making a buck off it.

having a standard and a whole space of compatible programs doesn't preclude people from making lifestyle money selling filters and aggregators and content, but it kind of removes the Meta-style leverage over the whole system.

general issues aside, for me one of the issues with emacs is that for historical reasons there is a cut between elisp and C that's really high up and pretty ragged. ideally a large composable lisp project like emacs would have a very accessible continuum between the surface and the underpinnings.

so I don't think one can achieve that by maintaining 100% compatibility. a much smaller base system build with better semantics that was notionally compatible would be something I would be really excited to contribute to.

yes, it can be easier to have a central serializer for events, but that certainly makes things problematic for fault tolerance and basically excludes large-scale solutions. using an agreed-upon post-hoc ordering based on timestamps is certainly another way, but really only if you're working in a paradigm that lets you impose it (like mvcc) or doesn't care (like crdt).

personally I find when you view events in a distributed system as a partial order, its more liberating than confusing. its not unusual to assume that there is some kind of canonical event ordering that we have to preserve, when its often just not semantically important. so its a useless constraint that can impose complexity and limit the solution space. the partial ordering exposes the real causal constraints.

fwiw I think it would reduce a lot of friction for the end user and probably increase utilization quite a bit. my new take on this problem is to arrange that shared resources are dynamically associated with your environment, rather than being assembled into one giant shared environment. so that if you run a program on your laptop that uses large scale compute resources, those remote threads see the same OS view that a local thread would. still not a business but I think potentially valuable. its strange how many solutions fall into that space.

to me the goal of having 'ps' show everything in the cluster is kind of cute at best.

but yes, right now you install all kinds of services and support nodes, and distributed filesystems, and orchestration tools and software management tools and job schedulers. every cluster is a bespoke mess that takes a large staff to maintain and is always broken.

this is kind of the projection of web software onto hpc clusters.

in the 90s it wasn't nearly as hard to run a supercomputer because it was an integrated software platform. they were still a lot dodgier than the needed to be. but you could run a 64k node system with one support person, and there weren't really very many support tickets because things just mostly worked.

but I certainly can't imagine trying to do a company that solves this problem. or I should say I keep trying to and just seeing failure. part of the issue is that the people that you are selling to are personally and monetarily invested in the status quo. I don't think they _want_ to relieved of the burden of messing around with Kubernetes all the time, and having distributed filesystems that need to be nursed all the time, or having provisioning tools that have a 80% success rate and take hours to spin up a node.

I did a research SSI in the early 2000s. After getting it largely to work, we kind of put it aside. Why would we aspire to using 'ps' and 'ls' and 'mount' and such to manage our large scale systems? surely there was a better model.

20 years later people are still sshing into nodes to fuss around, and treating cluster nodes like pets. it still could be done pretty easily, I guess its not really in anyone's interest to invest the 2 years it would take. there is a lot more money to be made nibbling around the edges of the problem.

I don't think the neuro-symbolic model is going to dumb anything down at all. Cyc didn't end up producing anything useful, but the only reason an llm is able to do math at all is that it can keep throwing stuff at lean all day. personally I think that that synthesis will turn out to be more powerful than just llm with constraints, but I don't really work work in the field either.

I think the point is even stronger. alignment is really not very well defined, nor are the mechanisms used to provide it. from what I understand it's more of a statistically imposed bias than an impenetrable gate.

personally I would like to flip this around, all of this is a consequence of some really extreme notions about investment. its a tail-wagging-the-dog. the investment community is apparently in love with the idea of an AI-scale vehicle in and of itself. given the amount of power they have, this is funneling a massive amount of resources into something that while really very interesting, probably would never be able to realize proportionate gains without taking down the system that built it. what's the societal control on that.

my only argument here is that there isn't really any reason to avoid going through an emissions review if required. or to require that scrubbers be installed if necessary. the decision to just make an exception to the process for datacenters is more of a political statement about deregulation than anything else.