# Python for scientific computing November 2025

## Details
- Tue 25+ Wed 26+ Thu 27 / November, 4 hours per day with 1h lunch break in between
- (Helsinki timezone) 10:00-12:00 (lunch break 12:00 - 13:00) + 13:00-15:00
- You all have a calendar invitation sent a month ago
- Webpage for 2025 run: to be updated
- Registration link: coming
- Materials: https://aaltoscicomp.github.io/python-for-scicomp/ (to be moved under coderefinery github org)
- Internal notes from previous run: https://hackmd.io/BzCbZh9PS0GLoc--PImq3g?both
- New roles doc: https://docs.google.com/spreadsheets/d/1YUD4L4uDKRgX9ArED5oNBGDYcbeW_VBZjCd12T4uf24/edit

# Tasks

| Task | Person | Due date |
| -------- | -------- | -------- |
| Moving materials to coderefinery github org | ?? | Later |
| Webpage + registration page | EG | 10/October |
| Mark what you want to teach | Everyone | 10/October
| Installations + installation sessions | EG | 10/October |
| Checking situation with issues + last year's feedback | EG | 10/October|
| ? | ? | ? |

# Roles
*Some things are copied from 2024 run*
- Coordinator: Enrico (deputy: Richard)
- registrations
- communication with participants
- assigns lessons and tasks
- director / host (intros, outros, etc)
- Streamer: Richard (deputy: Enrico)
- zoom studio room
- any streaming related things
- twitch related things
- Communication
- Finland: Enrico
- Norway: Sabry
- Sweden: Diana
- Denmark
- Estonia:
- Iceland: Heman
- Social media:
- Instructors:
- JH "[e-mail]" <[e-mail]>;
- EG "Glerean Enrico" <[e-mail]>;
- ~~"[e-mail]" <[e-mail]>; ~~
- RD "Darst Richard" <[e-mail]>;
- SW "[e-mail]" <[e-mail]>;
- SR "[e-mail]" <[e-mail]>;
- JR "Rantaharju Jarno" <[e-mail]>;
- MvV "van Vliet Marijn" <[e-mail]>;
- TP "Pfau Thomas" <[e-mail]>;
- LN "Niemi Lauri" <[e-mail]>;
- DI "diana iusan" <[e-mail]>;
- ST "Tuomisto Simo" <[e-mail]>
- AM "Ashwin Mohanan"
- SM "Susa Merz" <[e-mail]>
- HM "Hemanadhan Myneni" <[e-mail]>

# Topics + voting
:::danger
Read this:
*1) Vote for which topic you would like to teach in 2025*
*2) Vote for more than you will actually do in the end*
*3) Not all topics listed below will be covered*
*4) Add more topics if you plan developing new materials*
*5) Those highlighted, are those that WERE included in the 2024 run*
*6) You can add more notes under each topic (e.g. I want to revise this and that)*
:::

* ==Introduction to Python==:
* 2024 instructors: RD, EG
* 2025 instructors: SM, EG
* ==Jupyter==:
* 2024 instructors: DI, RD
* 2025 instructors: ??, DI
* ==NumPy==:
* 2024 instructors: AM, YW
* 2025 instructors: SM, ==MvV==
* Advanced NumPy:
* 2025 instructors: MvV (if needed)
* ==Pandas==:
* 2024 instructors: ST, RD
* 2025 instructors: ??, MvV
* ==Xarray==:
* 2024 instructors: GD, MvV
* Gregor won't be around this time, should we skip it this year and do Advanced Numpy?
* @wmvanvliet: I can teach with someone else. Xarray is super useful.
* 2025 instructors: MvV, AM
* Plotting with Matplotlib (should we skip it like last year?)
* 2025 instructors:
* ==Plotting with Vega-Altair==
* 2024 instructors: RB, RD
* 2025 instructors: ST, ==SW==
* ==Working with Data==:
* 2024 instructors: TP, ST
* 2025 instructors: ST, ==TP==
* ==Scripts==:
* 2024 instructors: TP, YW
* 2025 instructors: ==TP==, ==ST==
* ==Profiling==:
* 2024 instructors: GD, RB
* 2025 instructors: ???
* ==Productivity tools==:
* 2024 instructors: GD, RB
* 2025 instructors: ???
* SciPy:
* 2025 instructors: JH
* ==Library ecosystem==:
* 2024 instructors: TP
* 2025 instructors: ==TP==
* ==Dependency management==:
* 2024 instructors: RB, SR, ST
* 2025 instructors: SR, ST
* Binder:
* 2025 instructors:
* ==Parallel programming==:
* 2024 instructors: JH, RD
* 2025 instructors: JH, ==SM==
* ==Packaging==:
* 2024 instructors: AM, RD
* 2025 instructors: ??, ==SM==
* Web APIs with Python:
* 2025 instructors:
* ==Cython==:
* 2025 instructors: LN, (AM, tentative)
* Use (updated) material from [CSC "Python for HPC" course](https://github.com/csc-training/hpc-python)
* ?? new topic here ??
* 2025 instructors:
* ?? new topic here ??
* 2025 instructors:

---
# BLOG

# To Code or Not to Code? Python or R? Or ChatGPT?
*Is software coding a skill of the past with generative AI tools?*

Every researcher today faces the dilemma “why am I doing this? 😩”, no sorry, not THAT existential dilemma, but this one: "Should I learn how to code? Should I improve my coding skills? What is the point of spending time on that in 2025 with AI everywhere? Isn't AI going to replace all coders?"

Ok, I get it, with **large language models (LLMs) like ChatGPT, Copilot, Claude**, it has never been easier to ***look* like a coder**. Just describe what you want in plain language, and *boom*: a piece of code appears in less than 15 seconds, ready to be copy-pasted to wherever you will run the code. Sometime **these tools even run the code for you** (*what could possily go wrong? 😅*)! Here’s the catch: do you actually know what your code is doing? Or where/how these tools are running things for you? Do you **trust** the process and the final result so that you can put your name on it and be accountable in the peer review process?

If you are not fully sure what your copy-pasted code is doing... well, the results can range from confusing to catastrophic. You need just a small typo by the LLM (and yes, those tiny errors happen daily) and *oops*... the code deletes all your data, breaks your analysis right before the deadline, or even worse, leads to research misconduct if your outputs turn out to be wrong (aka **falsification**, eventually followed by retraction).

I am not trying to scare you, but if you are doing research that requires computations, it is definitely worth learning how to code, or **at least learning how to *read and run* your own code** without relying entirely on some AI assistant. Think of it as learning how to drive before activating autopilot: you’ll understand the technology more, and you will always stay in control.

## Python or R?

Most likely you have already some coding experience from your past, but you might not still feel confident about your coding skills, and I have now convinced you to go deeper. The next question then arises: **Python or R?**

Python and R are the two most popular choices when it comes to programming languages for scientific research. Choosing between them can feel like choosing between coffee and tea: both great, just different.

**Python** is the multi-tool of programming languages: it does everything from data analysis and machine learning to web apps and hardware control. The vast amount of libraries just makes it the perfect choice for researchers so that you do not have to write all basic methods by yourself, instead you just need to combine existing pieces to build your analysis pipeline.

**R**, on the other hand is a little bit more niche: it is loved by statisticians and data scientists for its elegant syntax and powerful visualization tools. Some complex statistical models and analysis tools basically only exist in R, and, because of that, it still rules in many research fields.

So, which one should you learn? As usual the answer is: "it depends". But our advice: why not learn both?

Understanding both languages gives you the superpower to read and reuse other researchers’ work, collaborate more effectively, and eventually pick the right one for each project. It’s like being multilingual in the world of data science.

## Learn with us at Aalto Scientific Computing, CodeRefinery, and CSC!

The good news: you don’t have to embark on this learning journey alone! At Aalto Scientific Computing, together with our extended network at CodeRefinery and CSC, we offer upcoming courses to get you started:

- Python for Scientific Computing (add dates etc)
- Data analysis with R (add dates etc)

These courses are designed to make your learning experience hands-on and relevant to real research problems, they are beginner friendly, and there is alway something for the most advanced users. Not sure where to start? Just look at what your peers are using, and pick one.

And if you’re feeling adventurous, there’s a whole world beyond Python and R: Julia, Rust, MATLAB, C++, and even CUDA for GPU programming. Learning how to code is a lifelong learning path, and it can be an enjoyable one, even just as a reader rather than someone who will have to *speak* the language you will learn. Let's take this path together and learn from each other. See you at one of these upcoming courses!