Sources

GitHub added 36 million developers in 2025—roughly one new account every second—but the platform's latest analysis suggests this explosive growth is creating serious sustainability problems for open source projects worldwide. The February 18 report from GitHub's Octoverse team highlights a widening gap between contributors and maintainers, compounded by what the industry now calls "AI slop"—low-quality, auto-generated pull requests that consume maintainer time without adding value. … ## The AI Problem Nobody Wanted While AI tools lowered barriers for new developers, they've simultaneously created a flood of problematic contributions. Maintainers report that review time has increased faster than the number of people available to do reviews—some describe it as "a denial of service attack on human attention." The platform saw nearly 1 billion commits in 2025, up 25% year-over-year, with 43.2 million pull requests merged monthly. That volume becomes unmanageable when a significant portion requires extensive rework or outright rejection. Some maintainers have started using AI defensively—triaging issues, detecting duplicates, and handling routine labeling. GitHub has released new tools to help, though the report acknowledges these are stopgap measures. … ## The Maintainer Crisis Record growth looks great on paper. In practice, it's straining the relatively small group of people who actually maintain critical infrastructure. The report recommends clear paths from contributor to reviewer to maintainer, shared governance models spanning multiple timezones, and documentation that doesn't assume prior knowledge. "The important question going forward isn't how much it will grow," the analysis concludes. ... Projects that fail to invest in organizational maturity risk stalling entirely—or accumulating technical debt that eventually becomes insurmountable. For an ecosystem that underpins most of the world's software, that's not a theoretical concern.

### Body Over the past few months, Github has been getting slower and slower on Safari. It has now reached a point where it is unusable. Displaying any pull request with more than a thousand lines changed or even browsing any file with a thousand or more lines of code is fully broken. What happens: - In Activity Monitor, the rendering process is running at 100%. - Rendering the page is so slow, Safari displays blank space when scrolling up and down. - Any interactive features like search is so slow it doesn't work. - Pull request review is extremely painful (scrolling back and forth is impossible to do quickly, posting comments is extremely slow, even checking the "Viewed" checkbox sometimes takes several seconds, etc.). … ### LeLunZ Aug 25, 2025 ... For bigger PRs I can't edit anything or press on any buttons. Seems like such a big page breaks something? I just tried it from a current branch to a really old version of one of my projects, and there are 403 commits and 855 changed files. In such a case the GitHub UI becomes completely unusable. … ### BrentMifsud Aug 25, 2025 ... Even small PRs I can't do anything. Adding reviewers, adding labels, etc... every action on the page takes many seconds. The page often locks up as well. This wasnt an issue a few weeks ago. - 👍 3 3 replies ... As someone who writes bugs for a living I'm careful to complain. That said, this has become a real pain point for me, personally. It's not uncommon for me to do the following things opening a PR: - Changing the base branch - Writing the description - Toggling the create button between draft and ready to review - Assigning reviewers - Assigning myself I do this several times a day and within the last few weeks the page will lock up *every* time. Sometimes I'll refresh the browser and even that takes a while to perform. Historically I've had no issues with this in Safari. 0 replies … #### lukehefson Aug 28, 2025 ... > This lines up with my experience. Initially the new files experience seemed to improve things, but in the last week, I've noticed the changed files feature is unbelievably sluggish. I can barely scroll through more than a few hundred lines of change, and the page locks up. Yeah it's definitely the files experience. But I've also noticed sluggishness all around the past week or so. For example: In any comment box, when you start to type something that autocompleted (like an @mention), the character rendering slows riiiiight doooooown. … #### uson1x Aug 27, 2025 - Wow I did not know this problem was only in safari. ... It did get faster with latest PR review UI update, but still rather slow right now - 👍 2

#### 📈 Expanding project limits All your issues can also be laid out in a GitHub Project. We've listened to your feedback that you want space for more issues in your projects, so we've expanded the limits from 1,200 to a huge **50,000** items per project! 🎉 With today's general availability announcement, we'll be removing the opt-out option in the coming weeks. Moving forward, we'll also make increased limits your default mode. … #### beberlei May 7, 2025 - This is a real problem, even with projects, because you would don't always group by parent/child in projects, so there are enough views where you would end up with (to keep this example) a list of three or more tickets all named "UI" - - - - … ## GitHub Projects + GitHub Issues Automation Capabilities Automation between GitHub Projects and GitHub Issues feels half-baked. Webhooks make it difficult to fully automate issues/projects ourselves. For example, if I want to automatically update an issue’s label when it's moved from one project field (e.g., “Category”) to another, there’s no webhook available for GitHub Projects. The only workaround is to run scheduled jobs to keep everything in sync — but that’s expensive and inefficient. … ## GitHub Projects View with Mixed Issue Types and Static Project Fields Another challenge arises when using mixed issue types within a single project, each needing different project fields. For example, we might have a field like “Effort,” which only applies to Tasks, not Stories. Or an “Impact Area” field meant for Bugs, but not Features. Since all these issue types live in the same project (to maintain correlation and visibility), having static fields for everything becomes cumbersome and semantically unclear. … ### SeeringPhil May 23, 2025 - Hello there! Great work with the new issues/subissues and projects view 😄 There are some pain points when using those new features: … - Once devs fix those issues, they can then add the sub-issue ticket in QA project/backlog. That's how it used to work before too, but not anymore. We're concerned about it as we've setup an integration of QA project with our slack channel specifically for QA related alerts. So whenever a new sub-issue is added with main ticket, an alert is sent by default because the by default selected projects are both i.e. main project and QA project.

(With the exception of some annoying carve outs like going too far with trying to please JS/node refugees with not only introducing support for top-level statements but also pushing it as the default in the various templates, the botched delivery of global includes, and other such changes —- but to be fair, many of these were implemented correctly and without any complaints on my end in the language itself but my quibbles are more with the delivery, integration, and polish in the IDE and downstream by teams like the ASP.NET Core one.) … (With the exception of some annoying carve outs like going too far with trying to please JS/node refugees with not only introducing support for top-level statements but also pushing it as the default in the various templates, the botched delivery of global includes, and other such changes —- but to be fair, many of these were implemented correctly and without any complaints on my end in the language itself but my quibbles are more with the delivery, integration, and polish in the IDE and downstream by teams like the ASP.NET Core one.)

C# shows a high “usage span” in developer communities, meaning that many developers use or continue to return to it over long periods. This continuity gives it an advantage in community knowledge, libraries, tooling, and institutional familiarity. … - Perception of heavier runtime or memory footprint — In contexts where ultra-lightweight or bleeding edge performance is required, some look toward languages that give lower-level control. - Market growth areas — Machine learning, data science, and AI have historically trended toward Python or more data-centric languages. Some of that momentum can pull developer mindshare away from cross-domain languages like C#.

## 1. Usage of String Concatenation String Concatenation Functions are really simple to use. When something is added to the string, a new address is **immediately created** in memory. The previous string is **transferred to the new section**, which now has a different location (this is not efficient at all). Let's see an example: … ## 2. Iterating with Values instead of with LINQ This problem happens when you attempt to iterate through a list of records using a loop, **which is not optimum.** … ## 5. Accessing Virtual Members within a Constructor Although this error is not one of the first, it is one of the **most common**, although it may not seem so. When an overridden method is called directly from the constructor of a base class, this **error will appear** because it comes from executing code before its time. … ## 6. Not knowing the importance of USING for Object Disposal As partech.nl says, many C# developers are +*unfamiliar* * with the concept that the using keyword is not only used as a directive for adding **namespaces**, but is also very beneficial for **object removal.** … ## 7. Using Weak Cryptographic Algorithms Here we agree with Stackify, this error is simply based on the fact that many developers use **obsolete** or **vulnerable encryption algorithms** (which is very easy to avoid). In this case we have for example SHA1 or RIPEMD160, which do not offer a current and very good level of security.

While working with (young) C# programmers I’ve noticed that some mistakes are being repeated by almost every one of them. These are mostly the mistakes, which once you point them, are quite easy to remember. However, if a developer is not aware of them, they can cause many problems with the efficiency and quality of the developed software. Therefore, I decided to gather the 8 most common mistakes made. ## 1. String concatenation instead of StringBuilder String concatenation works in such a way that every time when you add something to a string, a new address in the memory is being allocated. The previous string is copied to a new location with the newly added part. This is inefficient. On the other hand we have StringBuilder which keeps the same position in the memory without performing the copy operation. Thanks to the strings’ appending by means of StringBuilder the process is much more efficient, especially in case of hundreds of append operations. //INCORRECT List values = new List(){"This ","is ","Sparta ","!"}; string outputValue = string.Empty; foreach (var value in values) { outputValue += value; } //CORRECT StringBuilder outputValueBuilder = new StringBuilder(); foreach (var value in values) { outputValueBuilder.Append(value); } ## 2. LINQ – ‘Where’ with ‘First’ instead of FirstOrDefault A lot of programmers find a certain set of elements by means of ‘Where’ and then return the first occurrence. This is inappropriate, because the ‘First’ method can be also applied with the ‘Where’ condition. What’s more, it shouldn’t be taken for granted that the value will always be found. If “First” is used when no value is found, an exception will be thrown. Thus, it’s better to use FirstOrDefault instead. When using FirstOrDefault, if no value has been found, the default value for this type will be returned and no exception will be thrown. … //INCORRECT var woman = (Woman)person; //CORRECT var woman = person as Woman; ## 4. Not using mapping for rewriting properties There are a lot of ready and very powerful C# mappers (e.g. AutoMapper). If a few lines of code are simply connected with rewriting properties, it’s definitely a place for a mapper. Even if some properties aren’t directly copied but some additional logic is performed, using a mapper is still a good choice (mappers enable defining the rules of rewriting properties to a big extend). … ## 8. Retrieving or saving data to DB in more than 1 call This is a very common mistake, especially among junior developers and especially when using ORMs like Entity Framework or NHibernate. Every DB call consumes some amount of time and therefore it’s crucial to decrease the amount of DB calls as much as possible. There are many ways to do so: - Using fetching (Eager Loading) - Enclosing DB operations in transactions - In case of a really complex logic, just moving it to the DB by building a stored procedure **It goes without saying that there are hundreds of other types of mistakes made by C# programmers. If you know any interesting ones or you want to share your opinion about the subject, feel free to leave a comment below! ** … business models) is that 1) it’s a lot of writing, 2) it’s easy to ommit some property that you want to rewrite from one object to another. Generally it’s not necessarily a problem when you have only a few properties, but it might be when you have many of them. So let’s say you have an entity Person and a … I was going to go into detail about the problems with this article but previous posters have already pointed out all the problems I noticed. I just want to add that I feel like articles like this are dangerous. While points 5 and 6 are, in my opinion, absolutely best practices that should be followed in 99% of cases the rest of the items are dependent on what you are doing, how much data you are working with, and a host of other considerations. To tell a developer “always use for instead of foreach” will generate a bunch of developers who don’t understand why other than they read it on some blog. … This highlights the real core of the “sloppyness”. With the rush to market mindset there’s almost no considereration what a program (or method) really should do. Discussions bloated with oneliners and one sided remarks do not really contribute in highlighting the real problems. I’m talking about pre- and posconditions, and invariants. The real sloppyness can be found here.

## 1. Naming Naming is one of the two hardest parts of Computer Science. And Microsoft doesn't help that much. On one hand, we have ".NET Core" renamed to ".NET". Everything is .NET now. Was it a marketing strategy? Dunno. Probably. On the other hand, target framework monikers. You know, the version number we put inside our .csproj files. For some time, they were `.netcoreapp1.X`, `.netcoreapp2.X`, and `.netcoreapp3.X`. But one day, they changed it. I imagine a conversation somewhere on Teams at Microsoft like this: - Let's change monikers too. Let's also use `.net` plus the version number. - Wait, we can't do `.net4`. We already have a .NET Framework 4.0. People will get confused. - Ok, let's jump to `.net5`. … ## 2. Too many releases It's a good thing we have an evolving ecosystem. I used to read all the release notes and tried to pick up as many new features as I could. Now? I only care about long-term versions. I don't even pay attention to the short-term ones. Something somewhere is a bit faster on an architecture I don't use at work. Sorry Microsoft! Too many releases make it harder to keep up. ## 3. C# is getting too bloated C# doesn't feel like a single language anymore. It feels like three languages: one pre-2010, one around 2010, and the one we have now. I used to closely follow every new language release. Not anymore. C# as a language is getting less consistent. Too many options to create and initialize objects, for example. Apart from nullable references and pattern matching and maybe another feature here and there, it's more and more syntactic sugar on every release. I'm only waiting for discriminated unions. The worst part is features that look the same but work differently. Yes, I'm looking at you, primary constructors. They look like records, but surprise, surprise...They work differently. ``` public record ThisIsARecord(string ThisIsAPublicProperty); public class ThisIsAClassUsingPrimaryConstructor(string ThisIsNotAPublicProperty) { } ``` This inconsistency makes the language harder to teach and learn. ## 4. AutoMapper Ok, there's nothing wrong with AutoMapper. But what frustrates me is that, for some reason, we have adopted it as the de facto mapping library. And most of the time, AutoMapper ends up getting in our way. Even AutoMapper's author recommends not to use it if we're mapping more than 80% of our fields by hand. But anyway, we use it even when we shouldn't. Just in the past weeks, I found two scenarios that got in my way, ignoring unmapped fields in the destination type and getting mappings flagged as invalid. Sure, I know I was abusing AutoMapper. I wanted to add EntityFramework Core to this list, but I'm starting to feel the frustration in my stomach. Probably, I'm hungry. But, frustrations aside, .NET is still my go-to platform and C#, my go-to language. … > And finally, now they are adding that so much syntactic sugar in order to make it more appealing for... pythonists? I used to follow every release in excitement for new features. but maybe apart from nullable references and pattern matching, it's more syntactic sugar with every recent release. Nothing we can't live without it.

Example: SQL Servers JDBC driver will convert an entire table's of data from ASCII to UTF and a full table scan instead of convertering your UTF bind to ASCII and using the ASCII based index. This doesn't break interop but does make it painful to code and one more reason to just use .Net. GiorgioG 3 months ago … 1. Process, process, and more process. Doing anything required layers of management approval. Trivial tasks become month long, or even years long, processes. 2. You have no power or agency. Something is broken? You're a developer, you should be able to fix it right? No. Broken things stay broken. You swim in your lane and keep your head down. Mediocrity is the goal. 3. Optimization doesn't exist. If a process is manual and takes you, a developer, 10 hours, then that's what it is. Nobody gives a flying fuck about tooling. Nobody cares if you spend 50% of your dev time doing random stuff. And if you even dare try to fix it, you will be told it's impossible and you're wasting your time. 4. Management is king. You will have to lie to them. You will have to spend time re-entering the same data in 5 different places so they can read it conveniently. You will have to make Excel workbooks. You will have to dumb things down, and then dumb them down again, and again. Everything is about Jira... Unless they're a really high up manager, in which case you have to take whatever is in Jira and put it in a word doc and send it to them, because they don't know how to open Jira. … Expect rigid scrum, using dependencies only supported by Microsoft etc, Locked down Dev machines with visual studio only, ask for microsoft dev certs, and expect pre-approved enterprise design patterns up the wazoo. They don't want innovative developers, they want you to fit into the pre existing framework designed by an architect. Your skills can die in such an environment.

For those of you who are programming in C#, what would you say are the biggest sources of pain, or at least discomfort, when using C#.

3MLOC C# web forms application dating back to 2002 and evolved since backed on SQL server on owned hardware.2. Along comes Remoting/DNA fad from MS P&P. Chunks rewritten into semi distributed nightmare on advice.3. Along comes WS-* fad from MS P&P. Chunks rewritten into even worse distributed nightmare on advice.4. Along comes MVC from MS. UI rewritten using this and EF.5. EF, WWF, Remoting, WS-* deprecated (yes all of them) and enough of MVC rewritten to break everything that's left (when they added async which is incidentally buggy as fuck even 10 years later with regular production deadlocks)6. . … Another set of massive breaking changes to the entire web pipeline which causes 3 months wall clock work for 3 people across 120 microservices.10. Try to get this shit working in kubernetes on linux and you find that the certificate store implementation is STILL based on the shitty half arsed APIs written in 2002 which has an abstraction which doesn't make sense on any platform other than windows resulting in 2 month delay on a project while people work out how to do cert management with hashicorp vault in this environment which ends up in a whole chunk of sticky tape and string just to get it out of the door.11. Along comes MSFT and says they're going to rebrand it all .Net 5.12. Everyone goes FUCK YOU we've had enough of this shit. No new projects on .Net / C#So the UI is going in the direction of React and Electron and the back end is Go, Python or Node. And the storage engine is going postgres. And this is all on AWS. And the grass is greener. There's some poo dotted around on it but it's not up to your neck.That's why C# is dying: Lots of people experienced with it don't want to get hurt any more. Id say C# is great at doing what it was made for, easy desktop app development. It probably looks like it works. Watch out for threads and service shutdowns. Sometimes the two are fairly incompatible and will hang service manager. Never as easy as it looks unfortunately. I worked with some big companies. They all use C#.

## 10th place. Try to find it Today's top starts with an error mentioned in the article about checking .NET 9. It feels like .NET 9 was just released, but a little over a month ago, .NET 10 replaced it. ... PVS-Studio warning: V3025 [CWE-685] Incorrect format. A different number of format items is expected while calling 'AppendFormat' function. Format items not used: {3}, {4}. Arguments not used: 1st. VMInstruction.cs 105 Calling the overridden `ToString` method inevitably causes an exception. This is due to an incorrect `sb.AppendFormat` call containing two errors. - The number of arguments to insert is less than the number of placeholders in the format string, which causes the exception. - Even if we fix the first issue by matching the number of arguments and placeholders, the call will still throw the exception. This is because placeholder indexing starts at 0, not 1. This means the fifth argument is required for the placeholder with index 4, which is absent. … PVS-Studio warnings: V3192 The 'Max' property is used in the 'GetHashCode' method but is missing from the 'Equals' method. ScottPlot CoordinateRangeMutable.cs 198 V3001 There are identical sub-expressions 'Equals(Min, other.Min)' to the left and to the right of the '&&' operator. ScottPlot CoordinateRangeMutable.cs 172 The analyzer issued two warnings for this code fragment. ... PVS-Studio warning: V3123 [CWE-783] Perhaps the '??' operator works in a different way than it was expected. Its priority is lower than priority of other operators in its left part. RecoveryMessage.cs 35 The analyzer issued several V3123 warnings for this code, but I've included only one for brevity. The `??`operator has lower precedence than the `+` operator. However, the formatting of this expression suggests developers expected the opposite. … PVS-Studio warning: V3207 [CWE-670] The 'not 0 or 1' logical pattern may not work as expected. The 'not' pattern is matched only to the first expression from the 'or' pattern. Files.App.Controls Omnibar.cs 149 Let's look closer at the `itemCount is not 0 or 1` part. Already guessed what's the issue? This pattern is redundant. Its second part affects nothing. When saying "x is not 0 or 1", people usually imply that x is neither 0 nor 1. However, in C#, operator precedence works differently—`x is not 0 or 1` actually means `x is (not 0) or 1`. Such mistakes can lead not only to redundancy but also to errors like `NullReferenceException: list is not null or list.Count == 0`. … ## 1st place. How does LINQ work? And the winner is an error from an article about checking the Lean trading engine. This error ranks first due to its subtlety. Some developers may not consider the effects of using deferred execution methods in combination with captured variables. All the details are below: … While iterating over the `csv` collection, the `lineNumber` variable is also incremented. As a result, each iteration increases `lineNumber by 2`: when the delegate runs and inside the `foreach`, which looks odd. Note the `lineNumber = 0` assignment before `foreach`. It's likely that developers expected that this variable could hold a non-zero value before the loop. However, that is impossible: `lineNumber` starts at zero, and the only place that changes it before the `foreach` sits in the delegate. As mentioned above, the delegate runs during iteration, not before it. Apparently, the developers expected the delegate to execute prior to entering the loop.