Fedora 37 Hopes To Have A Preview Of The New Web-Based Install UI

[cl333r]

no, I was in a complex relationship with the borrow checker, so I stopped programming in Rust

Huh, I dumped Rust for the same reason. Horrible rules.

[finalzone]

To tell the truth, openSUSE is the most powerful "install" out there.
It offers by default a simple and a more advanced powerful mode in which you can choose in detail what to install and what not.

The current Anaconda installer has that similar simple and advanced powerful mode via network installation and also on Fedora Server by default.

[krzyzowiec]

I see this type of bug everyday where dynamic typed languages are used (luckily I care about my work and don't use such languages).

It really has nothing to do with dynamic types. You can do dumb things in any language. It’s also trivial to avoid if you actually know them. Then again, you don’t use them so how would you know?

[cynic]

It really has nothing to do with dynamic types. You can do dumb things in any language.

Nope. Statically typed languages have more predictable behaviour and makes strict check at compile time.

It’s also trivial to avoid if you actually know them.

if it were trivial, they would never happend. On the contrary, they always happend.
Never saw this video?

https://www.destroyallsoftware.com/talks/wat

Those languages always try to compute whatever absurd thing you ask them to do, and the outcome is not always the one you expect.
This open a big class of runtime bug.

Then again, you don’t use them so how would you know?

Guess what?
I use software written by other persons!
Some of my collegues uses python, perl and JS and they often incurr in those kind of bugs.

Not that my software is bug free, but I least my compilers won't let me add an array to an object and find out at runtime that, after all, that wasn't a good idea.

[rmnscnce]

What is so important about web based installers to the two big linux enterprise companies?

Because by doing so, everything regarding the matter of the infra fleet maintenance can be done easily from the web browser. From the installation (which Cockpit + Anaconda is trying to solve), software management, VM management with a web-based viewport, resource monitor, and of course -- your ol' trusty TTY on web.

[undefined]

It really has nothing to do with dynamic types. You can do dumb things in any language. It’s also trivial to avoid if you actually know them. Then again, you don’t use them so how would you know?

Actually, you can't avoid it.
In Java, Go, Rust, and many other languages, if you have a function

String addTwoNumbers(int a, int b) {
    return String.valueOf(a+b);
}

it can only be called with two integer numbers a and b passed to it. Otherwise the code will not compile. So, this function will never ever do anything unexpected. It will always take two integer numbers as input and return the sum of them as a string. It doesn't matter where the numbers come from or whatever, you know 100% they always be integer numbers, otherwise Java will not compile.

Let's imagine for a moment that we are working with javascript and that we are receiving two numbers from a server and we need to compute their sum client-side using a similar function but in JS (sorry if there are mistakes, I am no JS professional, treat is as pseudocode).

function veryImportantFunction() {
    var num1 = getNumber1FromServer();
    var num2 = getNumber2FromServer();
    return addTwoNumbers(num1, num2);
}

function addTwoNumbers(a, b) {
    var sum =  a+b;
    return sum.toString();
}

As long as functions "getNumber1FromServer" and "getNumber2FromServer" return two numbers respectively all is fine. But what if any of them returns not a number? What if "getNumber1FromServer" returns an array for some weird reason? Mistake on the server side or something. This function will happily work with array instead of a number without any issues whatsoever. And it will return "1,2,34" when called with a = [1, 2, 3], b=4. How does documentation help in this case? You need to consciously consider all these cases where JS just ignores errors and check for them. For example, in this case you need to keep in mind that you need to check in the beginning of the function that a and b are integers. Otherwise you have a potential bug that will appear the moment something goes wrong anywhere before. And instead of failing, this bug will carry on, it will go further in the stack.

[win10pwrusr]

So, this function will never ever do anything unexpected.

Are you sure? I just tested it.

Java:

public class MyClass {
    static String addTwoNumbers(int a, int b) {
        return String.valueOf(a+b);
    }
    
    public static void main(String args[]) {
      int x= 500000000;
      int y=2000000000;

      System.out.println(addTwoNumbers(x, y));
    }
}

Result = -1794967296



JavaScript:

function addTwoNumbers(a, b) {
  return a+b;
}
    
let x= 500000000;
let y=2000000000;

console.log(addTwoNumbers(x, y));

Result = 2500000000


I asked 7 people around me what result they expected when adding 500000000 to 2000000000 and not a single one gave Java's result as the answer. Clearly that's not the expected behaviour.
Do you really want a partition with a size of -1794967296 ? I think not. lol

[Charlie68]

The current Anaconda installer has that similar simple and advanced powerful mode via network installation and also on Fedora Server by default.

The problem with Anaconda is that it has a partitioner with a GUI that not even a kindergarten kid could have done worse. It is tremendously complicated to understand how it works, but Yast-install is simple.

[undefined]

Are you sure? I just tested it.

Java:

public class MyClass {
static String addTwoNumbers(int a, int b) {
return String.valueOf(a+b);
}

public static void main(String args[]) {
int x= 500000000;
int y=2000000000;

System.out.println(addTwoNumbers(x, y));
}
}

Result = -1794967296



JavaScript:

function addTwoNumbers(a, b) {
return a+b;
}

let x= 500000000;
let y=2000000000;

console.log(addTwoNumbers(x, y));

Result = 2500000000


I asked 7 people around me what result they expected when adding 500000000 to 2000000000 and not a single one gave Java's result as the answer. Clearly that's not the expected behaviour.
Do you really want a partition with a size of -1794967296 ? I think not. lol

Erm, Javascript does exactly the same thing as Java, it just uses a different default numeric type. 9007199254740990 + 3 according to JS is 9007199254740992. Use double in Java instead of int and you will have exactly the same behavior as in JavaScript. Including all these 0.1 + 0.2 equals to 0.30000000000000004. I don't know programming languages where there are no numerical issues and I don't know any language where integer overflow is checked (unfortunately).

Anyway, it was not my point to say that Java or whatever language is absolute best and has no bad moments. My problem is that the amount of these possible silent bugs is different. In Java you have provided one of the most well-known in CS issues with integer overflow, but this is rather an exception in Java than a rule.