Yes, PHP is faster than C#

[Mindless2112]

This is a pretty worthless comparison.

* The C# version invokes EndOfStream up to 4096 times for every 1 call to feof in PHP version.

* The C# version opens the file in text mode (and thus does UTF-8 decoding) whereas the PHP version opens the file in binary mode.

[cakoose]

The previous post on this blog makes another worthless comparison, this time based on lines of code:

https://withinboredom.info/blog/2022/03/16/my-favorite-langu...

> Like, look at this Merge Sort in C# [1] (130 lines) and then look at it in PHP (31 lines) [2]. You can’t beat that kind of productivity, not to mention in PHP, you can even mix data types (like ints and floats) where in the C# version, it’d be much more difficult.

[1] https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorit...

[2] https://www.w3resource.com/php-exercises/searching-and-sorti...

The C# version is the first Google result for "c# merge sort". But a later result is from w3resource.com, which where the PHP code came from. That C# code is only 55 lines and could easily be shorter by replacing loops with standard library calls:

https://www.w3resource.com/csharp-exercises/searching-and-so...

Also, both versions of the code from w3resources.com are trash -- they use an O(N) step to remove an element from the front of the array (array_slice in PHP and List.Remove in C#), which makes them O(N^2 log N), which is even worse than a naive selection sort or bubble sort.

[withinboredom]

The C# version only makes a syscall if the buffer is empty: https://github.com/dotnet/runtime/blob/1ba0394d71a4ea6bee7f6...

To read in binary, you open with 'rb' and not just 'r'

[deltaci]

this is very naive reimplentation of the C# version. I managed to reduce the runtime of the same file from 5.7 seconds to just 800ms

    using var file = File.OpenRead("file.bin");
    var counter = 0;
    var sw = Stopwatch.StartNew();
    var buf = new byte[4096];
    while (file.Read(buf,0,buf.Length) > 0)
    {
        foreach (var t in buf)
        {
            if (t == '1')
            {
                counter++;
            }
        }
    }

    sw.Stop();
    Console.WriteLine($"Counted {counter:N0} 1s in {sw.Elapsed.TotalMilliseconds:N4} milliseconds");

[cakoose]

This code has a bug that can cause the count to be overreported. The last `file.Read` may only partially fill the buffer, but this code will look for 1s in the entire buffer.

(This bug won't affect the performance comparison, but I was just reminded of how error prone these kinds APIs can be vs the PHP/Python route of having the library function just allocate a new buffer each time.)

[Someone]

If you know the file isn’t too large, there also is File.ReadAllBytes (https://docs.microsoft.com/en-us/dotnet/api/system.io.file.r...)

My C# is very rusty (no pun intended) but I would guess the core of the program could be something like

  File.ReadAllBytes("file.bin").Where(x => x == '1').Count()

And nitpick: the code you gave has a bug. file.Read can return less than 4096. If so, you should only loop over the part of the buffer it filled.

[stillbourne]

C# isn't the unholy incantations of unmaintainable cargo cult development. I don't care if its faster, I care if I have to weep for hours prior rewriting ungodly spaghetti. I've written code in many languages professionally, in the hierarchy of fuckery I've seen done in order to write code php is worse than perl, which is worse than js, which is worse than sucking on the teets of the chthonic elder gods. I would rather eat a hefty bowl of my own vomit while walking across a mile of broken glass before having to maintain anything written in php.

[withinboredom]

Damn dude. That’s almost as epic as https://stackoverflow.com/questions/1732348/regex-match-open...

[overgard]

That's a very convincing demonstration... that the author doesn't understand how to write moderately efficient C#

[WheelsAtLarge]

Ya, maybe. But it's easier to develop bug free code on C#. Speed has its advantages but it's not the only criteria used to decide what language to use.

[40four]

I respectfully disagree. Modern PHP is an excellent language to work in, despite all the gripes old timers have from the old version 4/5 days. You can write top shelf Object oriented patterns, with first class dependency injection support. Type hinting. Built in Interface support. A really nice module/ import system. Composer is a fantastic dependency manger, and automatically gives you a magical class autoloader script with a small amount of configuration. Also PHP 8 includes all the modern conveniences you’d expect, like arrow function notation for closures, Enums, the Null Coalescing Operator, need I go on? :)

[CharlesW]

> But it's easier to develop bug free code on C#.

Wow, that's a claim I've never seen before. What's it based on? (As an example, I'm wondering if you may not be aware that there are several static analysis tools for PHP.)

[alkonaut]

Isn’t this reading the file in 4K chunks in the php version and byte by byte in the C# version? If so they are completely different programs. The C# program would have 4096 times the number of method calls to Read()?

Edit: To clarify it’s buffered in C# too but the difference is that it’s fetched one byte at a time via a method call per byte. Not an I/O call per byte (then the difference would have been much larger of course).

[notRobot]

This is addressed in the article:

> “But Rob,” I hear you say, “they’re not reading it byte-by-byte in the PHP version!” and I’d reply with, “but we’re not reading it byte-by-byte in the C# version either!”

C# also reads in 4K chunks: https://github.com/dotnet/runtime/blob/1ba0394d71a4ea6bee7f6...

[withinboredom]

You can follow the link to the underlying C# library where it is reading it in 4kb chunks as well. PHP doesn’t buffer for you, so if you want to read a file one byte (to your peril) at a time, you can. It’ll be as fast as the async version of the C# implementation, but still slower than reading buffered.

[goaty_tyaotg]

Does anyone know if PHP's "substr_count" function uses SIMD? I did a write-up on this: https://dev.to/goaty92/in-response-to-yes-php-is-faster-than... where I implemented a counter with SIMD and get a 10-fold performance increase.

[withinboredom]

Here's the latest optimization to that func: https://github.com/php/php-src/commit/085b360abb622abc18b955...

In the latest addendum on the blog post, I ended up removing the counting of 1s.

[Thristle]

1.that's not pretty good C# code. Though i can't comment on the quality of PHP

2.Programming languages are more then their syntax, they are entire ecosystems. 99% of the time its not the syntax/features/paradigms that make you move fast its the libraries

[behnamoh]

What's the point?