\Device\NUL
I could even suggest someone ARM64 as long as it's not dead arch or dead OS
Manav
I could even suggest someone ARM64 as long as it's not dead arch or dead OS
arm64 *judging you* :D
\Device\NUL
Beside on learning how cpu works, I also learned how modern OS works from it. You can't get that lesson on DOS assembly
...
I don't think it justifies enough teaching dead architecture anyway
There is perfectly good RISC-V for that matter
>teaching dead architecture
You're teaching transferrable knowledge, nothing more, nothing less.
\Device\NUL
knowledge can be obsolote when times changes
\Device\NUL
You don't learn how steam machine works on nowdays
Manav
And they'll still have to learn x86_64 ISA so why not just start with it?
\Device\NUL
On Victoria ages, yes it's useful but now...
\Device\NUL
And they'll still have to learn x86_64 ISA so why not just start with it?
Yep, from my pov should be applicable and should'nt be obsolete
...
knowledge can be obsolote when times changes
for the foreseeable future, the von-neumann architecture won't become obsolete.
\Device\NUL
for the foreseeable future, the von-neumann architecture won't become obsolete.
I think we talk about how it's still related nowdays right? Not talking about von-neumann architecture
\Device\NUL
Sorry, when it's not applicable or relevant today. It's no use
\Device\NUL
I did learn DOS assembly for fun only, but still I didn't recommend it to people except they want to do retrocoding
Engineer
knowledge can be obsolote when times changes
That is never the case - I would recommend you watch video "Bret Victor The Future of Programming"
When programming was new researchers and other people tried very different ideas and we got stuck with text editing. Why did the other ideas never catch on?
https://m.youtube.com/watch?v=8pTEmbeENF4
\Device\NUL
Engineer
Then how could IA-64 become dead?
It was a company mess because people with MBA who knew nothing about technology were running the purse strings
Engineer
It was a company mess because people with MBA who knew nothing about technology were running the purse strings
As AMD was never invited to be a contributing party for the IA-64 architecture and any kind of licensing seemed unlikely, AMD's AMD64 architecture-extension was positioned from the beginning as an evolutionary way to add 64-bit computing capabilities to the existing x86 architecture, while still supporting legacy 32-bit x86 code – as opposed to Intel's approach of creating an entirely new, completely x86-incompatible 64-bit architecture with IA-64.
https://en.m.wikipedia.org/wiki/IA-64
Engineer
https://tedium.co/2020/06/16/apple-powerpc-intel-transition-history/
Engineer
That is never the case - I would recommend you watch video "Bret Victor The Future of Programming"
When programming was new researchers and other people tried very different ideas and we got stuck with text editing. Why did the other ideas never catch on?
https://m.youtube.com/watch?v=8pTEmbeENF4
This is why Computer Science courses need to teach the history of computers and programming. All other sciences talk about their history in introductory courses but not computer science.
Engineer
https://m.youtube.com/watch?v=HfHcwpzxSdk
Light
Can somebody help me in this.
I have a main array
And a elem array
elem array contains element whose permutation is required to find in the main arrya
Say {1,2,3,4}
In main array say {3,2,1,4,2,1,3,4}
Here 2 permutations are available
{3,2,1,4} {2,1,3,4} order doesnt matter in permutation
Please note it is unidirectnlional which means you just cant make a permutation using first elemnts and some end elements
klimi
klimi
Can somebody help me in this.
I have a main array
And a elem array
elem array contains element whose permutation is required to find in the main arrya
Say {1,2,3,4}
In main array say {3,2,1,4,2,1,3,4}
Here 2 permutations are available
{3,2,1,4} {2,1,3,4} order doesnt matter in permutation
Please note it is unidirectnlional which means you just cant make a permutation using first elemnts and some end elements
also, what do you need help in? you haven't written such
Light
Its vector array not set
Light
Oops
Sonu
Strcmp kya hota hai
Light
If the strings are equal, strcmp returns 0.If the first string is lexicographically greater than the second, it returns a positive value.If the first string is lexicographically less than the second, it returns a negative value.
Sonu
Ok sorry
Sonu
Because I don't know
Light
Btw, i think you should go through the rules, the bots are strict.
Light
Sigma
Light
You don't know how to open google?
Kali linux users just get all sweaty and depressed downloading chrome using Command line interface for first time
줄리아 우지야노바
legacy mode will eventually die later
legacy mode won’t die, because your pc works only because this legacy mode is still working in x86-based processors
klimi
wrong group
klimi
please read the group rules before posting messages
\Device\NUL
legacy mode won’t die, because your pc works only because this legacy mode is still working in x86-based processors
Afaik, there will be pure UEFI fw with no legacy support
zahra
how to solve it?
Error (active) E0135 namespace "CGAL" has no member "extract_mean_curvature_flow_skeleton"
Anonymous
how to solve it?
Error (active) E0135 namespace "CGAL" has no member "extract_mean_curvature_flow_skeleton"
Add the member "extract_mean_curvature_flow_skeleton" to namespace CGAL
Never Spam Bot
@artrone sent multiple messages that looks like a spam. If they send more spam - like messages, they will be muted. Only admins can unmute them.
MᏫᎻᎯᎷᎷᎬᎠ
We should add bjarne to this group....
MᏫᎻᎯᎷᎷᎬᎠ
What's the state of 20 modules anyway
Anonymous
A question here:
int k, j;
k = 2;
j = 7; --> line 1
j = k; --> line 2
in the first line j is clearly an lvalue but in the second one the compiler interprets k as rvalue or lvalue, I clarify that I am referring to C
Anonymous
A question here:
int k, j;
k = 2;
j = 7; --> line 1
j = k; --> line 2
in the first line j is clearly an lvalue but in the second one the compiler interprets k as rvalue or lvalue, I clarify that I am referring to C
I say this because we are copying the value 2 in that case 2 is an rvalue so k is an rvalue?
Anonymous
A question here:
int k, j;
k = 2;
j = 7; --> line 1
j = k; --> line 2
in the first line j is clearly an lvalue but in the second one the compiler interprets k as rvalue or lvalue, I clarify that I am referring to C
rvalue and lvalue is a property of an expression and not that of a variable. In your example both are lvalues.
j = <expr>
In your case the expr is k. k by itself is an lvalue expression as it refers to an identity of an object
If suppose j were defined as int* j and you have the assignment
j = &k;
Here the expression &k is an rvalue expression.
You can break this down like this:
j = <expr1>
where expr1 = &<expr2>
expr2 is k which is an lvalue expression. expr1 is &expr2 i.e. &k which is an rvalue expression
Whether an expression is an lvalue or an rvalue is determined by rules in the C standard.
Anonymous
What's the state of 20 modules anyway
Why should Bjarne be the one to answer this? The Cppreference page on C++20 features and C++23 features says that Visual Studio supports both modules and standard library import as modules while GCC and Clang are yet to support the C++20 parts itself. Clang is however working on a dependency scanner which can be used by build tools (CMake, Meson and Ninja count on this while b2 has worked around it while supporting this scanner if available) and they are doing this for both Clang and GCC.
Anonymous
rvalue and lvalue is a property of an expression and not that of a variable. In your example both are lvalues.
j = <expr>
In your case the expr is k. k by itself is an lvalue expression as it refers to an identity of an object
If suppose j were defined as int* j and you have the assignment
j = &k;
Here the expression &k is an rvalue expression.
You can break this down like this:
j = <expr1>
where expr1 = &<expr2>
expr2 is k which is an lvalue expression. expr1 is &expr2 i.e. &k which is an rvalue expression
Whether an expression is an lvalue or an rvalue is determined by rules in the C standard.
Let me ask you to explain something to me:
What exactly is a Lvalue? I understand that it is an expression that refers to an object but when I do
int *a = &x;
here a stores the Lvalue of X doesn't it?
Anonymous
b2...
Is it a package manager?
No it is a build tool (search for build2) which supports Conan, vcpkg and maybe many more.
MᏫᎻᎯᎷᎷᎬᎠ
Yeah, I just checked it
MᏫᎻᎯᎷᎷᎬᎠ
I haven't said that bjarne should answer anyway
MᏫᎻᎯᎷᎷᎬᎠ
But, it's just the language now is in bad state I guess
Anonymous
Let me ask you to explain something to me:
What exactly is a Lvalue? I understand that it is an expression that refers to an object but when I do
int *a = &x;
here a stores the Lvalue of X doesn't it?
No. Here 'a' stores a temporary value that is generated when you apply & operator to an lvalue expression 'x'.
To learn more about lvalues and rvalues (you don't need to understand them completely for your day to day programming) read the standard.
MᏫᎻᎯᎷᎷᎬᎠ
Less features, more overdose features
Uncomplete implementations
New language are around
MᏫᎻᎯᎷᎷᎬᎠ
It's just too tempting to just move to another language
While it's too tempting to stick around, It's C++ after all and survived nearly 40 years
MᏫᎻᎯᎷᎷᎬᎠ
Yes, I'm one of those who believe there is a best language, not the type of guys who say there is not better tool or something like that
Anonymous
Less features, more overdose features
Uncomplete implementations
New language are around
The implementation support for modules is bound to take time given how clunky gcc was to begin with. What is more surprising is the reason why Clang is taking so long given they started out fresh and were designed to be modular. Turns out they weren't so modular to begin with and supporting modules requires changes at many different levels that was not anticipated. But the absence of modules doesn't make C++20 less important in any way.
Yes the language as such is turning out to be a major ugly mess ball because of the committee's refusal to break ABI compatibility and that will remain so till the people who represent companies that have tonnes of legacy code to manage don't leave the committee. Google got pissed off and removed it's engineers from the committee and they started work on Carbon. Herb by himself is pissed off that his suggestions for things like exceptions by value have still not been ratified. He has started work on cpp2 (cppfront). They are intended to work with C++ but are also baggage free unlike C++ which has the giant elephant called ABI compatibility tied to its back.
MᏫᎻᎯᎷᎷᎬᎠ
MᏫᎻᎯᎷᎷᎬᎠ
It's a headache to even rewrite everything again in rust cuz it's nearly impractical
MᏫᎻᎯᎷᎷᎬᎠ
There was proposal I recall 3-4 years ago, called epoch
MᏫᎻᎯᎷᎷᎬᎠ
That might solved the ABI issue
Anonymous
Why would they want to break ABI, it's just like suggesting to destroy the world and the existence of technology
Without breaking ABI, the language can't evolve which is what makes people move away to other languages. Rust grew at C++'s expense as did Nim and zig to a lesser extent. It was not only because Rust was memory safe but also because the language was designed better (now there are complaints about the Rust committee as well; they are losing sight of their original ideas and moving in a corporate direction)
MᏫᎻᎯᎷᎷᎬᎠ
So, what's the suggested solution?
Breaking ABI, means breaking already existing software
Anonymous
There was proposal I recall 3-4 years ago, called epoch
I remember you discussing this earlier. I told you at that time, that epoch won't solve all the ABI issues.
MᏫᎻᎯᎷᎷᎬᎠ
MᏫᎻᎯᎷᎷᎬᎠ
So I just said yeah
MᏫᎻᎯᎷᎷᎬᎠ
I remember talking to Vittorio Romeo(The guy with epoch idea)
MᏫᎻᎯᎷᎷᎬᎠ
He said and I quote: "Epochs in the current form was rejected in Prague, but there's a still chance it could come back"
MᏫᎻᎯᎷᎷᎬᎠ
anyway that was 3 years ago lol
Anonymous
He said and I quote: "Epochs in the current form was rejected in Prague, but there's a still chance it could come back"
Epochs would not come back atleast not in the immature form it was envisioned originally. It is not an original idea. Rust has editions and C# has the .Net standard edition (v1, v2 and v2.1) to support such things.
Rust support for editions was baked in from the word go and hence it is not something that is analogous to C++'s case. What the .Net committee did is something similar however with some glaring differences. When .NET core was pushed, the .NET team had to worry about developers who were supporting the original .NET Framework. So what they did was to work on a separate standardization effort to support code that would work on .NET core and also .NET Framework. When you start writing new code, you advertise yourself as supporting a specific standard version which would ensure that your assembly would run unchanged on any .NET runtime.
This is something similar to what C++ needs to do. However the fact that ABI has always been outside of the committee's purview complicates such things and to bring something like what .NET team did to the C++ realm which is what epochs is suggesting, the C++ committee has to standardize the ABI and the committee would not touch this with a 100 ft pole even. epochs won't be much of a solution otherwise.
The original paper IIRC suggested some silly things like adding epoch edition at modular level which doesn't make sense at all like epoch 2023, epoch 2026 and so on. At a point of time, people would often lose sense of what was added/removed/deprecated at each epoch and then the headache of whether changing epoch 23 to epoch 26 would be safe change and so on. So unless the committee is willing to break ABI or to standardize the ABI, there is no point.
Paulo
Hi everyone,just a question. I'm taking a course and one of it exercise the instructor explicit ask us to throw a exception in a class constructor.
I write this code, but thinking about performance is that the better way to do that?
#include <cassert>
#include <stdexcept>
class Pyramid {
int length {};
int width {};
int height {};
int ValidateValue(int n){
if(n < 0)
throw std::invalid_argument("invalid number!");
return n;
}
public:
Pyramid(int l, int w, int h) : length(ValidateValue(l)), width(ValidateValue(w)), height(ValidateValue(h)) {
};
void Length(int lng){
length = ValidateValue(lng);
}
int Length(){return length;}
void Width(int wdt){
width = ValidateValue(wdt);
}
int Width(){ return width;}
void Height(int hgt){
height = ValidateValue(hgt);
}
int Height(){ return height;}
int Volume(){
return (width * length * height) /3;
}
};
// Test
int main() {
Pyramid pyramid(4, 5, 6);
assert(pyramid.Length() == 4);
assert(pyramid.Width() == 5);
assert(pyramid.Height() == 6);
assert(pyramid.Volume() == 40);
bool caught{false};
try {
Pyramid invalid(-1, 2, 3);
} catch (...) {
caught = true;
}
assert(caught);
}
Paulo
I know constructor can throw exceptions, but I do not like this, another think, is that the better way to validar constructor arguments?
borealis
Hello Friend Please Conversion Of int Into unsigned int For Make Impossible Negative Values,, such That ,, it is Less Possible To Make Erors
imminent