General Programming Discussion
Hi! I'm having a bit of a struggle with VSCodium. I'm not sure what I did, but I can't access the liveserver in my browser, and the extensions won't load to download them. I keep getting "Error fetching extensions. Failed to fetch" So that's been frustrating. Are there any fixes? What's a good VSCodium alternative I could try?
I've made a very simple and primitive JavaScript canvas engine that is simply not dependent on time, as in it assumes that `t = 1` in the formula `v = u + at` - `v` is the current velocity, `u` the initial velocity and `a` is acceleration due to gravity. Now, the issue with this method is that if the value of gravity, or velocity is large enough that the object it should collide, it just goes right through it. Now, I have been told that if time was a parameter, we could just increase the frame rate and dilate the time to resolve this, but this would mean that the engine would no longer be deterministic - as in, the simulation would not work out the exact as it we assumed it to be, owing to hardware and software requirement like decimal point handling and precision. How can we deal with this issue on this simple deterministic engine, and improve collision detection?
www.ogre3d.org
OGRE has grown to become one of the most popular open-source graphics rendering engines. It’s been 2 years since 2.3.0 and almost a year since the last 2.3.x release. It’s about time for 3.0.0! - Ogre to OgreNext name migration - Dealing with ABI mismatches: AbiCookie - ABI Semver - Move to C++11 and general cleanup
The GNU Compiler Collection (GCC) support for the C23 programming language standard is now considered "essentially feature-complete" with GCC 15. As such they are preparing to enable the C23 language version (using the GNU23 dialect) by default for the C language version of GCC when not otherwise specified. Preparations are now underway to set the default C language version of GCC to GNU23 as the GNU dialect of C23. Or in other words, implying -std=gnu23 when no other C standard is specified.
gustedt.wordpress.com
This new edition has been the occasion to overhaul the presentation in many places, but its main purpose is the update to the new C standard, C23. The goal was to publish this new edition of Modern C at the same time as the new C standard goes through the procedure of ISO publication. The closest approximation of the contents of the new standard in a publicly available document can be found here. New releases of major compilers already implement most of the new features that it brings.
So far, I've followed a simple Tor interceptor tutorial on YouTube, while strictly adhering to C2x with every warning flags enabled - not that it is the optimal way to go about learning the language. I may have, or may not have inadvertently used improper C2x, but I've used `typedef` aggressively to slightly mimic Golang. Almost a year ago, I had blindly translated a C++ Vulkan tutorial to C, and I didn't understand a single thing about anything graphics-related - framebuffer, swapchain, etc. Now that I am learning it again from scratch, I also wanted to know what to learn next, as well as some of the job opportunities that I can explore.
RINA offers a lot of
This is a simple experimental Lisp compiler, written in uLisp, that will compile a Lisp function into RISC-V machine code. You can run the compiler on the RISC-V core of a Raspberry Pi Pico 2 (or another RP2350-based board)
www.qt.io
We are thrilled to announce the release of Qt 6.8, packed with support for new desktop, mobile, and embedded platforms, hundreds of improvements, and exciting new features to boost your development experience and meet the needs of demanding applications. For this release we have focused on improving and stabilizing existing functionality. With over 500 bug fixes and performance improvements since Qt 6.7, your existing code will run better without changing a single line. On macOS, Qt Quick applications now integrate with the native menu bar, and for a native Windows 11 look they can use the new Fluent style. Resizing Quick windows is snappier on macOS with Qt 6.8, and on Windows the application start-up time has been improved by changing the default font database to DirectWrite. Several modules that were under technology preview have been completed: Qt Graphs, Qt HttpServer, and Qt GRPC are promoted to be fully supported from this release on. Thanks to the feedback from our users we were able to finish those modules with substantial improvements since their initial introduction as technology previews.
cross-posted from: https://lemmy.ml/post/21033409 > In the book authored by K.N.King, there's this example: > > ::: spoiler **viewmemory.c** > > ```c > /* Allows the user to view regions of computer memory */ > > #include <stdio.h> > #include <ctype.h> > > typedef unsigned char BYTE; > > int main(void) > { > unsigned int addr; > int i, n; > BYTE *ptr; > > printf("Address of main function: %x\n", (unsigned int) main); > printf("Address of addr variable: %x\n", (unsigned int) &addr); > printf("\nEnter a (hex) address: "); > scanf("%x", &addr); > printf("Enter number of bytes to view: "); > scanf("%d", &n); > > printf("\n"); > printf(" Address Bytes Characters\n"); > printf(" ------- ------------------------------- ----------\n"); > > ptr = (BYTE *) addr; > for (; n > 0; n -= 10) { > printf("%8X ", (unsigned int) ptr); > for (i = 0; i < 10 && i < n; i++) > printf("%.2X ", *(ptr + i)); > for (; i < 10; i++) > printf(" "); > printf(" "); > for (i = 0; i < 10 && i < n; i++) { > BYTE ch = *(ptr + i); > if (!isprint(ch)) > ch = '.'; > printf("%c", ch); > } > printf("\n"); > ptr += 10; > } > > return 0; > } > ``` > ::: > > For some reason, when I try to enter `addr` variable address as the parameter, it has a segmentation fault error. However, in the book's example and the screenshot from this [site in Hangul](https://ziegler.tistory.com/84), there's no such error? > > When I try using `gdb` to check the issue, here's what I get: > > :::spoiler gdb > ```console > $ gdb ./a.out --silent > Reading symbols from ./a.out... > (gdb) run > Starting program: /home/<username>/Desktop/c-programming-a-modern-approach/low-level-programming/a.out > [Thread debugging using libthread_db enabled] > Using host libthread_db library "/gnu/store/zvlp3n8iwa1svxmwv4q22pv1pb1c9pjq-glibc-2.39/lib/libthread_db.so.1". > Address of main function: 401166 > Address of addr variable: ffffd678 > > Enter a (hex) address: ffffd678 > Enter number of bytes to view: 64 > > Address Bytes Characters > ------- ------------------------------- ---------- > > Program received signal SIGSEGV, Segmentation fault. > 0x000000000040123a in main () at viewmemory.c:31 > warning: Source file is more recent than executable. > 31 printf ("%.2X ", *(ptr + i)); > (gdb) > ``` > ::: > > What is going on? By the way, I am using Guix, if that matters in any way. Here's the output for `ldd`: > > :::spoiler ldd > ```console > $ ldd ./a.out > linux-vdso.so.1 (0x00007ffecdda9000) > libgcc_s.so.1 => /gnu/store/w0i4fd8ivrpwz91a0wjwz5l0b2ralj16-gcc-11.4.0-lib/lib/libgcc_s.so.1 (0x00007fcd2627a000) > libc.so.6 => /gnu/store/zvlp3n8iwa1svxmwv4q22pv1pb1c9pjq-glibc-2.39/lib/libc.so.6 (0x00007fcd2609c000) > ``` > :::
Recently I wondered what I get in term of C++ features for upgrading my system from version 13 to 14 of GCC... Now, of course - a lot of bug fixes. Its surely a good idea to upgrade. But that doesn't answer my question. So a quick look at C++ compiler support showed that there is some interesting features, and mostly first C++26 support becoming available is one of them. Other features are more important to me though.
In my journey to learning C, I've come across header files, which are used to (I'm assuming) define a prototype for the source file, as well as structure modules. This feature, in my opinion, is pointlessly not just redundant, but possibly a source for pitfall. The same information can probably be extracted from the source code, if not for the restrictions of the language specification in C. Say, if I have a GTK project, I will have to use the preprocessor directive, that will require the use of GTK headers that look something like `#include <gtk/gtk.h>`, and they're usually in the system path. How do modern languages, like Rust, Zig or Go deal with this situation, where shared libraries are used?
Vulkan 1.3.296 is out as the first spec update in nearly one month. Given the time that has passed there are more bug fixes than usual but there is also a prominent new extension: VK_EXT_device_generated_commands. It has been worked on by Valve's Linux graphics driver developers along with engineers from Intel, AMD, NVIDIA, Collabora, and others. This new extension allows for the GPU device to generate a number of commands for command buffers.
Is there a way to scale the Lightness in OKLab/OKLCH color space, so it becomes identical to lightness in CIELAB? I want use OKLab to create tonal palettes, that requires a change in lightness scale since OKLab's lightness scale perfoms poorly in this regard.
pierre-couy.dev
cross-posted from: https://lemmy.pierre-couy.fr/post/678825 Hi ! I've been working on this article for the past few days. It would mean a lot to me if you could provide some feedback. It is about implementing a physico-chemical simulation as my first attempt to write a shader. The code is surprisingly simple and short (less than 100 lines). The "Prerequisite" and "Update rules" sections, however, may need some adjustments to make them clearer. Thanks for reading
www.qt.io
Two-dimensional vector graphics has been quite prevalent in recent Qt release notes, and it is something we have plans to continue exploring in the releases to come. This blog takes a look at some of the options you have, as a Qt developer. In Qt 6.6 we added support for a new renderer in Qt Quick Shapes, making it possible to render smooth, anti-aliased curves without enabling multisampling. The renderer was generalized to also support text rendering in Qt 6.7, and, in the same release, Qt SVG was expanded to support a bunch of new features. And there is no end in sight yet: In Qt 6.8 we are bringing even more vector graphics goodies to the Qt APIs. In this blog, I will share some details on the different ways vector graphics can be used in Qt, as well as the benefits and drawbacks of each.
I'm really bad at keeping my dependencies up-to-date manually, so dependabot was great for me. I don't use github anymore though, and I haven't really been able to find a good alternative. I found Snyk, which seems to do that, but they only allow logging in with 3rd party providers which I'm not a big fan of. Edit: seems like Snyk also only supports a few git hosts, and Codeberg isn't one of them.
Taking accurate screenshots with Puppeteer has been a real pain, especially with pages that don’t fully load when the standard ``waitUntil: load`` fires. A real pain. Some sites, particularly SPAs built with Angular, React, or Vue, end up half-loaded, leaving me with screenshots where parts of the page are just blank. Peachy, just peachy. I've had the same issue with `waitUntil: domcontentloaded`, but that one was kind of expected. The problem is that the page load event fires too early, and for pages relying on JavaScript to load images or other resources, this means the screenshot captures a half-baked page. Useless, obviously. After some digging accompanied by a certain type of language (the *beep* type), I did find a few workarounds. For example, you can use Puppeteer to wait for specific DOM elements to appear or disappear. Another approach is to wait for the network to be idle for a certain time. But what really helped was finding a custom function that waits for the DOM updates to settle ([source](https://urlbox.com/puppeteer-wait-for-page-load)). It’s the closest to a solution for getting fully loaded screenshots across different types of websites, at least from what I was able to find. Hope it will help anyone who struggles with this issue.
I initially wrote this as a response to [this joke post](https://lemmy.world/post/18144181), but I think it deserves a separate post. As a software engineer, I am deeply familiar with the concept of rubber duck debugging. It's fascinating how "just" (re-)phrasing a problem can open up path to a solution or shed light on own misconceptions or confusions. (As and aside, I find that among other things that have similar effect is writing commit messages, and also re-reading own code under a different "lighting": for instance, after I finish a branch and push it to GitLab, I will sometimes immediately go and review the code (or just the diff) in GitLab (as opposed to my terminal or editor) and sometimes realize new things.) But another thing I've been realizing for some time is that these "a-ha" moments are always mixed feelings. Sure it's great I've been able to find the solution but it also feels like bit of a downer. I suspect that while crafting the question, I've been subconsciously also looking forward for the social interaction coming from asking that question. Suddenly belonging to a group of engineers having a crack at the problem. The thing is: I don't get that with ChatGPT. I don't get that since there's was not going to be any social interaction to begin with. **With ChatGPT, I can do the rubber duck debugging thing *without* the sad part.** If no rubber duck debugging happens, and ChatGPT answers my question, then that's obvious, can move on. If no rubber duck debugging happens, and ChatGPT *fails* to answer my question, then by the time at least I got some clarity about the problem which I can re-use to phrase my question with an actual community of peers, be it IRC channel, a Discord server or our team Slack channel. --- So I'm wondering, do other people tend to use LLMs as these sort of interactive rubber ducks? And as a bit of a stretch of this idea---could LLM be thought of as a tool to practice asking question, prior to actually asking real people? --- PS: I should mention that I'm also not a native English speaker (which I guess is probably obvious by now by my writing) so part of my "learning asking question" is also learning it specifically in English.
I started writing this as an answer to someone on some discord, but it would not fit the channel topic, but I'd still love to see people's views on this. So I'll quote the comment but just as a primer: > The safest pattern to use is to not use any pattern at all and write the most straight forward code. Apply patterns only when the simplest code is actually causing real problems. First and foremost: Many paths to hell are paved with design patterns applied willy-nilly. (A funny aside: OO community seems to be more active and organized in describing them (and often not warning strongly enough about dangers of inheritance, the true lord of the pattern rings), which leads to the lower-level, simpler patterns being underrepresented.) But, the other extreme is not without issues, by far. I've seen too many FastAPI endpoints talking to db like there's no tomorrow. That is definitely "straight forward" approach but the first problem is already there: it's pretty much untestable, and soon enough everyone is coupling to random DB columns (and making random assumptions about their content, usually based on "well let's see who writes what there" analysis) which makes it hard to change without playing a whack-a-bug. And what? Our initial DB design was not future proof? Tough luck changing it now. So new endpoints will actually be trying to make up for the obsolete schema, using pandas everywhere to do what SQL or some storage layer (perhaps with some unit-of-work pattern) should be doing -- and further cementing in the obsolete design. Eventually it's close to impossible to know who writes/expects what, so now everyone better be defensive, adding even more cruft (and space for bugs). My point is, I guess, that by the time when there are identifiable "real problems" to be solved by pattern, it's far too late. Look, in general, postponing a decision to have more information can be a great strategy. But that depends on the quality of information you get by postponing. If that extra information is going to be just new features you added in the meantime, that is going to be **heavily** biased by the amount of defensive / making-up-for-bad-db junk that you forced yourself to keep adding. It's not necessarily going to be easier to see the right pattern. So the tricky part is, which patterns are actually strong enough yet not necessarily obtrusive, so that you can start applying them early on? That's a million dollar question. I don't think "straight forward" gets you towards answering that question. (Well, to be fair, I'm sure people have made $1M with "straight forward code", so that's that, but is that a good bet?) (By the way, real world actually has a nice pattern specifically for getting out of that hole, and it's called "your competitor moving faster & being cheaper than you" so in a healthy market the problem should solve itself eventually...) --- So what are your ideas? Do you have design patterns / disciplines that you tend to apply generally, with new projects? I'm not looking for actual patterns (although it's fine to suggest your favorites, or link to resources), I'm mainly interested in what do people think about patterns in general, and how to apply them during the lifetime of the project.
