Announcement

Collapse
No announcement yet.

Qt 6.3 Released With Improved Wayland Support, Qt Language Server Module

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • #21
    The truth about windows and winblows fanboy birdie

    https://news.ycombinator.com/item?id=5689391

    There is not much discussion about Windows internals, not only because they are not shared, but also because quite frankly the Windows kernel evolves slower than the Linux kernel in terms of new algorithms implemented. For example it is almost certain that Microsoft never tested I/O schedulers, process schedulers, filesystem optimizations, TCP/IP stack tweaks for wireless networks, etc, as much as the Linux community did. One can tell just by seeing the sheer amount of intense competition and interest amongst Linux kernel developers to research all these areas.
    The net result of that is a generally acknowledged fact that Windows is slower than Linux when running complex workloads that push network/disk/cpu scheduling to its limit: https://news.ycombinator.com/item?id=3368771 A really concrete and technical example is the network throughput in Windows Vista which is degraded when playing audio! http://blogs.technet.com/b/markrussinovich/archive/2007/08/2...

    Note: my post may sound I am freely bashing Windows, but I am not. This is the cold hard truth. Countless of multi-platform developers will attest to this, me included. I can't even remember the number of times I have written a multi-platform program in C or Java that always runs slower on Windows than on Linux, across dozens of different versions of Windows and Linux. The last time I troubleshooted a Windows performance issue, I found out it was the MFT of an NTFS filesystem was being fragmented; this to say I am generally regarded as the one guy in the company who can troubleshoot any issue, yet I acknowledge I can almost never get Windows to perform as good as, or better than Linux, when there is a performance discrepancy in the first place.

    Comment


    • #22
      Originally posted by Volta View Post
      The truth about windows and winblows fanboy
      Yeah, we all know birdie should fly away. Even when he has a good point, he ruins it with it with "I know everything, and you're all just a bunch of lusers that live in your parents' basements" rhetoric.

      Would anyone like to actually discuss Qt 6.3?
      Last edited by DanL; 12 April 2022, 08:00 PM.

      Comment


      • #23
        Originally posted by tildearrow View Post

        May you specify why exactly?
        • IO logging: The Linux kernel logs data in 4K increments, ntoskrnl logs actual bytes
        • Microkernel abilities: ntoskrnl can recover from drivers crashes, the Linux kernel panics
        • Network filtering: The Linux kernel is unable to filter UDP traffic by user (it always belongs to the root user), ntoskrnl can do it
        • Network filtering: The Linux kernel cannot filter traffic by application, including its path or hashsum (including all the dependent libraries)
        • MAC implementation in ntoskrnl is leaps and bounds more powerful than in Linux/POSIX
        • GPU load monitoring - missing in Linux altogether (it's just a case of missing APIs, right, but Windows 8 implemented it a decade ago)
        • Processes groups CPU/IO/Net monitoring out of the box - this can be done in Linux but it's far from trivial and there are no tools to show this data aside from systemd-cgtop.
        This is just what I use and deal with - people who deal with Windows internals know a lot more.

        The Linux kernel has its own features but they are server class, e.g. cgroups.

        Comment


        • #24
          The Linux kernel has its own features but they are server class, e.g. cgroups.
          Fascinating! My Fedora Workstation must be a 'server class' distribution. Your other points are as invalid as this one. To check a few:

          • IO logging: The Linux kernel logs data in 4K increments, ntoskrnl logs actual bytes
          It's hard to guess what you actually mean, but I'm sure you can say farewell to performance on you Windows box in this case.

          • Microkernel abilities: ntoskrnl can recover from drivers crashes, the Linux kernel panics
          Linux kernel can 'oops' instead of panic.

          • Network filtering: The Linux kernel cannot filter traffic by application, including its path or hashsum (including all the dependent libraries)
          The root of this in Windows come from insecurity:

          Application-wise network filtering is a controversial topic: in Windows such frameworks are quite common (ZoneAlarm, Norton Internet Security) and are the nightmare of every Help Desk. Additionally they are designed to interact with the user who most often has no idea – and they tend to spread fear among the users to show how “effective” they are while there is nothing to fear.

          For Linux it was often mentioned that application-wise network filters are not needed since Linux cannot be infected as easily as Windows.
          But even on Linux it's possible:

          wise network filtering can also be achieved with SELinux. It does require a certain amount of own work (creating new policies and so on), but it is possible.
          • MAC implementation in ntoskrnl is leaps and bounds more powerful than in Linux/POSIX
          MAC implementation on Windows is unholy and terrible joke.

          Comment


          • #25
            What's more important Windows will be dead in few years. It's on the same path Solaris was. What's funny I predicted the fate of Solaris a few years of its end. Now, when comes to dying Windows:

            May, 2013

            I'm a developer in Windows and contribute to the NT kernel. (Proof: the SHA1 hash of revision of [Edit: filename redacted] is [Edit: hash redacted].) I'm posting through Tor for obvious reasons.

            Windows is indeed slower than other operating systems in many scenarios, and the gap is worsening. The cause of the problem is social. There's almost none of the improvement for its own sake, for the sake of glory, that you see in the Linux world.

            Granted, occasionally one sees naive people try to make things better. These people almost always fail. We can and do improve performance for specific scenarios that people with the ability to allocate resources believe impact business goals, but this work is Sisyphean. There's no formal or informal program of systemic performance improvement. We started caring about security because pre-SP3 Windows XP was an existential threat to the business. Our low performance is not an existential threat to the business.

            See, component owners are generally openly hostile to outside patches: if you're a dev, accepting an outside patch makes your lead angry (due to the need to maintain this patch and to justify in in shiproom the unplanned design change), makes test angry (because test is on the hook for making sure the change doesn't break anything, and you just made work for them), and PM is angry (due to the schedule implications of code churn). There's just no incentive to accept changes from outside your own team. You can always find a reason to say "no", and you have very little incentive to say "yes".

            There's also little incentive to create changes in the first place. On linux-kernel, if you improve the performance of directory traversal by a consistent 5%, you're praised and thanked. Here, if you do that and you're not on the object manager team, then even if you do get your code past the Ob owners and into the tree, your own management doesn't care. Yes, making a massive improvement will get you noticed by senior people and could be a boon for your career, but the improvement has to be very large to attract that kind of attention. Incremental improvements just annoy people and are, at best, neutral for your career. If you're unlucky and you tell your lead about how you improved performance of some other component on the system, he'll just ask you whether you can accelerate your bug glide.

            Comment


            • #26
              More about the miserable condition of Windows:

              Is it any wonder that people stop trying to do unplanned work after a little while?

              Another reason for the quality gap is that that we've been having trouble keeping talented people. Google and other large Seattle-area companies keep poaching our best, most experienced developers, and we hire youths straight from college to replace them. You find SDEs and SDE IIs maintaining hugely import systems. These developers mean well and are usually adequately intelligent, but they don't understand why certain decisions were made, don't have a thorough understanding of the intricate details of how their systems work, and most importantly, don't want to change anything that already works.

              These junior developers also have a tendency to make improvements to the system by implementing brand-new features instead of improving old ones. Look at recent Microsoft releases: we don't fix old features, but accrete new ones. New features help much more at review time than improvements to old ones.

              That's literally the explanation for PowerShell. Many of us wanted to improve cmd, but couldn't.

              More examples:

              We can't touch named pipes. Let's add %INTERNAL_NOTIFICATION_SYSTEM%! And let's make it inconsistent with virtually every other named NT primitive.
              We can't expose %INTERNAL_NOTIFICATION_SYSTEM% to the rest of the world because we don't want to fill out paperwork and we're not losing sales because we only have 1990s-era Win32 APIs available publicly.
              We can't touch DCOM. So we create another %C#_REMOTING_FLAVOR_OF_THE_WEEK%!
              XNA. Need I say more?
              Why would anyone need an archive format that supports files larger than 2GB?
              Let's support symbolic links, but make sure that nobody can use them so we don't get blamed for security vulnerabilities (Great! Now we get to look sage and responsible!)
              We can't touch Source Depot, so let's hack together SDX!
              We can't touch SDX, so let's pretend for four releases that we're moving to TFS while not actually changing anything!
              Oh god, the NTFS code is a purple opium-fueled Victorian horror novel that uses global recursive locks and SEH for flow control. Let's write ReFs instead. (And hey, let's start by copying and pasting the NTFS source code and removing half the features! Then let's add checksums, because checksums are cool, right, and now with checksums we're just as good as ZFS? Right? And who needs quotas anyway?)
              We just can't be fucked to implement C11 support, and variadic templates were just too hard to implement in a year. (But ohmygosh we turned "^" into a reference-counted pointer operator. Oh, and what's a reference cycle?)

              Comment


              • #27
                Originally posted by birdie View Post

                I almost remember this but I will dismiss his opinion for a simple reason: ntoskrnl is leaps and bounds better than the Linux kernel. And there's no hatred or particular strong emotions in this statement, just a dismissal.
                Except ntoskrnl is not better than Linux kernel. It cannot be even used outside Windows while Linux is not tied to any specific operating system.

                Comment


                • #28
                  Originally posted by dragon321 View Post

                  Except ntoskrnl is not better than Linux kernel. It cannot be even used outside Windows while Linux is not tied to any specific operating system.
                  ntoskrnl can and is used outside of Windows, e.g. it's used in XBox. There are versions of Windows without UI at all.

                  And I wonder how this feature can even be considered an advantage. For whom? Why? Who the hell cares? I don't give a damn.

                  And lastly, the Linux kernel alone is 100% useless. It needs userspace to do something.

                  Sorry, your argument is null and void.

                  Comment


                  • #29
                    Originally posted by birdie View Post

                    ntoskrnl can and is used outside of Windows, e.g. it's used in XBox. There are versions of Windows without UI at all.

                    And I wonder how this feature can even be considered an advantage. For whom? Why? Who the hell cares? I don't give a damn.

                    And lastly, the Linux kernel alone is 100% useless. It needs userspace to do something.

                    Sorry, your argument is null and void.
                    Windows without UI is still Windows. Xbox uses Windows based OS. ntoskrnl is useless without userspace as well and compared to Linux it doesn't really exists without Windows userspace.

                    Thanks to being standalone Linux is used in much wider variety applications because it's not limited by one user land and can be easily modified to work in many environments. Compare how many devices that are not desktop or server are using Linux and how many of them are using Windows. Super computers are good example - almost every of them is using Linux. The fact that Linux can be much more minimal than Windows is crucial here, in super computers OS needs to be as small as possible. Windows can't really compete with Linux here.

                    Ignoring argument doesn't mean they are "null and void". It doesn't work that way.

                    Comment


                    • #30
                      Originally posted by dragon321 View Post

                      Windows without UI is still Windows. Xbox uses Windows based OS. ntoskrnl is useless without userspace as well and compared to Linux it doesn't really exists without Windows userspace.

                      Thanks to being standalone Linux is used in much wider variety applications because it's not limited by one user land and can be easily modified to work in many environments. Compare how many devices that are not desktop or server are using Linux and how many of them are using Windows. Super computers are good example - almost every of them is using Linux. The fact that Linux can be much more minimal than Windows is crucial here, in super computers OS needs to be as small as possible. Windows can't really compete with Linux here.

                      Ignoring argument doesn't mean they are "null and void". It doesn't work that way.
                      I've seen millions of devices with the Linux kernel. They are often part of botnets because maintaining the kernel for them is a Herculean task which also requires money.

                      Your argument of the Linux kernel versatility in terms of supporting various devices as an advantage is complete crap. If anything it's a disadvantage because it shows that you can either have RHEL/Google which actually maintain older versions of it or use the bleeding edge which is not applicable to all your wonderful devices.

                      Comment

                      Working...
                      X