FLOSS virtualization hacker, occasional brewer

  • 11 Posts
  • 271 Comments
Joined 2 years ago
Cake day: June 9th, 2023
  • Alex@lemmy.mltoTechnology@lemmy.world•YouTube’s Deliberate Indifference Exposes Kids to disgusting ContentEnglish
    7·
    5 days ago

    When we first let the kids watch YouTube it was on the main TV with it’s own account. We have consistently monitored it and actively prune recommendations while slowly introducing them to the concept of “the algorithm”. From secondary school they pretty much need YouTube on their own PC’s for homework reasons and it’s harder to totally lock down - we use the family link controls to limit it a little but if they tried to get around them they could. The hope is we’ve at least prepared them a little before they have totally unfettered access to the internet.

    We did try YouTube kids a little but it was such a garbage experience we just blocked the app everywhere.

  • Alex@lemmy.mltoUK Politics@feddit.uk•UK still sending spy planes for Israel.
    32·
    23 days ago

    That’s certainly an assertion but even the MP who’s comment they got didn’t go that far. I’m not sure STW are the most neutral party to report this either.

    Sure they can designate targets, it’s one of its many roles which also include surveillance. If anywhere is deserving of keeping a close eye on its what’s currently going on in Gaza.

  • Alex@lemmy.mltoTechnology@lemmy.ml•Xiaomi releases an open-source 7B reasoning model that
    3·
    26 days ago

    I finally figured out the ramalamma runes to run stuff from hugging face. It sure does like to “think” through its problems:

     ➜  ramalama run huggingface://jedisct1/MiMo-7B-RL-GGUF/MiMo-7B-RL-Q4_K_M.gguf
Downloading hf://MiMo-7B-RL-Q4_K_M.gguf:latest ...
Trying to pull hf://MiMo-7B-RL-Q4_K_M.gguf:latest ...
 99% |███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████  |    4.36 GB/   4.36 GB  34.04 MB/s        0s 🦭 > what sort of coding capabilities do you have?
<think>

Okay, the user is asking about my coding capabilities. Let me start by recalling what I know. I can handle a lot of programming languages, right? But wait, I need to list the main ones without getting too technical. Frontend like JavaScript, HTML, CSS. Backend languages such as Python, Ruby, maybe Java or C#. Then frameworks and libraries: React, Node.js, Django, TensorFlow. Oh, and I can help with algorithms, debugging, and code optimization. Also, version control with Git. Should I mention specific examples where possible? Like helping with Python scripts or JavaScript functions. Don't forget to mention that I can explain concepts and assist with coding interviews. Wait, maybe add something about being updated with the latest trends. Also, emphasize that I can provide explanations and walk through code step by step. Avoid mentioning any limitations, like not having real-world execution. Make sure the answer is clear and covers the key areas without being overwhelming. Structure it with bullet points for clarity. Check for any recent updates in programming languages I should include. Yeah, I think that's covered. Alright, time to put it all together in a friendly, concise way.
</think>

I can assist with a wide range of coding-related tasks, including:

### **Programming Languages**
- **Frontend**: JavaScript (ES6+), HTML, CSS, React, Vue.js, Angular.
- **Backend**: Python, Node.js (JavaScript), Ruby, Java, C#, PHP, Go, Rust.
- **Data Science/ML**: Python (NumPy, Pandas, scikit-learn, TensorFlow/PyTorch).
- **Databases**: SQL (MySQL, PostgreSQL, SQLite), NoSQL (MongoDB, Redis).

### **Frameworks & Tools**
- Web Development: Django, Flask, Express.js, Spring Boot, React/Next.js.
- DevOps: Docker, Kubernetes, AWS/GCP/Azure, Git (and GitHub/GitLab/Bitbucket).
- Testing: Unit tests, mocking (with tools like unittest, pytest, JUnit).

### **Key Skills**
- Algorithm design, code optimization, debugging, and problem-solving.
- Code review, formatting, and refactoring.
- Generating code snippets, pseudocode, or explanations for specific tasks.
- Walk-throughs for complex projects (e.g., building APIs, sorting algorithms).

### **Additional Help**
- Coding interview preparation (examples, explanations, time/space complexity analysis).
- Concepts like OOP, REST APIs, design patterns, and best practices.
- Debugging assistance (e.g., interpreting errors, logic issues).

Let me know what you need! I can also explain ideas in simple terms or guide you through steps. 🚀
🦭 > Can you write me a short C function to reverse a string?
<think>

Okay, I need to write a C function to reverse a string. Let's see. Hmm, how do you reverse a string in C? I remember that strings in C are arrays of characters, so the idea is to swap the characters from the beginning and the end.

First, I should think about the parameters. The function will take a string pointer and its length. Oh right, because to know how long the string is. But wait, strings are null-terminated, so the actual length is one less than the size including the null character. But maybe the user will pass the correct length. Hmm, maybe the function should accept both the string and its length. Or maybe calculate the length inside the function. Wait, but calculating the length each time might be inefficient, especially for long strings. So perhaps the user should pass the length as an argument. That's better.

So the function signature would be something like void reverseString(char *str, int length). But wait, in C, the length of a string can be found using strlen(), but that includes the null terminator. Oh right, so the actual number of characters is strlen(str) - 1. Wait, no. The strlen function returns the number of characters before the null terminator, so for example, if the string is "hello", it's 5 characters, and the null is at index 5. So the length parameter for reversing should be the same as the return value of strlen(str). But if the user passes the full size of the buffer, maybe that's different. But perhaps it's safer to have the function take the length as an argument. Because if the user provides the correct length (including the null terminator?), wait no. When reversing, you don't want to mess with the null terminator. So maybe the function should reverse the characters up to the null terminator. So perhaps the function should first find the length of the string using strlen(), then reverse the first length characters. But then the user doesn't have to pass the length. Hmm. Let me think.

If the function is written to take the string and its length, the user has to make sure they pass the correct length (excluding the null terminator?), but maybe that's up to the function to handle. For example, if the user passes the correct length, then the function can swap the characters from 0 to length-1. So perhaps the function can be written as:

void reverseString(char *str, int length) {
    int left = 0;
    int right = length - 1;
    while (left < right) {
        char temp = str[left];
        str[left] = str[right];
        str[right] = temp;
        left++;
        right--;
    }
}

But then the user needs to calculate the length before calling the function. Like, int len = strlen("hello"); reverseString(str, len); That would reverse the first len characters, which are the actual characters without the null terminator. That makes sense. So the function swaps the characters up to the length provided. So the user is responsible for passing the correct length. But maybe in the example code, the user might just pass the string and the function calculates the length. Let me see. If the function doesn't take the length, then we can compute it inside the function. Let's see:

void reverseString(char *str) {
    int length = strlen(str);
    int left = 0;
    int right = length - 1;
    while (left < right) {
        char temp = str[left];
        str[left] = str[right];
        str[right] = temp;
        left++;
        right--;
    }
}

This way, the user just passes the string, and the function reverses it. That's probably better because the user doesn't have to compute the length. But then, what if the string is null? Well, we should handle that, but maybe for simplicity, the example code can assume the string is valid. Also, the function will modify the string in place, which is efficient. That's a common approach in C.

So putting it all together, the function would look like this. Let me test it in my mind. Suppose the string is "hello". The length is 5. Left starts at 0, right at 4. Swap 'h' and 'o' → "oleh". Then left 1, right 3: swap 'e' and 'l' → "olleh". Then left 2, right 2: stop. So reversed string is "olleh", which is correct. Yes.

So the answer would be a function that reverses the string in place using an in-place swap algorithm. The code would look like the second version, without the length parameter. That's better for the user because they don't have to compute the length. So the code is:

#include <string.h>

void reverseString(char *str) {
    int length = strlen(str);
    int left = 0;
    int right = length - 1;
    while (left < right) {
        char temp = str[left];
        str[left] = str[right];
        str[right] = temp;
        left++;
        right--;
    }
}

Wait, but what about strings that are not null-terminated? But in standard C, all strings are null-terminated, so this should work. So this code should work for standard C strings. The function reverses the string in place, which is efficient. The user can call it like: char str[] = "hello"; reverseString(str); printf("%s", str); which would output "olleh".

So that's the code. I think that's correct. Let me check for possible errors. For example, when the string has only one character. Then left and right are same, the loop doesn't run, correct. For empty string, but then strlen would be 0, right would be -1, loop doesn't run. That's okay. So yes, the code should work.
</think>

Here's a C function that reverses a string in-place:

```c
#include <string.h>

void reverseString(char *str) {
    int length = strlen(str);
    int left = 0;
    int right = length - 1;
    while (left < right) {
        char temp = str[left];
        str[left] = str[right];
        str[right] = temp;
        left++;
        right--;
    }
}

    How to use it:

    #include <stdio.h>

int main() {
    char str[] = "hello";
    reverseString(str);
    printf("Reversed string: %s\n", str);
    return 0;
}

    Output:

    Reversed string: olleh

    Explanation:

    1. The function calculates the string length using strlen().
    2. Two pointers (left and right) start at the beginning and end of the string.
    3. They swap characters (``) until the end of the string.

    This approach reverses the string efficiently with minimal memory usage (in-place reversal).

  • Alex@lemmy.mltoUK Politics@feddit.uk•After-work drinks in decline outside London, peers told
    4·
    1 month ago

    It used to be more common. Back in the 90s when I was working in an office we’d often head to the pub for Friday lunchtime and roll in later in the afternoon. Going along for a free lunch and a few beers with visiting sales reps was also pretty common.

    I couldn’t do it now - the thought of nursing a proto hangover before I’ve even got home seems insane in retrospect. God knows how much productivity used to be wasted due to work time tipples.

  • Alex@lemmy.mltoOpen Source@lemmy.ml•The UK Post Office should have insisted on an open source system
    26·
    2 months ago

    Care needs to be taken with big orgs like the NHS to not try and boil the ocean with massive IT systems. Concentrating on open interoperability standards allows for smaller more flexible contracts and the ability to swap out components when needed.

    Open source licences would be the ideal default although at a minimum the purchasing org should have a licence that allows them (or subcontractors) to make fixes without being tied to the original vendor.