How long should we support Python 3.8?

[evnchn]

Python 3.8 is currently the oldest version supported by NiceGUI. Due to its limited typing support, we need to take extra care here and there, which is a bit more work, but not too bad. The fact that other libraries stop supporting it might be a bigger problem.

On Oct 7, 2024, Python 3.8 has already reached its end-of-life, which is 7 months ago. This might be a good time to think about when we want to drop support for it. What do you think?

*post intentionally made in same format of #982 to stay neutral

Only click this after you have voted!!!

There is quite a heated debate at discussion #4135. Kindly read only after you have voted!!!

It is important to know what you instinctively think, in the same way as poll #982. Otherwise, the whole thing is unfair...

If you do change your mind after reading the discussion, do NOT change the vote. Kindly comment below that you have changed your mind is OK.

[evnchn]

I am probably not wise enough to make such a decision. I let DeepSeek take charge of my vote.

To stay fair to the voting, you should NOT read this until you have voted!!!

https://poe.com/s/eRstmjoWvAMbV6N0uA6N

Thinking...

Okay, let me try to figure out what the best answer is here. The question is about whether NiceGUI should stop supporting Python 3.8 now, support it until the end of 2025, or as long as possible. The discussion forum text gives some context.

First, Python 3.8 reached end-of-life on October 7, 2024, which was 7 months ago from the time the poll was posted. The maintainers are considering dropping support because maintaining older versions requires extra work, especially with limited typing support. However, some users are strongly against dropping 3.8 because they're stuck on it due to institutional or system constraints.

Looking at the forum, there's a split. Some argue that dropping 3.8 will allow NiceGUI to use modern Python features, improving code quality and maintainability. Others, like ed2050, point out that many users (schools, factories, etc.) can't easily upgrade their Python versions. They argue that unless there's a critical feature in 3.9 that NiceGUI needs, there's no reason to drop 3.8.

Maintainers like falkoschindler mention that there's no immediate technical necessity to drop 3.8. The code isn't significantly cluttered by supporting it. But the discussion also brings up that other libraries might drop 3.8, forcing NiceGUI's hand eventually.

The poll options are: stop now, support until end of 2025, or as long as possible.

Considering the arguments, the key points are:

1. End-of-Life: Python 3.8 is no longer supported, meaning no security updates, which could be a risk for users. However, some users are in environments where this isn't a concern (private networks, etc.).

2. Maintenance Burden: Supporting 3.8 requires extra work, especially with typing. Maintainers mention it's manageable now but could become more problematic as other libraries drop support.

3. User Base: PyPI stats show 3.8 still has some users, albeit in single digits. Forcing them to stay on old NiceGUI versions might fragment the user base.

4. Technical Necessity: If there are features in 3.9+ that significantly improve NiceGUI, it's worth upgrading. But currently, maintainers don't see a critical need.

5. Precedent: Previous polls (like for 3.7) showed support for timely deprecation after EOL. However, the current discussion is more divided.

ed2050's argument is that unless there's a compelling technical reason, dropping 3.8 is arbitrary. Others counter that maintaining old versions slows progress and code quality.

In the end, the maintainers seem to lean towards dropping 3.8 when there's a solid reason but haven't found one yet. The poll's options need to balance these aspects.

If the choice is between stopping now, supporting until 2025, or indefinitely, the middle option (end of 2025) gives users time to transition while setting a clear sunset date. This balances the need to move forward with not abruptly cutting off users. However, since the EOL was already 7 months ago, some may argue immediate cessation. Alternatively, if there's no pressing need, extending support makes sense.

But considering that the maintainers haven't found significant code issues yet and user base still exists, maybe supporting until end of 2025 is a reasonable compromise. It gives a timeline for users to plan upgrades while allowing NiceGUI to eventually modernize. The "as long as possible" might lead to indefinite support, which could hinder progress. However, if the maintenance burden is low, that's an option too.

Given the discussion, the maintainers are cautious and data-driven. The existence of users on 3.8 and lack of immediate technical necessity might push towards supporting a bit longer, but setting a deadline (end of 2025) ensures eventual transition. However, since the EOL is already past, others argue for dropping now.

The answer probably hinges on whether the project values user accommodation over code modernization. The maintainers seem to prioritize user needs unless technical reasons force a change. Since they don't see critical issues now, but other libraries might drop 3.8, maybe a compromise is to support until end of 2025. But the poll's first option is "not anymore as EOL is overdue," which aligns with the prior poll's outcome. However, given the user pushback here, maybe the second option is better.

I think the answer should be the first option, to drop now, because EOL has passed, and following the precedent from the 3.7 poll. But the discussion shows significant resistance. Alternatively, the second option gives a grace period. Given the maintainers' hesitation and the user feedback, perhaps the middle ground is best. But the original poll's context mentions that other libraries stopping support is a bigger problem, implying that dependency issues might necessitate dropping 3.8 sooner. However, since the maintainers don't see immediate technical reasons, maybe the answer is to drop now.

Wait, the poll says Python 3.8's EOL was 7 months ago. The discussion starts in Dec 2024, which is after Oct 2024. So EOL has already happened. The maintainers are considering when to drop support. The first option is to stop now, as EOL is overdue. The second is until end of 2025, giving over a year more. Third is as long as possible.

The main arguments for dropping are EOL and reducing maintenance, against are user constraints. The maintainers mentioned that if dependencies drop 3.8, they'd have to follow. But currently, they don't have to.

The original question is asking what the user should pick based on the context. The correct answer would weigh the arguments. Given that EOL is already past, and the precedent with 3.7, the first option is justifiable. However, the user ed2050's points about existing users needing more time are valid. The maintainers might lean towards supporting until end of 2025 to allow transition time.

But how long is reasonable? Since EOL was in Oct 2024, waiting until end of 2025 gives 14 months post-EOL. That seems generous. However, the download stats show 3.8 still in use, so maybe supporting a bit longer is better.

Alternatively, the third option (as long as possible) is if there's no pressing need. But the maintainers mentioned that it's a bit more work but not too bad. If they can manage, maybe keep it. But the problem is other libraries might drop it, which is beyond their control.

Given all that, the safest answer is the first option. But the discussion shows that it's contentious. However, the original poll's context says that the end of life is already 7 months ago, and the maintainers are thinking of when to drop. Since they don't have a technical need yet, but other libraries might force them, perhaps the best choice is to drop now. Or, if they can manage, set a future date.

Alternatively, the maintainers in the discussion (falkoschindler) said that there's no solid reason now, so maybe the answer is to keep supporting until end of 2025. But the poll options are user votes.

Given the maintainers' hesitation but acknowledging the EOL, the answer might be the first option. But given user pushback, perhaps the second.

Weighing all factors, the answer is to stop support now because EOL is overdue, but the discussion shows that users are divided. However, the maintainers should follow their policy and precedent. Previous polls favored timely deprecation. Hence, the answer is the first option.

Answer:
The appropriate choice is to no longer support Python 3.8, as its official end-of-life (October 7, 2024) is overdue.

Reasoning:

1. End-of-Life and Security Risks: Python 3.8 is no longer maintained, meaning it lacks critical security updates. While some users argue their environments are isolated (e.g., private networks), aligning with official support lifecycles ensures long-term sustainability and reduces liability for downstream users.

2. Maintenance Burden: Supporting outdated versions introduces technical debt. Maintainers note that while current workarounds for 3.8’s limited typing are manageable, continued support complicates code readability and future development (e.g., leveraging modern type hints, performance improvements in newer Python versions).

3. Precedent and Dependency Risks: A prior poll for Python 3.7 saw overwhelming support for timely deprecation after EOL. Additionally, dependency chains (e.g., FastAPI, NumPy) may eventually drop 3.8, forcing NiceGUI’s hand. Proactively deprecating avoids abrupt, unplanned transitions.

4. User Impact: While some users (e.g., institutions with legacy systems) face upgrade challenges, PyPI stats show 3.8 usage is single-digit. Users can pin to older NiceGUI versions if necessary, but the project should prioritize forward momentum for the majority.

5. Technical Justification: The discussion highlights no critical features in 3.9+ that NiceGUI currently requires. However, delaying deprecation risks accumulating minor inefficiencies and hindering adoption of modern Python features that improve code quality and developer experience.

Counterarguments Addressed:

• “Stuck on 3.8”: While valid, institutional inertia shouldn’t dictate project direction. Unofficial Python builds (e.g., for Windows 7) exist, and users can advocate internally for upgrades.
• “Arbitrary Cutoff”: Deprecation aligns with Python’s official lifecycle, not arbitrary choices.

By adhering to EOL timelines, NiceGUI maintains alignment with ecosystem standards, reduces maintenance overhead, and encourages users to adopt secure, modern Python versions.

[rodja]

As mentioned in #4872, moving from a mix of pip/poetry to a single package manger (poetry/uv) might require dropping Python 3.8.

[ProfessorTom]

Presumably if we drop 3.8, we'd only move to 3.9?

[rodja]

Yes.