harvey

Pros of Linux

• Massive community support and extensive documentation
• Wide hardware compatibility and driver support
• Proven stability and performance in various environments

Cons of Linux

• Complex codebase with a steep learning curve for new contributors
• Slower development cycle due to its size and need for thorough testing
• Higher resource requirements for full kernel compilation

Code Comparison

Harvey:

void
main(int argc, char *argv[])
{
	rfork(RFNAMEG|RFENVG|RFFDG|RFREND);
	boot(argc, argv);
}

Linux:

asmlinkage __visible void __init start_kernel(void)
{
	char *command_line;
	char *after_dashes;

	set_task_stack_end_magic(&init_task);
	smp_setup_processor_id();
	// ... (more initialization code)
}

Harvey is a smaller, more focused operating system inspired by Plan 9, while Linux is a full-featured, widely-adopted kernel. Harvey aims for simplicity and modern design principles, whereas Linux prioritizes compatibility and broad hardware support. The code comparison shows Harvey's concise initialization process compared to Linux's more complex startup routine.

Pros of Serenity

• More active development with frequent updates and contributions
• Comprehensive GUI implementation with a desktop environment
• Broader feature set, including a web browser and various applications

Cons of Serenity

• Larger codebase, potentially more complex to understand and contribute to
• Higher system requirements due to GUI and additional features
• Less focus on POSIX compatibility compared to Harvey

Code Comparison

Harvey (Plan 9-inspired system call):

long
sys_open(char *name, unsigned long omode)
{
    Chan *c;
    c = namec(name, Aopen, omode, 0);
    if(waserror()){
        cclose(c);
        nexterror();
    }
    fd = newfd(c);
    poperror();
    return fd;
}

Serenity (POSIX-like system call):

ErrorOr<FlatPtr> Process::sys$open(Userspace<const Syscall::SC_open_params*> user_params)
{
    VERIFY_NO_PROCESS_BIG_LOCK(this);
    auto params = TRY(copy_typed_from_user(user_params));
    auto path = TRY(get_syscall_path_argument(params.path));
    return open(path->view(), params.options, params.mode);
}

Both systems implement their own unique approaches to system calls, with Harvey following a Plan 9-inspired design and Serenity adopting a more POSIX-like interface.

Pros of ReactOS

• Larger community and more active development
• Aims for Windows compatibility, potentially more familiar to users
• More comprehensive documentation and user guides

Cons of ReactOS

• More complex codebase due to Windows compatibility goals
• Slower development progress due to reverse engineering challenges
• Potentially more vulnerabilities due to mimicking Windows architecture

Code Comparison

ReactOS (C++):

NTSTATUS NTAPI NtCreateFile(
    PHANDLE FileHandle,
    ACCESS_MASK DesiredAccess,
    POBJECT_ATTRIBUTES ObjectAttributes,
    PIO_STATUS_BLOCK IoStatusBlock,
    PLARGE_INTEGER AllocationSize,
    ULONG FileAttributes,
    ULONG ShareAccess,
    ULONG CreateDisposition,
    ULONG CreateOptions,
    PVOID EaBuffer,
    ULONG EaLength)

Harvey (C):

int
kopen(char *path, int mode)
{
    Chan *c;
    c = namec(path, Aopen, mode, 0);
    if(waserror()){
        cclose(c);
        nexterror();
    }
    // ...
}

The code snippets show different approaches to file handling, with ReactOS closely mimicking Windows APIs, while Harvey uses a more Unix-like approach. ReactOS's code is more complex due to Windows compatibility, while Harvey's is simpler and more aligned with Plan 9 principles.

Pros of Haiku

• More active development with frequent commits and updates
• Larger community and contributor base
• Better documentation and user guides

Cons of Haiku

• Larger codebase, potentially more complex to navigate
• Steeper learning curve for new contributors
• Longer build times due to project size

Code Comparison

Harvey:

void
main(int argc, char *argv[])
{
	USED(argc);
	USED(argv);
	print("Hello World\n");
	exits(nil);
}

Haiku:

#include <iostream>

int
main()
{
	std::cout << "Hello World" << std::endl;
	return 0;
}

Both projects aim to create alternative operating systems, but they differ in their approach and implementation. Harvey focuses on a Plan 9-inspired system, while Haiku aims to recreate and improve upon the BeOS experience. The code comparison shows a simple "Hello World" program in each project's preferred language and style, with Harvey using C and Haiku using C++.

Haiku has a more established ecosystem and active community, which can be beneficial for long-term development and support. However, this also means it may be more challenging for newcomers to contribute significantly. Harvey, being smaller, might offer more opportunities for impactful contributions but may lack some of the resources and support available in the Haiku project.