Interesting that the reviewer is using Linux 4.19, considering 4.18 was released on Sunday (2 days ago) so the merge window just opened for that version.

There is no way in heck that linus will merge some DIY home rolled crypto code into the kernel

I started following Phil’s guides a few months ago when I had the itch to write a kernel. After I had completed everything he had written with the 1st edition, he abandoned it to move on to a 2nd edition - just my luck. I’m glad he’s still pushing out regular updates with the 2nd edition, the 1st edition was starting to become out-of-date. For example - one of the most important parts for writing a kernel in Rust is the global_allocator attribute, which was stabilized a little over a month ago, with a number of changes that are incompatible with the 1st edition’s code (IIRC - it’s been a little while since I looked at the memory allocation post).

I’m interested to see how he approaches the memory management and remapping of the kernel in the 2nd edition. One thing that bothered me about the 1st edition was that he shows you how to implement a simple “bump” heap allocator, without a “free” function. Instead of completing that allocator and adding “free”, he instead linked to his other linked-list allocator without going into its implementation details. I scoffed and decided to write my own heap allocator, using the buddy allocation method. I even started writing a blog post about it - maybe I’ll get off my ass and finish it one of these days, I’m sure it would prove useful to someone.

Although it’s not as pretty, the column(1) (core?)util does something similar. Given the example input from the README for Miller, throwing it through column -s ',' -t produces this output:

county      tiv_2011    tiv_2012    line         construction
SEMINOLE    22890.55    20848.71    Residential  Wood
MIAMI DADE  1158674.85  1076001.08  Residential  Masonry
PALM BEACH  1174081.5   1856589.17  Residential  Masonry
MIAMI DADE  2850980.31  2650932.72  Commercial   Reinforced Masonry
HIGHLANDS   23006.41    19757.91    Residential  Wood
HIGHLANDS   49155.16    47362.96    Residential  Wood
DUVAL       1731888.18  2785551.63  Residential  Masonry
ST. JOHNS   29589.12    35207.53    Residential  Wood

Of course, you don’t get the processing language that Miller appears to provide for more complex data mangling. It looks like a very nice tool for that sort of thing.

I’ve been watching Jon Blow’s language design since he started in 2014, and I gotta say, he’s made some impressive leaps and bounds. The original “conceptual” talks[1] that don’t feature any of the code at all have a lot of great justification for his design decisions. Of course this video four years later as he’s actively been working on the project, and I’m interested to see how this has diverged from and expanded on his original vision.

[1] First talk, second talk.

I feel like this would be a great way to help teach someone how to play Dwarf Fortress. Cool project.

These are a lot of interesting pictures and diagrams - is there a video of a presentation to go with this?

Nice article. I must admin that I am a systemd fan. I much prefer it to the soup of raw text in rc.d folders. Finally, an init system system for the 1990s.

Link appears broken, but the cached versions work. Here’s a link to one:

https://archive.is/urHjP

You can form your own opinion here: https://github.com/xtermjs/xtermjs.org/pull/54

Contributors feeling entitled to have their patches merged is indeed an recurring Problem in OSS.

I’m an ASCAP member. I can’t think of anything good to say about this idea. But, as an ASCAP member. No thank you. We don’t need to replicate that model. Nope.

Oh man, the memories. Great video, thanks for sharing – I doubt I would have run across it otherwise.

Agreed wholeheartedly with everything on this list (esp. Docker and Nix) except for the Code of Conduct line. Sadly, we’re living in a time where assholes need to be explicitly uninvited.

I always thought it interesting how the GNU tools have this split-brain between emacs and vi keybindings. I know that readline (by default) uses emacs, but I believe you’re able to make it use vi-like keybindings instead (or maybe that’s just a feature of Bash?). The two tools I use daily that use vi keybindings are man and less. And then you can see GNU’s influence with info because they use emacs bindings.

All in all, it’s a pain and I’m a vim guy so beyond single-line editing on the command line, emacs bindings are completely foreign to me. As a result info pages are almost useless to me because I have no idea how to correctly navigate them. ¯\_(ツ)_/¯

While I love the fact that Microsoft is trying this, I somehow don’t believe that it will be a major success. There is already conan, buckaroo and hunter, and your OS’s package manager of choice. But how many people actually use these? And even if you wanted to use them, you might not be able to, because not all are supported by all build systems. What build systems, you ask? Well, you could use make, either with pkg-src directly or with the higher-level automake? Nah, scratch that, better go with premake. Or maybe try out ninja combined with meson, like all the other cool kids? Most people seem to use and dislike cmake. And the really daring are trying to bolt a module system onto C++. I think C++ is beyond saving because it has too many moving parts, and Microsoft won’t fix that. But then again, that’s probably not their mission, anyways.

If anyone wants a larger video than the embedded one, here’s a link to the browser-width player:

https://player.vimeo.com/video/248214009

Yeah, but can it run DOOM?

In my free time I’m trying to write an OS targeting little ARM microcontrollers (currently working with Teensy 3.6, and hopefully RPI0 soon enough). Work has finally quieted down so I hopefully have energy in the evening to continue.

This week, I’m still trying to get an LED to blink from the bare metal. I’m stealing using PJRC’s Arduino libraries for the Teensy 3.6 and incorporating a lot of it into my codebase. I’m learning a lot about the world of watchdog timers, crossbars, and confusing hardware defaults. It’s a lot of fun, even if the fun comes from complaining.

I’m still not sure what I want the OS itself to do, though. I know I want to

1. make it a toy project exploring stupid ideas (what if the filesystem was like JSON?)
2. make it easy to plug ‘n’ play user-space software with peripherals like GPIO

but everything else is up in the air. Maybe I’ll figure out what I want as I write it. I’ve never written a kernel or an OS before, so it’s all a learning experience.

One thing that really frustrates me about programming language landing pages is when the author foregoes showing any example of what the syntax looks like. This page even says:

A simple, familiar syntax optimized for readability: alignment and indentation, everything is an expression, separation with newline, simple grammar, optional type annotations…

What does that mean? The link on it leads nowhere, and the Github repository doesn’t have any clear examples that I can see.

I was playing around with a toy language I made in Rust. Here’s the program entry function, 50 lines. How readable is it?

fn run_program<P: AsRef<Path>, Q: AsRef<Path>>(
    path: P,
    dump: bool,
    optimize: bool,
    compile_only: bool,
    search_dirs: &[Q],
) -> Result<()> {
    let mut ast_tree = ImportAST::new();
    ast_tree.import_ast(search_dirs, path.as_ref())?;
    let ir_compiler = CompileIR::new(ast_tree);
    let compiler = CompileBytes::new(ir_compiler.compile()?);
    let fun_table = {
        let fun_table = compiler.compile().chain_err(|| "Compile error")?;
        // run optimizations
        if optimize {
            // TODO : Optimization groups
            OptimizePipeline::new(fun_table).optimize()
        } else {
            fun_table
        }
    };
    if dump {
        for f in fun_table.iter().filter_map(
            |(_, f)| if let &internal::Fun::UserFun(ref f) =
                f as &sbl::bc::Fun
            {
                Some(f)
            } else {
                None
            },
        )
        {
            eprintln!("- {} {}", &f.name, "-".repeat(69 - f.name.len()));
            f.dump();
        }
    }
    if !compile_only {
        let mut vm = VM::new(fun_table);
        let res = vm.run();
        // Dump the VM state on error if we're dumping code as well
        if res.is_err() && dump {
            eprintln!("- Begin VM state ---------------------------------------------------------------");
            vm.dump_state();
            eprintln!("--End VM state -----------------------------------------------------------------");
        }
        res
    } else {
        Ok(())
    }
}