fotcorn

That is a very editorialized title, original is "Bcachefs Lands Big Scalability Improvement, Disables Debug Option By Default".

Also note that debug is enabled by default, so Phoronix tested the use-case most end users would actually run.

Looking forward to the new benchmarks, I wanted a filesystem with good snapshoting support for a long time, it's nice to easily revert a broken Nvidia driver update...

In my experience, people do hack game engines all the time for game specific optimizations, fixes and special features. At least in the bigger AA/AAA games I've seen. We tried to sell our plugin as binary only (C++), but basically everybody wanted the source code to hack and extend it. So people wouldn't be happy with MPL.

I agree for other things, e.g. webdev, I never had to hack Django or Vue.js.

The game industry is notorious for using, but not contributing back to open source. I don't want to know how often the same bug in recast/detour has been fix in different games, and never upstreamed.

The Apache 2 license is incompatible with GPL2, you cannot have code under those two licenses in the same project. So they dual licenses it under MIT, which is compatible with GPL2.

The Rust project has the same problem, it's also dual-licensed under Apache2 + MIT.

You want Apache 2 because of the explicit patent grant, but at the same time you also want to allow GPL2 projects to use your code.

I worked with it quite a bit on my last job, and for me it's really the quality that is not there yet. One example is prefabs: They worked just fine in Lumberyard years ago. The first few releases of O3DE broke them (that was in 2021 I believe), because like almost every other subsystem, Amazon wanted to rewrite it from scratch. Seems like they released the new version in the latest release, but as you can see in this video from Gamesfromscratch, it still doesn't work: https://www.youtube.com/watch?v=5PAuR-pEz1w

Also, they are not great at marketing. For example, in the latest release notes, the main headline talking point is robotics, and not games.

I think the tech is actually good, I prefer both the component system and ScriptCanvas over Unreals component mess and Blueprints. It just needs much more polish. And a big game company trying to actually make a game.

I've been using Cursor quite a bit on my two current personal projects in Python and C++ respectively, and I think it's quite useful:

I haven't written a unit test by hand since I started using Cursor. Because it has the full codebase as context, it can easily generate unit tests. I would say the code is correct around 50% of the time on the first try? Otherwise, you can quickly submit a follow-up prompt to fix stuff. Obviously, it's still GPT-4 in the background, so hallucinations still happen.

I tried adding a simple feature to my interpreted custom programming language using the chat feature, giving the full codebase as context: The programming language already supported indexing into arrays, but not strings. I asked in chat what I need to change to make this feature work. It generated code and showed me in which files I have to add or modify existing code. Very impressive. Again, the code wasn't perfect, I had to do some minor adjustments like method names, but it understood my code, gave the right files to modify, and also proposed code that was almost correct. There is a beta feature that applies the proposed code changes to the codebase, but that did not work yet when I tried it (I am using an OpenAI API key, maybe it's related to that).

Overall, I think it is very helpful, especially when I am tired from $dayjob, but still want to do some coding in the evening. For me, it's much easier to formulate what I want to code in human language, instead of writing the code "by hand".

Caveat: Even if you use the OpenAI API key, ALL your code is sent to the cursor.so servers for prompt generation, indexing etc., even with "local mode" on. "Local mode" just changes a flag that cursor won't save code on their servers, but it's still sent there for processing. I assume this is a deal-breaker for most companies for now.

ROCm has HIP (1) which is a compatibility layer to run CUDA code on AMD GPUs. In theory, you only have to adjust #includes, and everything should just work, but as usual, reality is different.

Newer backends for AI frameworks like OpenXLA and OpenAI Triton directly generate GPU native code using MLIR and LLVM, they do not use CUDA apart from some glue code to actually load the code onto the GPU and get the data there. Both already support ROCm, but from what I've read the support is not as mature yet compared to NVIDIA.

1: https://github.com/ROCm-Developer-Tools/HIP

You can use OpenXLA, but it's not the default. The main use-case for OpenXLA is running PyTorch on Google TPUs. OpenXLA also supports GPUs, but I am not sure how many people use that. Afaik JAX uses OpenXLA as backend to run on GPUs.

If you use model.compile() in PyTorch, you use TorchInductor and OpenAIs Triton by default.

I think this is really just a naming problem. The Apache Software Foundation was founded for the Apache webserver, but today they have hundreds of projects unrelated to that. The same is true for the Linux Foundation.

And you can't scan eyeballs while it's charging.

Interesting counterpoint: https://www.reddit.com/r/gamedev/comments/qeqn3b/despite_hav...

Spoiler: 38% of bug reports from Linux users, 400 in total, but only 3(!) are actually Linux specific.

There is also a Hugging Face Space for some quick tests without downloading the model:

https://huggingface.co/spaces/facebook/seamless_m4t

In the BIOS of my Lenovo laptop (T13 Gen3 AMD) I can select how much of the RAM should be reserved as VRAM. I guess they are doing something similar.

ROCm and PyTorch recognize the GPU, as in, `torch.cuda.is_available` returns true, but I haven't actually run any models yet.

The maximum I can select on my 32GB RAM laptop is 8GB. Sounds like there are desktop AM4 mainboards where you can go up to 64GB.

One interesting thing I have seen being reported by `glxinfo` is auxiliary memory, which in my case is another 12GB, for a total of 20GB reported total available memory GPU memory. Unclear if this could be used by ROCm/PyTorch.

Ubuntu 22.04 LTS with Regolith Desktop on top, which is a great pre-configured i3 desktop environment. Not sure if there is something similar for sway yet, but stuck on X11 anyway thanks to Nvidia.

I got a base-spec MacBook Pro 16 inch with the M2 Pro chip from work last week. Before that, I was on my Linux workstation with an AMD Ryzen 3950x, a desktop CPU released 3.5 years ago.

The compile time for a debug build of LLVM and MLIR is basically the same on those machines, the desktop machine only winning by a little bit. Roughly 10 minutes. Yes, of course desktop vs. laptop is unfair, but it's also a 3.5 year old chip.

And if you really want all-out performance, there are still AMD ThreadRippers, which should easily beat an M2 Ultra in almost all multi-threaded workloads.

(Details on the benchmark run: Building LLVM from source using precompiled LLVM 15 downloaded from the official website, debug build, only clang;mlir;lld projects, using mold/sold linker on Linux/Mac respectively, ninja build tool).

I like to ask the following as a starting point for an interview:

What is the most interesting project you have worked on recently? Doesn't have to be work related, but should be relevant to the job, e.g. programming, not gardening for a developer role. Why was it interesting? What were the biggest challenges on that project? How did you solve those?

Will show if people are passionate about something specific, and also gives a general measurement on what they consider challenging, and a first insight into their problem solving skills. If the person goes into detail, go along and ask more questions. Very helpful to figure out how a person works. This should hopefully be a low pressure "just talking" question to get started and help people to calm down a bit.

    Location: UK (EU & UK work permit)
    Remote: Remote only
    Willing to relocate: No
    Technologies: C++, LLVM, Compilers, Linux, Rust, Unreal Engine
    Résumé/CV: Please email for PDF + LinkedIn
    Email: fotcorn@gmail.com

Looking for jobs using C++ or Rust. Interested to work on open source projects, for example compilers (e.g. LLVM), Linux related technologies like the kernel itself or the graphics stack, databases etc.

Seems like this also works with C++. This was my first time using GPT3, and first attempt at this, no fine-tuning, no cherry picking at all:

    Replace the $$dollar-quoted expressions$$ with the content described therein, or follow the directions they contain.

    main.cpp
    ```
    $$c++ includes for output$$

    $$Vec3 struct with three float members x, y, z. constructor. dot product implementation. $$

    $$main method which allocates two vectors, then prints the dot product of them to standard output$$
    ```

    Answer:

    main.cpp
    ```
    #include <iostream>

    struct Vec3 {
        float x, y, z;
        Vec3(float x, float y, float z) : x(x), y(y), z(z) {}
        float dot(const Vec3& v) const {
            return x * v.x + y * v.y + z * v.z;
        }
    };

    int main() {
        Vec3 a(1, 2, 3);
        Vec3 b(4, 5, 6);
        std::cout << a.dot(b) << std::endl;
    }
    ```

There is still some CryEngine related stuff left: https://github.com/o3de/o3de/tree/development/Code/Legacy

But it's getting less and less every day.

I wouldn't go as far as calling it a complete rewrite. The renderer (called Atom) is completely new, but many other things stayed the same. Our Lumberyard Gem required some work to port over, but that was mostly replacing old CryEngine stuff with the equivalent in the Lumberyard/O3DE API.

There is also coder.com which provides more or less the same thing (running Visual Studio Code in the browser).

The code is actually open source and you can run it on your own machine: https://github.com/cdr/code-server

Hint: Set the following environment variables before starting code-server to get access to the official Visual Studio Code extension marketplace. This is against the TOS of VSCode, but some extensions are missing/broken on the alternative marketplaces.

SERVICE_URL=https://marketplace.visualstudio.com/_apis/public/gallery

ITEM_URL=https://marketplace.visualstudio.com/items

Question: My understanding is that the Supreme Court is here to interpret the constitution and other laws. When it now decides that Oracle is right and APIs are copyrightable, can't the other parts of the government introduce a new law making APIs not copyrightable again?

  Location: Edinburgh UK
  Remote: Only UK
  Willing to relocate: No
  Technologies: Python, Django, Vue.js with TypeScript, C++/OpenGL/Vulkan/Qt, PyTorch/Tensorflow/Keras,   Devops (Kubernetes, ELK, Prometheus, etc.)
  Email: hnusername@gmail.com

10 years of software developer and system engineering experience, mainly in web development. Looking for everything from startups to big established companies with the technologies listed above. Send me an email for full CV.

I am running Pi-Hole at home (on a Ubuntu VM, no Raspberry Pi necessary). In addition I have a Wireguard VPN server which uses the DNS server from Pi-Hole. This way a have a system-wide ad blocker for my smartphone when connected to the VPN. The latency hit from this setup is barely noticeable.

> Council house dwellers made no comment about the accusations when we didn't ask.

The only available CPU from Ampere EMAG seems to be the 8180, so I think this workstation also uses this.

Wikichip: https://en.wikichip.org/wiki/ampere_computing/emag/8180

AnandTech: https://www.anandtech.com/show/14141/ampere-emag-in-the-clou...

TL;DR: 32 Cores, up to 3.3 Ghz boost, 32MB L3 cache, 125W TDP

Drone.io is a CI system with a minimal and very fast interface, especially in comparison to the monster that GitLab is.

I'd rather have AGPL licensed code or an open-core model with proprietary enterprise features (e.g. LDAP/Active Directory auth), but I completely understand that making money from open source software is hard (see similar changes with Redis/MongoDB).

I started to create the counterpart, a x86_64 bit emulator written in Rust: https://github.com/fotcorn/x86emu

Disclaimer: Almost no comments, unidiomatic Rust, tons of hacks. Currently can run the uncompress code of Linux and some initial startup code. Not much more than instruction decoding & execution and basic page handling is implemented, the rest of the hardware is missing.

Sadly I do not really have time right now to work on it. I am still torn if Rust helps more than it makes everything more complicated, but recent Rust version should have made some things I wrangled with much easier.

The default network plugin (canal) did not work for me (some strange error), switching to Weave fixed the problem. Somehow RKE fails when your ssh-key is added to an ssh-agent, you need to add the "--ssh-agent-auth" flag to RKE to make it work.

The rest worked great and fast (~5 minutes I'd say). I am currently looking into persistent volume solutions, Rook.io looks good but is still beta. Ingress is another thing I have to look into, probably just port forwarding from my router to one of the nodes running the controller.

The nodes are Ubuntu 16.04 with docker installed from the repos.

Running on my NAS at home:

* GitLab (GitHub + CI/CD replacement)

* FreeNAS (Storage server)

* Nextcloud (Dropbox replacement)

* Syncthing (Dropbox replacement, Nextcloud did not work properly on my android phone)

* In progress: Kubernetes cluster (just for fun, RKE + rook.io)

* My own notes/wiki/task tracker I will release real soon now (TM)

Thinking about setting up Gitea + Drone.io, GitLab is just too heavyweight for just using it as git Hosting + CI/CD.

Is the touchpad driver in the macOS kernel? If yes, the kernel itself is open source, would it be crazy to try to extract the driver from there and make it Linux compatible?

Other question: When are you actually using the touchpad? I use my notebook 99% of the time with a screen + keyboard/mouse.

Next question: Can we get to the level of a Macbook touchpad only with software? Is there no magic sauce inside the hardware itself? How does the touchpad feel when installing Windows or Linux on the Mac?