Richard W.M. Jones

At least 4 companies are working on server-class chips, targeting "Xeon-like" performance. Of course without actual hardware to test you should take those claims with a grain of salt for the moment. If you want a cheap, low-end single board computer you can use right now, then I'd go for either the Vision Five 2 or the Sipeed Lichee Pi 4A. Performance won't be that great, but it'll run Fedora, Debian, Ubuntu or Yocto distros pretty much out of the box. I'm working on a Hifive Unmatched vs VF2 vs Sipeed vs Raspberry Pi 4B performance comparison right now, which will appear on https://rwmj.wordpress.com

Seconding "Starting Forth" and "Thinking Forth". After that, Jonesforth (https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/) is an excellent example of Literal Programming that starts with an Assembly listing and bootstraps into a complete usable Forth system. No better way to learn Forth than to actually implement one...

> I'm not saying that yosys is a replacement for Vivado Actually, you kinda did: >>> Please let's kill off Vivado once and for all. [...] There are open source tools for programming FPGAs, and they are really great too: https://rwmj.wordpress.com/2018/03/17/playing-with-picorv32-...*

Thanks. This was what I was expecting. Although, I was hoping FFI was not the answer http://rwmj.wordpress.com/2011/09/21/which-foreign-function-interface-… Richard Jones is fairly erudite in the art and industry (one of the authors of http://gchandbook.org/ and quite proficient around various programming languages in general) and if he says Haskell FFI is painful to work with I get a really bad feeling. I was hoping the answer would have been "There is this stream computation library that is really neat and just works...".

Not to imply he's an expert, but author seems to have more than a week's experience writing Haskell. He linked to a blog post[1] from 2011 about writing the libguestfs bindings in several languages, including in Haskell. I'm unfamiliar with the library, but some googling seemed to imply it was >1kloc for the Haskell bindings, which probably took some time. [1] http://rwmj.wordpress.com/2011/09/21/which-foreign-function-interface-…

Those are numbers from 7 years ago, so they're beginning to get a bit stale as people start to put more weight behind having frame pointers and make upstream contributions to their compilers to improve their output. People put it at <1% from much more recent testing by the very R.W.M. Jones you're replying to [0] and separate testing by others like Brendan Gregg [1b], whose post this is commenting on (and included [1b] in the Appendix as well), with similar accounts by others in the last couple years. Oh, and if you use flamegraph, you might want to check the repo for a familiar name. Some programs, like Python, have reported worse, 2-7% [2], but there is traction on tackling that [1a] (see both rwmj's and brendangregg's replies to sibling comments, they've both done a lot of upstreamed work wrt. frame pointers, performance, and profiling). As has been frequently pointed out, the benefits from improved profiling cannot be understated, even a 10% cost to having frame pointers can be well worth it when you leverage that information to target the actual bottlenecks that are eating up your cycles. Plus, you can always disable it in specific hotspots later when needed, which is much easier than the reverse. Something, something, premature optimisation -- though in seriousness, this information benefits actual optimisation, exactly because we don't have the information and understanding that would allow truly universal claims, precisely because things like this haven't been…

I found this nbdkit demo for visualizing filesystem IO interesting - https://rwmj.wordpress.com/2018/11/04/nbd-graphical-viewer/

It tries to be both a filesystem and a database and fails miserably at both. Entries layout is a total mess that not even Microsoft pays attention to anymore. Relevant: Why the Windows Registry sucks … technically https://news.ycombinator.com/item?id=32275078 https://rwmj.wordpress.com/2010/02/18/why-the-windows-registry-sucks-t…

The author published an update: https://rwmj.wordpress.com/2023/02/06/frame-pointers-an-important-upda…

> I am fascinated by Forth, but every time I've tried to learn it I haven't really "got it". Try reading Jonesforth, a literate Forth implementation in one x86 assembly file and one Forth file. You can read it top to bottom and it will explain how everything works step-by-step. https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/ Github mirror: https://github.com/nornagon/jonesforth

From the "rant" rwmj just posted a link to: https://rwmj.wordpress.com/2010/02/18/why-the-windows-registry-sucks-t… >This misses the point: the Registry is a filesystem. Sure it’s stored in a file, but so is ext3 if you choose to store it in a loopback mount. The Registry binary format has all the aspects of a filesystem: things corresponding to directories, inodes, extended attributes etc. > The major difference is that this Registry filesystem format is half-arsed. The format is badly constructed, fragile, endian-specific, underspecified and slow. Anyway, file systems and databases are essentially similar, the point revolves more around the poor implementation of the Registry (whatever it is).

The main thing that would be of interest to me: - Have they replaced/improved the NT kernel [1]? - Have they replaced the ancient registry? [2] The answer to either was not to be found. I'll bet windows 11 will still be a backwards-compatible mess if the answer to either is `no`. [1]: http://blog.zorinaq.com/i-contribute-to-the-windows-kernel-we-are-slow… [2]: https://rwmj.wordpress.com/2010/02/18/why-the-windows-registry-sucks-t…

Original repository and introductory article: http://git.annexia.org/?p=jonesforth.git;a=shortlog https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/

I think this was the first line of the forth in the library of an older version of jonesforth (https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/), but now I can only find it in my port: : \ IMMEDIATE #IB @ >IN ! ; \ We can now comment! Implementing a forth system is unbelievably fun because of gems like this.

The tooling around libguestfs, a library for manipulating disk images that is typically used with KVM/Qemu based virtualization, is implemented in OCaml; the library itself is implemented in C. https://rwmj.wordpress.com/2017/06/04/new-in-libguestfs-rewriting-bits… http://libguestfs.org/

We live in a world where MongoDB is at the butt-end of all Database and ACID jokes. But the award should go the Windows Registry, a Key-Value store that combines the drawbacks of a half-assed filesystem with the advantages of piping your database to /dev/null. A Database would be capable of using an index to traverse all the keys. The Registry does a linear lookup at each pathnode. There is a good blogpost [https://rwmj.wordpress.com/2010/02/18/why-the-windows-registry-sucks-t… that details the insanity of a database that managed to be worse than MongoDB at the lowest level of jokes before MongoDB was even invented.

Found this blog with someone who bought an FPGA devkit[1] for £260 and managed to boot Linux on it[2]. [1] https://rwmj.wordpress.com/2016/07/25/risc-v-on-an-fpga-pt-1/ [2] https://rwmj.wordpress.com/2016/07/26/risc-v-on-an-fpga-pt-4/

Jonesforth is pretty minimal bootstrap https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/

[Disclosure: I spend a (not too large) _portion_ of my time on the OpenStack Compute project, so adjust my comments for bias.] Please. You seem to be making the same mistake, that many make on blogs and news websites, of exclaiming "containers are the future!" while both VMs and containers have their place and use-cases. I'd rather suggest you read the below. (Since I'm linking to a blog, quick background about the author: Rich is one of the long-time contributors of KVM-based Virtualization stack and the lead author / maintainer of libguestfs.org) https://rwmj.wordpress.com/2013/06/19/the-boring-truth-full-virtualiza…

Since this was posted, the FAT LFN patents has expired, and the license for the TianoCore FAT drivers was changed not long afterwards. (I am the guy who also posted https://rwmj.wordpress.com/2016/03/30/tianocore-uefi-now-has-a-free-fa… Of course, the same is not true for exFAT.

http://hirudov.com/oric/ or http://www.oric.org/software/ or type all kind of old basic games: https://rwmj.wordpress.com/2009/05/25/your-computer-80s-computer-magaz…

Done! https://rwmj.wordpress.com/2016/10/15/fedorarisc-v-is-finished/

That problem is mostly because ARM SoCs don't even have the concept of a standardised bootloader or dynamic device discovery like x86 chipsets which means every SoC needs it's own custom bootloader and it's own custom kernel where the available devices must be hardcoded. See basically any single board ARM computer which suffer from the exact same problem. This is why the community forms around the specific device rather than the architecture in general. ARM's openness ironically makes it unsuitable as an open software plaftorm whereas on x86 you just put your iso on a flash drive and it works pretty much everywhere. BIOS/UEFI might be bloated but at the very least it actually achieved what it set out to do, meanwhile we are still waiting for the ARM SoC manufacturers to adopt a standard. Source: https://rwmj.wordpress.com/2013/08/08/bring-back-the-bios/

How about the Gigabyte MP30-AR0, apparently actually available to consumers through this one retailer?: https://www.xcase.co.uk/products/gigabyte-mp30-ar0-with-appliedmicro-x… It seems Richard WM Jones has got RHEL running on it: https://rwmj.wordpress.com/2016/03/08/gigabyte-mp30-ar0-flashing-uefi/

https://rwmj.wordpress.com/2015/12/06/inspection-now-with-added-prolog… is pretty interesting. LuaJIT uses logic programming extensively in its optimization pipeline IIRC, but I don't know of any articles on it (just Mike Pall on newsgroups).

Erlang's binary matching is beyond awesome, and OCaml has a pretty good implementation of it as well (Bitstring) [1]. Cool thing about Elixir is of course that awesome Erlang binary handling is available and very easy to use. Lots of people have been lobbying for something like this in Rust, given its low-level orientation, but there's been resistance to the idea from the core devs, who want it to be done using syntax extension. 1. https://rwmj.wordpress.com/2010/02/03/on-the-awesomeness-of-ocaml-bits…

it doesn't go into specifically exploiting your machine but the infamous Jones Forth is ~1000 lines of assembly and ~a billion lines of comment explaining the assembly and this gets you into a functioning Forth, then it starts writing everything else in forth, including IF, WHILE, DO UNTIL... which shows how you can use the parsing words to write new language features. https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/

Red Hat's Richard Jones (who is also often commenting on Hacker News) does a lot of system programming in OCaml (mostly VM management-related I think): https://rwmj.wordpress.com/tag/ocaml/

jonesforth is a nice literary programming tutorial for making a forth using x86 assembly; and then forth - the same approach would work for implementing it in js, C or other languages. https://rwmj.wordpress.com/2010/08/07/jonesforth-git-repository/