Loper OS

Unfortunately you can't get the LEDs any more - they were originally from LED printers and those all now use infrared LED arrays. I'm actually working on something similar, and am even using a few VB scanner mechs in development (driven by a raspberry Pi). For further background, they were developed from an earlier system called the "Private Eye" - still a few references to them on the web e.g. [0]. I've built a circuit to drive one from a Pi Zero - amazing gadgets for 90's tech. [0] https://www.loper-os.org/?p=752

Great link for this, thanks. I had suspected some different ordering might already be called for given the need for e.g. RAM training. That [version of?] pi booting is much more filename-oriented than all of the partitioning I have seen documented for a Rockchip [ http://www.loper-os.org/?p=2295 ].

If you're serious about increased typing speed you're probably better off switching to a two-handed chording system http://www.loper-os.org/?p=861&cpage=1#comment-16162 . Alternative layouts for conventional non-chorded typing don't seem to be worth the disruption.

> Fink has assigned one team to develop the open-source Machine OS, which will assume the availability of a high-speed, constant memory store. Another team is working on a stripped-down version of Linux with similar aims; another team is working on an Android version, looking to a point at which the technology could trickle down to PCs and smartphones. I was hoping for a second there that somebody at HP had read about Loper OS and Stanislav Datsovskiy's ideas[1], or even about Symbolics LISP machines (great article on the frontpage today[2]), but nope, looks like they are just gonna repeat the same insanity of the past fifty years instead of actually doing something that will progress the field of computing. [1] http://www.loper-os.org/?p=284 [2] https://news.ycombinator.com/item?id=7878679

EDIT: Expanded my question about Mike's opinion of FP. This perspective from a compiler developer lends credence to Stanislav Datskovskiy's rants about the importance of the underlying CPU architecture. Stanislav has done some work on a new dataflow-based CPU architecture (http://www.loper-os.org/?p=846). I wonder why Mike considers the usual blend of concepts provided by FP languages to not be worthwhile. After all, FP languages that don't allow reassignment of variables are in SSA form already, unless I misunderstand what SSA form is.

That might be (though if you browse under 'Hardware' or 'LoperOS', you'll find relatively recent posts; his updates are generally scarce throughout in any case) - I'd say this is one of those really long-term (indeed, vaporware as of now) projects that might not make it, but hey. In any regard, I'm quite sure the author himself sees this as a really long-term affair and treats it as a free-time-after-work kind of thing. [0] I mean for what he's set out to accomplish, it's a huge undertaking. Perhaps an over-ambitious overkill, but I for one try to follow his (frustratingly infrequent) updates because (1) it's a really interesting idea and (2) I like his perspective and I think some of the people here might share a subset of his views (it's not difficult to spot them, as he rants relatively often;). [0] http://www.loper-os.org/?p=562

Excellent question. See this thread on my site, the story of how I kicked the Mathematica habit: http://www.loper-os.org/?p=42&cpage=1#comment-2746

> I think this should not be underestimated. You're right but it's broader than "C folks like terseness." C is famously hard to read. Before Perl we used to joke that C is a write-only language: you can't understand what your own code means just weeks later. Combine this with its lack of bounds checking, pointer arithmetic, and other dangerous features, and the result is a language that's macho for geeks: it's hard, it's dangerous, but it's small and it's fast. It's a motorcycle for nerds. Ada is a tank. Nerds get to establish dominance over lesser nerds by doing hard stuff in hard languages and making it fast. This bestows nerd street cred: geek cred. Ada was used by contractors who needed stuff to work and money was no object. C was used by hackers to do cool hacker stuff that was perceived to be fast and low level. It's not low level: machine architectures haven't resembled the C abstractions since the 1970s. https://queue.acm.org/detail.cfm?id=3212479 A modern low-level language would be some brain-bending combination of APL and Lisp with n-dimensional tensor algebra or something. But C looks cool and hard and you will blow both feet off if you don't hold it just right. And there are good free versions. So you can be poor and still demonstrate your machismo. Result, a software industry requiring weekly multi-gigabyte online patches, keeping millions in work. C makes programmers a cheap fungible commodity. https://www.loper-os.org/?p=69

I think a computer system checking most of those boxes could be made with software on modern PC hardware. I think that is possible as long as we keep check of ourselves to continue following the principles. Your list of qualities remind me of what I liked most about the Amiga and its OS. The (desktop) system was manageable by one person and you learned as you went. It did not "mollycoddle" the user, and it did not require you to spend years of study (as with Unix, Linux and the internals of MS-Windows). One older principle (1967) that is related to several of yours, and apparently largely forgotten these days is "The principle of least astonishment" [0]. Other lists of computing principles I've come across that I find interesting (even if I do not always agree): Loper-OS's seven laws of Sane Computing [1], and the principles of Permacomputing [2]. [0]: <https://en.wikipedia.org/wiki/Principle_of_least_astonishment> [1]: http://www.loper-os.org/?p=284 [2]: https://permacomputing.net/Principles/

This whole article is great, but the first 2 paragraphs really resonated with me: http://www.loper-os.org/#selection-29.0-44.0 Here's an excerpt: Sadly, the above scenario is more truth than fiction – for computer enthusiasts. There is a particularly cruel discrepancy between what a creative child imagines the trade of a programmer to be like and what it actually is. When you are a teenager, alone with a (programmable) computer, the universe is alive with infinite possibilities. You are a god. Master of all you survey. Then you go to school, major in “Computer Science,” graduate – and off to the salt mines with you, where you will stitch silk purses out of sow’s ears in some braindead language, building on the braindead systems created by your predecessors, for the rest of your working life. There will be little room for serious, deep creativity. You will be constrained by the will of your master (whether the proverbial “pointy-haired boss,” or lemming-hordes of fickle startup customers) and by the limitations of the many poorly-designed systems you will use once you no longer have an unconstrained choice of task and medium. To my knowledge, no child grows up “playing doctor” and still believes as a teenager (or even as a college student) that an actual medical practice resembles that activity. Likewise, no one has a fully functional toy legal system to play with as a child, and as a result goes into law. On the other hand, “adult” programming, seen from afar, is…

> It should have had protocol-level technologies for preserving historic data, for search, for offline use, for authoring and publishing. [...] He was talking about the lack of protocol-level solutions for resilience of the Web. That's completely at odds with what Kay actually advocates for. His position is strongly aligned with the "mechanism, not policy" philosophy. That is, what he advocates for is less of what you want, not more. This is apparent from that Dr Dobbs interview, his work with VPRI, back to his OOPSLA speech in 1997. To wit: > HTML on the Internet has gone back to the dark ages, because it presupposes that there should be a browser that should understand its formats. [...] You don't need a browser if you followed what this staff sergeant in the Air Force knew how to do in 1961. Just read it in, it should travel with all the things that it needs, and you don't need anything more complex than something like X Windows. Kay has always sat on the diametrically opposite site of the table as those favoring the Principle of Least Power—one of the most underappreciated tenets of computing. Tim Berners-Lee called it out in Axioms of Web Architecture: > At the other end of the scale is the weather information portrayed by the cunning Java applet. While this might allow a very cool user interface, it cannot be analyzed at all. The search engine finding the page will have no idea of what the data is or what it is about. The only way to find out what a Java…

I'll cons this onto my list of reasons why Lisp "failed". Other explanations are: Worse is Better: https://www.jwz.org/doc/worse-is-better.html The Bipolar Lisp Programmer: https://groups.google.com/forum/#!topic/comp.lang.lisp/eicqvm3GXiE The Lisp Curse: http://winestockwebdesign.com/Essays/Lisp_Curse.html Where Lisp Fails: http://www.loper-os.org/?p=69 Lisp is still my language of choice. I'm more productive in it than other languages (C, Java), not because I know the other languages less well, but because they're less expressive. So, for me, Lisp fixes the world. Why aren't people using it? There are three things often missed. (1) People's choice of programming languages perhaps isn't as rational as they might like to believe. There's a large amount of personal taste involved. For a personal project, that's no barrier, you can use your favourite language, but if you're working with a dozen other people, Lisp is unlikely to be adopted because more people on the team will prefer Java, C++, or Python. Multiply over all the commercial projects and you can see why you can't build a career around Lisp programming. (2) There are accidents of history. When DEC decided to discontinue the PDP-10, the days of the hacker community built around it were numbered. Those involved then went on to build Lisp machines, but they were undercut by cheaper, commodity hardware which ran Unix. Then, the AI winter arrived. It was bad for Lisp, but Prolog fared far…

You mean that out of all the things in this combinator [0] flavored abstract rewrite system [1], programmed via a symmetrical [2], forward-inferenced [3] typed language, exposing modula-2 style per-code-block compilation control [4], all designed to support a content centric [5], natively networked [6] global computing environment with sovereignty-hard siloing capabilities [7], the most difficult part to understand is the naming scheme? Edit: In the early Urbit docs [8] there was a nigh ad nauseam emphasis on the "stupidity" of the project. What the epiphany of careful inspection revealed was that this stupidity was not that of intellectual deficiency, but rather opposition to "cleverness" of the kind that tends to foster (and infest) Urbit's peer group of deep stack [9] rebuilds. One of the most insightful comments I've heard after springing Urbit on unsuspecting PL professionals was (paraphrased): "It [Urbit] does all the things we've said we wanted, in the worst possible way." All words are equally made up until grounded in referents. The question is, are the Worfian shorthands new words provide worth the cost [10] of expanding the symbol table, as compared to the interpretation overhead of translating new concepts into old? Under the burden of internalizing all the content linked below and more, I judge new vocabulary justified. [0] http://www.ucombinator.org/ [1] https://en.wikipedia.org/wiki/Abstract_rewriting_system (ARS being the most mechanical of the pure…

Using a device that is designed to localize movement just to the fingers - through chording no less - strikes me as completely backwards ergonomically. That's a good point on chording mechanics, and useful to compare with Douglas Engelbart's piano-like chording keyboard[1]. Also, if the current design permits minimal movement precision-grip use (vs. crossing into power grip), it may not be too bad. The tricky design challenge of the Twiddler is that it's intended for portable, handheld use. E.g. I met Steve Mann using an earlier Twiddler rev. some years back as part of his then-current cyborg rig. Perhaps it's best to look at this device as another design compromise for a portable keyboard, instead of a desktop keyboard replacement. I wouldn't necessarily want to write a novel on my phone, for similar suitability-to-purpose reasons. [1] http://www.loper-os.org/wp-content/mw/motd_ui.jpg [2] Image in [1] via http://www.loper-os.org/?p=861

Lisp had a condition system that was very clever. You still had to write the code, but you were able to separate the problem, the handling, and the restart. This is the problem that comes up in many languages and which needs to be dealt with: "Because each function is a black box, function boundaries are an excellent place to deal with errors. Each function--low, for example--has a job to do. Its direct caller--medium in this case--is counting on it to do its job. However, an error that prevents it from doing its job puts all its callers at risk: medium called low because it needs the work done that low does; if that work doesn't get done, medium is in trouble. But this means that medium's caller, high, is also in trouble--and so on up the call stack to the very top of the program. On the other hand, because each function is a black box, if any of the functions in the call stack can somehow do their job despite underlying errors, then none of the functions above it needs to know there was a problem--all those functions care about is that the function they called somehow did the work expected of it. In most languages, errors are handled by returning from a failing function and giving the caller the choice of either recovering or failing itself. Some languages use the normal function return mechanism, while languages with exceptions return control by throwing or raising an exception. Exceptions are a vast improvement over using normal function returns, but both schemes…

Don't forget http://www.loper-os.org/ by far my favourite.

Here's an old blog post that explores that topic at least with one specific example: https://www.loper-os.org/?p=861 The gist is that keyboards are optimized for ease of use but that there could be other designs which would be harder to learn but might be more efficient.

Either way, expect no HyperCard (or work-alikes) from Apple. But how about other vendors? What about open-source projects? Nothing there, either. Oh, there is no shortage of attempts. And all of them are failures for the same reason: they insist on being more capable, more complexity-laden than HyperCard. And thus, none of them can readily substitute for it. https://www.loper-os.org/?p=568#selection-660.0-660.5

Without unconditionally endorsing the content of this blog (especially the more recent parts of it) you may find this post interesting: http://www.loper-os.org/?p=4003

well, it should be lisp all the way down https://www.loper-os.org/?p=42

The quote is from an old blog post: http://www.loper-os.org/?p=42#:~:text=Clojure%20is%20the%20gutted%20an… The blog post itself is not very informative, but the quote is poetic, memorable and perfectly captures the sentiment of some Common Lisp enthusiasts towards Clojure.

1. The book of law should have a fixed number of words, written in stone in the constitution. Side effects: a) you want to pass a new law? Pick one in the book to get rid of. b) magically, the enforcement budget and the size of the fat leech that feeds off of it (the government) remains constant. See "The Advantage of a Dragon" by Stanislaw Lem [1] 2. A law should always (with the possible exception of those in the constitution) have an expiration date, voted with the law, with a maximum of 10 years, at which time the law should get re-voted on if it turns out it was actually useful to society. [1] http://www.loper-os.org/?p=3725

not op but for me structured editing is one of the biggest pluses when it comes to editing lisp code. here is a good example of what i mean [0]. btw autolisp standard formating is kind of an anti-example of good lisp formating. in emacs lots of excellent tools exist to make parantheses an extremely helpful feature [1] [0] https://m.youtube.com/watch?v=D6h5dFyyUX0 [1] http://www.loper-os.org/wp-content/parphobia.png

> the Cr50 provides a controlled and user-controlled The Cr50 is as far from user-controlled as you can get. It can MITM your keyboard, reflash your firmware, and obeys only the holder of the private key corresponding to `LOADERKEY_A`: http://www.loper-os.org/?p=2433 If the Chromebook is Google's take on laptops, then Cr50 is Google's take on the IME.

True, though the process of establishing the trust and authenticity around digitally signed artifacts is not as widely established or disseminated as it is with print media. Also, establishing what a signature means often requires out-of-band information. I really like the concept of annotations for a signature that would communicate the signer's relationship to the work: http://www.loper-os.org/?p=1545

The "fungible programmer" theory [0] is one of the better explanations for the unpopularity of languages like Haskell and Lisp. Ultimately, making software that's large enough will become an organizational problem as well as technical one, and developers will get funged into being blub programmers [1], though RoR is a pretty nice way to do that all things considered. I would argue Go was designed for maximum fungibility. [0] http://www.loper-os.org/?p=69 [1] http://www.paulgraham.com/avg.html

Can you clarify what number you mean by “a lot” and/or cite some research to corroborate this claim? You quote one article [0], which has been received by the Clojure community with almost unanimous disagreement, as the author himself acknowledges (in less than friendly words). That article in turn contains little factual information and lots of expressive verbiage. In my experience, this opinion is very much in the minority, albeit a vocal one. [0]: http://www.loper-os.org/?p=42

They already have a Google Management Engine in the chromebooks. It's called an "H1" chip: http://www.loper-os.org/?p=2433 It's connected to the auxiliary lines on one of the USB-C connectors. Tickle it the right way and it will happily overwrite the boot firmware -- so long as the image you give it is signed by Google. It will do this without any intrusion into the chassis. Very convenient for, say, airport security inspectors, who would arouse suspicion if they took the time to open the case. Plug in the magic USB dongle, press the power button, the deed is done. There were a precious few aarch64 chromebook models without it, but they've all been discontinued.

I come back to this article every now and then http://www.loper-os.org/?p=861

Might be some in the comments on http://www.loper-os.org/?p=861 ...