This can also be a side product for code blocks being expressions instead of statements.
In rust for example they are, so it’s not rare to see functions like:
fn add_one(x: i32) -> i32 {
x+1
}
This lets you do amazing things like:
let x = if y < 0.0 {
0.0
} else {
y
}
which is the same as
x = y < 0.0 ? 0.0 : y
But is much better for more complex logic. So you can forget about chaining 3-4 ternary operations in a single line.
I’ve got all that. I just needed to convert a string of characters into a list of glyph IDs.
For context, I’m doing a code editor.
I don’t use harfbuzz for shaping or whatever, since I planned on rendering single lines of mono spaced text. I can do everything except string->glyphs conversion.
Just trying to implement basic features such as ligatures is incredibly hard, since there’s almost no documentation. Therefore you can’t make assumptions that are necessary to take shortcuts and make optimizations. I don’t know if harfbuzz uses a source of documentation that I haven’t been able to find, or maybe they are just way smarter than me, or if fonts are made in a way that they work with harfbuzz instead of the other way around.
As someone trying to have as little dependencies as possible, it is a struggle. But at the same time, harfbuzz saved me soo much time.
EDIT: I don’t do my own glyph rasterization, but that’s because I haven’t gotten to it yet, so I do use a library. I don’t know if it’s going to be harder than string->glyphs, but I doubt so.
I cannot comprehend what the fuck harfbuzz does.
I tried to implement my own because “I don’t need all the features, I’m gonna render self-to-right western text with very few font features”. But holly fuck, the font format documentation is barely non-existent. And when I tried my naive solution it was like 10000x (or more) slower than harfbuzz.
The problem with static mut is that it allows you to create multiple mutable references. And also mix mutable and immutable references. Additionally, it is accessible by any thread. So, as long as you don’t do any of that, it should be safe. Maybe I’m missing something.
If this is the entire program, it’s not unsafe. But if it is just a fraction of the program, it may be unsafe. For example if 2 threads call the function at the same time. Since you would have 2 mutable references to BUF. Well, not actually unsafe since you don’t use the mutable reference, only create it.
As to the other question, static variables are not in the stack. They have their own region of memory. If they were in the stack, they couldn’t be accessed across threads, since each thread has its own stack.
EDIT: for completeness sake. For your last question. Yes, using a static buffer is probably more performant, since it doesn’t need to be set to 0 each time it’s called. However, that’s not what statics are for. If what you want is just to avoid that setting to 0, there are ways to get initialized arrays. For example MybeUninit. Which would be way better.
This is the dram. Since the entire codebase is shit, you basically have to rewrite it basically in its entirety.
Which means you can do it with an actual good design.
And if you mess up on something, you have a working version you can consult.
I don’t understand why any user would have to care or even know what GUI toolkit an app uses.
I don’t know why the burden is put on the user/DE. You shouldn’t have to care about what GUI toolkit your DE uses either.
DE and themes should be decoupled from eachother. So the user can install whatever “theming system” they want, and GUI toolkits should aim to support as many theming systems as practical.
GUI toolkits are implementation details, the user doesn’t care about implementation, it cares about what it sees. And what it sees is the colors and icons.
Installing dependencies via the OS’ package manager is one of the worst experiences there is. I understand it for C, because the language is ancient and doesn’t have its own dependency manager.
But when developing, there are many dependencies you need that aren’t in the package manager. And when they are, they are often years old versions.
And in the case of python, it installs dependencies in the global scope, which means that you sometimes import that version instead of the pip one.
And in the case of python there’s the extra:
python main.py
python command not found
Ah. It must be python3 then. Now all the bash scripts are broken.
Since it’s python3, I’m going to install packages with pip3:
pip3 install matplotlib
pip3 command not found
What?? So for python you need to put the 3, but for pip they removed it?
Ngl, python development is much less stressful on windows.
The same argument for cartels. “We didn’t all increase our prices to the exact same amount, we just paid a consulting company to tell us which price we should use. Of course our competitors used the exact same company, but that’s just a coincidence”.
Tbf that leads to the problem of:
Company/Individual makes program that is in no way meant for making management decision.
Someone else comes and deploys that program to make management decisions.
The ones that made that program couldn’t stop the ones that deployed it from deploying it.
Even if the maker aimed to make a decision-making program, and marketed it as so. Whoever deployed it is ultimately the responsible for it. As long as the maker doesn’t fake tests or certifications of course, I’m sure that would violate many laws.
There are use cases. Like containers where the pointer to the object itself is the key (for example a set). But they are niche and should be implemented by the standard library anyway. One of the things I hate most about Java is .equals() on strings. 99.999% of times you compare strings, you want to compare the contents, yet there is a reserved operator to do the wrong comparison.
Yes that is correct. A BigInt represents the entire integer set.
Rational numbers are defined by just 2 integers. Therefore, 2 BigInts represent the entire rational set.
I haven’t tried using a GUI library for this. But it is possible (and relatively easy) to build for Android using rust.
I found this tool called “x build” that works basically out of the box. It was a bit tricky to set up the release build, but got it working too.
I made a small App using winit+wgpu and it seems to work. Win it also has touchscreen-specific events.
Iced does use winit+wgpu, so if they are listening to the touchscreen events, it should work for Android. Haven’t tested it though.
Yes. Have a structure with 2 BigInts. Treat one as the numerator. The other as denominators.
It might not be efficient or fast. But it is possible.
In C, goto is basically a necessity though. There is really no good way of error handling.
Options:
void func(void *var) {
void * var2 = malloc();
if var == Null {
goto err;
}
do_something();
err:
free(var2);
}
void func(void *var) {
void * var2 = malloc();
if var == Null {
free(var2);
return;
}
do_something();
free(var2);
}
void func(void *var) {
bool error = false;
void * var2 = malloc();
if var == Null {
error = true;
}
if !error {
do_domething()
}
free(var2);
}
void cleanup(void *var2) {
free(var2);
}
void func(void *var) {
void * var2 = malloc();
if var == Null {
cleanup(var2);
return;
}
cleanup(var2);
}
Option 1 is really the only reasonable option for large enough codebases.
Option 2 is bad because duplicate code means you might change the cleanup in one code path but not some other. Also duplicate code takes up too much valuable screen space.
Option 3 has a runtime cost. It has double the amount of conditionals per error point. It also adds one level of indentation per error point.
Option 4 is same as option 2 but you edit all error paths in one single place. However, this comes at the cost of having to write 2 functions instead of 1 for every function that can error. And you can still mess up and return while forgetting to call the cleanup function.
You must also consider that erroring functions are contagious, just like async ones. I’d say most of the time a function is propagated upwards, with very few being handled just as it ocurrs. This means that whichever downside your option has, you’ll have to deal with it in the whole call stack.
Show one use case of Blockchain outside cryptocurrency. It must also be a better solution than a traditional database.
If there’s literally a bike lane along the road, there’s no reason to use the road on a bike unless you’re an asshole.
I do pay the water company, which doesn’t give me the right to throw wet wipes down the toilet.
I do pay a waste management tax. That doesn’t give me the right to throw dogshit in the paper container.
We all pay to build bike lanes. Since people using bike lanes helps both cyclists and drivers. Just use the damn bike lane if there is one.
If you don’t understand the “problem” part in the “what problem does this tool fix?” Then you probably don’t need that tool. You should probably try the program they mentioned that didn’t fix their specific problem. Since that program probably has way more users and a more entry-level documentation.
Bash might be better than IE. But I think we can agree that it is no longer a good shell.
Its syntax is awful, and lacks many features that other shells have.
It is only so widely used because it is a de facto standard. If bash was created today, barely no one would us it.
For me it’s the opposite. Lossy ones (the ones that seem to maintain quality while lowering size by a lot) are magic to me but lossless is understandable.
What do you mean “treat this image as a wave and do an inverse Fourier transform on it in order to discard the high frequency low amplitude noise”. wtf? Straight up magic.
Except accept/cancel is sometimes switched.
As a PC gamer that doesn’t often use a controller. I often have to enter menus twice. Once to just exit it, and another to accept whatever is the first entry.
Specially when emulating old Nintendo games, which don’t say which button is which.