The ISEM Dev Club

isem-logo

mbb-logo

TL;DR? Skip straight to FAQ.

The (Boring) Introduction

In ISEM lab, in Biological/Ecology/Evolution sciences in general, and pretty much anywhere else, computer science technologies have undoubtely become pervasive: very useful maybe, very powerful maybe, in any case very much used throughout our institutions. People use software, need software, look for software, shake software, install software, insult software, bless software, drop software, write software, edit software, share software.. And by "software" here we do mean "programs", "scripts", "code", "pipelines", "applications", "libraries" and all that whatever stuff that runs on our computers, crunches data, burns power, processes for ages sometimes, and eventually spits plots, numbers, tables or p-values..

The problem we are facing as a community (and pretty much like anywhere else) is that this rise of computer science technologies has been too fast for us to catch up. We have been learning Biology, Ecology, Evolution for a while, and this makes a lot of sense. But we have not been learning computer science for a while, because it does not make sense, or it did not make sense at the time.
For some of us it's okay: we don't need this knowledge, or we have invested some time to learn the little we need and now we are confident enough to keep working.
For some of us it's not okay: technologies evolve fast, and there is a gap between the level of knowledge that we feel is required to do the work and the one we actually feel confident about.

This is unfortunate. But the community is strong, diverse and kind. Some of us happen to know more and teach the others, and this eases their paths towards a level of knowledge that makes them confident in doing their work. This is fortunate. This is what the dev club is about.

What's the Dev Club?

The dev club[why the name?] aims to be a safe and cosy place at ISEM where you'd be comfortable learning more about computer science, and become confident when your work requires so.

The dev club consists of:

  • A regular series of frequent in-person sessions at the lab, where someone volunteers to share their knowledge with a small audience. (I for instance am happy to volunteer a lot as a part of my actual mission.) The possible topics for these sessions are listed in the dev club catalogue, and the sessions are either held in French or in English depending on the audience. There is no obligation to attend regularly: just ask for a session whenever you want or join an upcoming one.

  • A chat room online[invitation link], which anyone in the lab can join to ask for computer science support, share knowledge, solve each other's problems while learning stuff. (I for instance am happy to participate a lot as a part of my actual mission.) In particular, the chat room is where we discuss the object of upcoming in-person sessions and who wants to join them. Discussions there are written in English.

  • This very website, along with the catalogue enclosed (sources here).

Building upon previous experience in sharing knowledge this way, there are a few features that the dev club is willing to enforce so as to remain attractive and cosy:

Large Online Chat Room, Small In-Person Sessions

The more people active on the chat room, the more opportunity to share knowledge, help each other out, and discuss fruitful ideas for the next in-person sessions.

The less people during in-person sessions, the easier to make sure that no one is left behind. It should be easy to check that everyone is keeping up. The audience should feel confident asking dummy questions about anything. It should be easy to adjust the live session to the needs of the ones present.

If a lot of people want to join the in-person sessions, then it means that these sessions need to become more frequent to ensure that they stay small and cosy. It is okay to repeat the same session several times so that everyone can attend.

Come Without Your Science

The dev club is meant to help you become confident in your use of computer science technologies at work. As such, it makes sense that the topics covered at ISEM dev club intent to always be useful to the audience in the context of Biology/Ecology/Evolution. By the way, you are welcome to share any topic of interest, if you think that it would be useful to others.

But if you come to the dev club with your very specific problem in mind, like the special hypothesis that characterizes of your research, or this nasty script that you have been stuck on for a week, then it is less likely that the story of that particular problem becoming solved will be useful to anyone else. In this situation, we suggest that you rather request support from the CS-related platforms at ISEM: ISI, MBB or Data depending on your needs. There is also ISDM support at Montpellier level.

Own Your Sessions

The dev-club is not going to plan in-person sessions on a regular, preemptive, rigid basis. Instead, you get to decide what you want to learn and when. There are two ways to join a session:

1. Pick an item from the calalogue and drop us a line in the channel to discuss what exactly you want to learn and when/where we could find room for a session. You get to own this session, as you are the initiative. To help us host the session, there is an ongoing reservation every Tuesday afternoon (1PM-5PM) for the meeting room in building 21 (3rd floor), but any other option is good as long as you've found a teacher and your schedules fit. In-person sessions have no predefined structure. Depending on the topic and the person(s) covering it, it may ressemble:

  • A formal presentation with a slideshow and like 15-20 people attending.
  • A hands-on practical session with only 3-4 people trying commands together on their laptops.
  • A simple informal Q&A-style chat on the whiteboard.
  • ..

Anything is okay as long as everyone feels confident and that knowledge is shared.

2. Reading from the channel, you are interested in a precise upcoming session owned by someone else. You can join provided your schedule matches and there is still room left. If you cannot attend and/or there is no room left, then don't worry: just roll back to the first option and become the owner of your next upcoming session.

 

 

teachem

Catalogue

Here is the catalogue of possible topics to discuss during the dev club in-person sessions. It does not reflect general topics of interest, or general recommendations which technology to use, and it does not even try not to be exhaustive in the context of Biology/Ecology/Evolution.

Instead, this catalogue is meant to reflect the local expertise that people in the lab are willing to share, and which we think would be fruitful to share. As a consequence, it is expected to evolve frequently [anything to offer?].

The catalogue is divided in two major parts. One is an ordered collection of topics which, taken together, constitute a full-fledged programming course useful to anyone willing to write their own programs. The other is an unstructured collection of topics more specifically related to BioInformatics and using computers for biological science.

Development

This is an ordered collection of topics for the dev club in-person sessions which, taken together, constitute a full-fledge programming course.

Prerequisites for all topics:

  • You are not confident how to write your own programs.
  • You want to learn how to write your own programs.
  • Pick a programming language[how?] among:

Other languages are welcome but not listed here in the Development section, either because there is no local expertise to share (yet), or because there is local expertise but then the languages are either inadequate in the context of the lab's activities or inadequate to learn programming. Of course, they can still be covered by other dedicated catalogue items:

  • Bash: restricted to system scripts, not general-purpose.
  • LaTeX: restricted to typesetting documents, not general-purpose.
  • Mathematica: requires a paid license.
  • C/C++: difficult to master, ill-advised for new projects or learning; mostly useful as legacy.
  • [need more? have one to offer?]

Learn to Program

If you wish so, this collection of topics intends to take you from a state where you have no idea that software could even be written by humans to a state where you stand out as an autonomous developer with decent programming skills.

Topic 1: Demystify

In scope:

  • Setup your machine.
  • Your first program:
    • R/Python/Julia: what is an interpreter.
    • Rust: what is a compiler.
  • Variables: the machine's memory.
  • Operators/Functions: the machine computes.
  • Outputs: the machine serves you.
  • Inputs: feed the machine data.
  • Branches (if/else): you make decisions.
  • Discuss simple exercises.
  • Share resources to get further on your own.

Topic 2: Native Types

In scope:

  • From ones and zeros to integers: decimal vs. binary encoding.
  • Signed integers.
  • Text characters.
  • Floating-point numbers and IEEE754.
  • R/Python:
    • Compound types: vectors, strings, lists, dicts, matrices, dataframes.
  • Julia/Rust:
    • References and pointers.
    • Compound types: arrays, vectors, maps, dicts.
  • Loops: the machine does not get tired.
  • Introduction to algorithmic complexity.

Topic 3: Code Semantics

In scope:

  • Functions: your code is meaningful and reusable.
  • Aliases and Copies: there is more to computer memory than meets the eye. What does a = b really means? What does f(a) really means?
    • R: copies by default.
    • Python/Julia: aliases by default.
    • Rust: the move semantics, shared references and mutability.
  • Discuss simple exercises, possibly from exercism.

Topic 4: Get organized

In scope:

  • Split your work into multiple files.
    • R: the package structure.
    • Python: packages and modules.
    • Julia: environment, packages and modules.
    • Rust: cargo, crates and modules.
  • Test your project.
    • R: testthat.
    • Python/Julia: native doctests.
    • Rust: native test modules and functions.
  • Document your project.
    • R: write your own help pages with Roxygen.
    • Python/Julia/Rust: docstrings and doctests.
    • Markdown, Bookdown, MdBook..

Topic 5: Creating your own types

By creating your custom types, you make your program more meaningful to humans: easier to understand, easier to modify without introducing bugs.

In scope:

  • Python:
    • Classes and methods.
    • Object-oriented programming.
    • Inheritance and associated pitfalls/good practices.
  • Julia:
    • Structs.
    • Multiple dispatch.
    • Type parameters and generic programming.
  • Rust:
    • Struct and enums: sum types and union types.
    • Methods and traits: composition.
    • Type parameters, trait bounds, and generic programming.

Creating custom types in R is overly complicated. R is a niche software to do statistics. If you need custom types in your program, then you have left the original scope of R and you probably need another language.

Topic 6: Metaprogramming

Machines can write code. Programs can write programs. This is very powerful, although you should mostly use this to alleviate boilerplate and ease readability.

In scope:

  • Python:
    • Decorators.
    • Metaclasses.
    • The eval function and associated pitfalls.
  • Julia/Rust:
    • Compile time vs. runtime.
    • The Abstract Syntaxic Tree (AST).
    • Macros and expansion.
    • Quoting and interpolation.
    • Hygiene and escaping/bending hygiene.

— Wait.. 6 topics and that's it: I am an "autonomous programmer with decent programming skills" already? õ.Ô

— Of course not: you need to practice a lot first, right? You had a science project when you first came: embrace it now, write code and code and code again to make it work. Have your code reviewed by peers. Learn cool things this way. Then eventually, yes, you'll become that for sure ;)

Learn to Use Programming Tools

There is software designed to help you develop software. If you are writing programs, then you do need them.

Topic: Integrated Development Environment (IDE)

Prerequisites:

  • You write scripts and code.

In scope:

  • Writing code is tedious:
    • Syntax: special characters, missing parentheses, long variable names.
    • Refactoring: change without breaking, run to test, wait! forgot a semicolon..
  • The 90's are over: you deserve state-of-the-art tooling.
  • IDEs are software to help you write code. They have become very sophisticated:
    • VSCode/VSCodium (used in this session).
    • Alternatives: Vim, RStudio (for R), Atom, IntelliJ, emacs..
  • The edition experience you deserve:
    • Automatic enclosers.
    • Automatic comment/uncomment lines/blocks.
    • Select valid expressions.
    • Move lines/blocks around up/down.
    • Vertical/multiple edition.
    • Record Macros.
    • Customise shortcuts: make it your own.
    • ...
  • The Language Server Protocol (LSP) and the features you deserve:
    • Syntactic coloring: make your code easy to parse.
    • Linting: highlight errors before you even run the code.
    • Autoformat: stop messing with whitespace/tabs by hand.
    • Code actions:
      • Rename identifiers.
      • Errors quickfix.
      • Extract variables.
      • Extract functions.
      • ...
  • The integration you deserve:
    • Invoke intepreter/compiler directly from your editor.
    • Pass lines/blocks to your interpreter.
    • The Debug Adapter Protocol (DAP): inspect your program execution live.

Git

Topic: 1 Git from Scratch

Prerequisites:

  • You write scripts and code.
  • You have already made deep copies of your files and folders before modifying any of your programs because you were worried about breaking anything.

In scope:

  • Introduction.
  • Configure the software.
  • Produce commits.
  • Publish your project on a shared repo (Github/Gitlab).
  • Branches and good practices.

Topic: 2 Collaborate with Git

Prerequisites (either):

  • You are not the only person writing code in your project.
  • You are, but you want to evolve parallel versions of your project.
  • You want to contribute to shared or open-source projects.

In scope:

  • Clone.
  • Fetch/Push to/from the same shared repo.
  • Git conflicts and what they really mean.
  • Merge/Rebase.
  • Good practices.

Topic: Good Practices: Code, Test, Documentation [support not ready yet]

Prerequisites:

  • You write scripts and code.
  • Someone (including yourself) has already broken something when modifying your programs.
  • Someone (including yourself) has a hard time understanding your own programs.

In scope:

  • Code is power:
    • Power is danger.
    • Examples of dangerous broken code.
  • Automated tests: guard against breakage.
    • Testing requires courage:
    • Code and tests are not only read by machines.
    • Example cryptic code.
  • Documentation is wisdom:
    • Bug definition: a bug is ill-defined without a specification.
    • You are human, speak to humans.
    • The various types of documentation:
      • For users:
        • Context: why using it, what to use it for.
        • Guide: how to use it.
        • Status: what's the project situation now.
      • For developers:
        • Implementation report: how does it work.
        • Technical details: why these choices, advantages/limitations.
      • For both: specifications: what does it do:
        • Informal.
        • Formal.
    • Documentation supports:
      • README.md
      • Docstrings.
      • Comments.
      • Tests.
      • Identifiers names.
      • Code style.
    • If you loose all but documentation remains, you can rebuild everything easily.

Topic: (Neo)Vim

Prerequisites:

  • You write scripts and code.
  • You are confident with your keyboard.
  • You like keyboard mappings / shortcuts / macros / automations, anything that speeds up your workflow.
  • You are willing to spend weeks (no kidding) learning / configuring a very sophisticated piece of software, just so it fits your exact needs and eventually bring you closer to coding at the ultimate speed of thought.

In scope:

  • Introduction to vim/neovim.
    • First steps with :vimtutor/:Tutor.
    • Disable <left>/<right>/<up>/<down>: focus on your home row.
    • Practice. Practice. Practice.
    • Config file:
      • Custom mappings.
      • "Metamaps" to easily add/modify mappings.
      • Start crafting your own home.
    • Navigate files.
  • Vimscript/lua.
  • Extensions.
  • Developing with vim/neovim: at least all IDE features should become a breeze.

Computer Science Tools for Biology/Ecology/Evolution

These topics are not exactly relevant to learn how to program, but they are definitely useful in day-to-day or occasional use of a computer in Biology/Ecology/Evolution.

Topic: Linux/Bash/Zsh

Prerequisites:

  • There is a linux machine that you interact with or are about to interact with.

In scope:

  • What is an OS: Windows, Unix, MacOs, Linux.. Step away from your hardware.
  • The shell: interact with the OS. Sh, Bash, Zsh..
  • Basic commands: ls, cd, echo, cat, mkdir, rm, less, etc.
  • Your terminal should be comfy: make it your own:
    • Abuse shortcuts: <tab>, <c-r>, <c-u>..
    • Custom aliases.
    • Themes and sophisticated autocompletion: OhMyZsh/p10k.
    • Configuration files: be yourself at home, anywhere, .bashrc, .zshrc, source.
  • How linux is organised: /home, /, /usr, /dev, /mnt, lsblk, /opt, etc.
  • Ownership and permissions: the root user, su, sudo, chown, chmod, etc.
  • Think before you type.
  • The multiple command inputs:
    • Arguments.
    • Standard input (stdin).
    • Environment.
  • The multiple command outputs:
    • Return code.
    • Standard outputs (stdout, stderr).
    • Border effects: (print, operations..).
  • Redirections and piping: >, |, &>, >>, <<, tee, etc.
  • Synchronicity and parallelism: &, sleep, etc.
  • A programming language:
    • Variables and interpolations.
    • Branches and short-circuiting, &&, ||, () subshells.
    • Write a shell script.
    • Functions and arguments.
    • Loops.. but at this point maybe you need a better language?
  • Important system environment variables: $PATH, $PWD, $LANG, etc.
  • How the shell works and the meaning of which/type.

Topic: Text-processing

Prerequisites:

  • You have already issued some commands in Linux / Bash / Zsh.
  • You need perform simple operations on large or numerous text files.

In scope:

  • Basic text-oriented commands: cat, head, tail, tac, etc.
  • Regexes
    • Exert/learn with Regex101.
    • Matches, wildcards, alternates, repetitions..
    • Substitution, captures, greediness/lazyness.
    • The different regex flavours.
    • The limit of regexes: use a proper parser for more.
  • Text-oriented programs:
    • grep/rg: find the needle in a haystack.
    • sed/perl: transform needles in a haystack.
    • awk/frawk: transform the haystack.

Topic: Containers

In scope:

  • Introduction to docker/singularity.

Topic(s): Python libraries

Prerequisites:

In scope (either):

Topic: Conda and python environments

Prerequisites (either):

  • You have already become upset because of python/modules versions mismatches.
  • You are not confident how to best distribute your python program.

In scope:

  • Manage your various python environments.

Topic: Snakemake

Prerequisites (either):

  • Your are confident running linux programs one after the other.
  • You are having a hard time running your whole pipeline again and again.
  • You are not confident how to best distribute your pipeline.

In scope:

  • Automated your pipeline recipes with Snakemake.

Topic: HPC/Slurm/Cluster [support not yet ready]

Prerequisites:

  • You are confident with basic Linux/bash.
  • You are not confident how to submit jobs on a shared calculation cluster.

In scope:

  • Interact with shared computing resources.

Topic: MBB Workflows

Prerequisites:

  • <TODO>

In scope:

  • Automate your pipelines with WAW/SubWAW.

Topic: Awk, a programming language

Prerequisites:

  • You are confident running basic linux / bash commands.
  • You want to learn more about awk.

In scope:

  • Awk model of a text file.
  • Structure of the awk script.
  • Power and limitations.
  • Regexes.

Resources:

LaTeX

Topic: Introduction to LaTeX

Prerequisites:

  • You have written a LaTeX document.
  • You want to learn about LaTeX.

In scope:

  • Setup your machine.
  • What is LaTeX, how to use it.
  • Write/compile your first LaTeX document.
  • Customize text typeset.
  • Floating environments, counters and references.
  • Bibliography.
  • Create your own commands to factorize your doc.

Topic: Tikz

Prerequisites:

  • You are confident writing/compiling basic LaTeX documents.

In scope:

  • Draw pixel-perfect vector graphics with your keyboard.
  • Program your graphics.

Resources:

Topic: Inkscape

In scope:

  • Install Inkscape.
  • What is inkscape, vector-graphics vs. bitmaps.
  • Draw pixel-perfect vector graphics with your mouse.
  • Sophisticated inkscape features.

Topic: Mathematica, an Introduction

Requirements:

  • Paid licence.

In scope:

  • Symbolic calculation with the computer.
  • Documentation.
  • Plots.
  • Functional programming.
  • Syntacting sugar.
  • Manipulable graphics.
  • Performances and Compilation.

Topic: C++, Use and Dangers

Requirements:

  • You are fluent in another language, (like topic 5 or topic 6).
  • You have understood that Rust is just as fast and powerful although much safer and modern.
  • You need to dive into a legacy C++ project. (like, there is really no other option)

In scope:

  • Introduction.
  • Resources for learning.
  • Variables, references and pointers.
  • Language legacy pitfals:
  • Memory safety:
    • Undefined Behaviour (UB).
    • Resource Acquisision Is Initialization (RAII).
    • « There is more to a pointer than meets the eye » [1] [2] [3].
  • Build with Cmake.
  • Test with Catch2.

Resources:

Every topic can be characterized by:

  • Prerequisites: If you meet these conditions, then you may be interested in a session on this topic. If you don't then you may not, but you're always welcome.

  • In scope: A collection of issues that are relevant to the topic, and can be discussed during the session. The dev club suggests to avoid discussing out-of-scope issues during the session, but it is okay to not cover all of them. Depending on the audience, some issues can be skipped or they can be covered in depth at the expense of other issues. If the session is too short to cover all the issues that the audience was willing to discuss, then the dev club suggests a follow-up session: there is no point in rushing when more time is required.

How do I choose a programming language?

This section is meant to help you choose, depending on your situation, a programming language to start with. It only focuses on the programming languages discussed in the ISEM dev catalogue. Also, the advice given here is supposed to be only valid within the scope of using programming languages for research in Biology/Ecology/Evolution.

Regardless of the language chosen, it is always good to:

For example, you can practice for free and get feedback on your code at exercism.org (feel free to ping me there as a mentor). Or you can ask for feedback on the dedicated dev club channel.

R-logo

[wikipedia] [official] [exercism]

Advised if:

  • You want to automate what R has been designed for:
    • Read data.
    • Manipulate data tables.
    • Fit statistical models.
    • Produce graphics/plots.

Example resources:

Ill-advised if:

  • You need to implement your own sophisticated logic/model (poor programming features, poor naive performances).
  • Your project is going to be large (poor static checking).
  • You are looking for a good, general-purpose programming language.

python-logo

[wikipedia] [official] [exercism]

Advised if:

  • You want to learn programming.
  • You want to automate scientific calculations (numpy/scipy, matplotlib, pandas/polars, ..):
    • Read data.
    • Manipulate data tables.
    • Perform calculations.
    • Produce graphic/plots.
  • You want to automate system tasks (pathlib, subprocess..):
    • Create/modify/delete files.
    • Launch other system programs (bash, R, ..).
    • Send e-mails.
    • whatever..
  • You want to use machine learning libraries like torch.
  • You need to implement your own sophisticated logic/model.

Example resources:

Ill-advised if:

  • Performance is a concern for your own logic/model.

julia-logo

[wikipedia] [official] [exercism]

Advised if:

  • You want to learn programming.
  • You need powerful scientific packages:
  • You need sophisticated meta-programming tools (code that write code).
  • Performance is a concern for your own logic/model.

Example resources:

Ill-advised if:

  • Your program takes a small time to run but is run frequenly (julia is fast to run but slow to start).
  • Your project is going to be large (poor static checking).

Rust

rust-logo

[wikipedia] [official] [exercism]

Advised if:

  • You want to learn programming in depth.
  • Performance is a major concern for your own logic/model.
  • You need to be very strict how your program behaves and make sure it handles all possible errors correctly.
  • You are an experienced C/C++ programmer and (either):
    • You are tired of C++ and feel like it should be deprecated.
    • You spend a lot of time investigating data races and segmentation faults.
    • You worry that someone (including yourself) may easily introduce data races or segmentation faults into your program.

Example resources:

Ill-advised if:

  • Your project is going to be very simple or very small.
  • You are not interested in lower-level details how programming works.

FAQ

The club.

Who can join?

If you work in ISEM then well, you're already part of the club. Welcome :)

We unfortunately don't have the bandwidth to invite everyone in Montpellier yet, but maybe one day.

How do I join?

Well, you have already found this website, keep it in your bookmarks: ⭐.
To see what's happening day-to-day, follow this invitation link to join our zulip chat room: ⭐.

Why the name?

The dev in "dev club" stands for development, as in "developing computer programs", which actually stands for "writing code" like in "writing a script", but also extends to "composing algorithms", "designing software", "assembling pipelines", "creating applications", "authoring libraries" etc.

Much of the complicated computer science stuff that people in our lab(s) become confused or reluctant about, be it related to machines, disks/RAM/CPU/GPU, computation models, operating systems, networks, versions numbers, algorithmic complexity, whatever.. revolves around this peculiar phenomenon that a human being can write a computer program. Becoming confident with this phenomenon makes you confident with a large region of the computer science world. This is what the dev club would like to focus on.

What kind of support do you provide?

🎓 I need to learn how to do <X> with my computer.

You're in the right place! Come explain what you want to learn in the sessions channel. Hopefully we can organize an in-person session soon to teach you just that.

🧪 I need help to design / fix / improve my project.

The dev-club is only meant to help you acquire general-purpose CS-related skills (mastering a programming language, a new software..).
We really hope this can help, but if you need something very specific about your particular project, then you'd rather find support on either of the following other resources at ISEM:

  • The ISI platform provides hardware/infrastructure support (physical machines, network connections..).
  • The MBB platform provides software/design support (development, pipelines..).
  • The DATA plaftorm provides data support (data management, FAIR sharing..).

You can also find support at Montpellier level with ISDM's Clinique des Données:

with frequent in-person sessions organized in various places to help you with your own project.

💔 I have bugs in my code!

Don't stay on your own! Come explain your problem in the debug channel. We'll do our best to help you. And hopefully we'll learn something on the way :)

⁉️I need help, but I'm not sure what exactly :(

It's okay. Just explain your problem and ask. We'll do our best to help you find the appropriate support :)

What's this Zulip thing?

Zulip is the chat room where we discuss. Follow this invite link to join.

Zulip is 100% free and open source software ❤️
In addition, Zulip sponsors hosted plans when it's 100% useful for academic research. So they have accepted sponsoring the club, and we enjoy a free standard plan on their servers. Big up to them 💖

How do I use it? How do I know what's happening?

Just connect and read what's up. Messages are organized in thematic channels, and conversations are isolated within distinct topics within these channels so we don't get everything mixed up. You can either see all messages in a gigantic pooled timeline with the grouped thread view, or you can navigate within individual channels/conversations with the column on your left. There are numerous settings you can tweak to make the software fit your expectations and improve your experience.

HELP! 🛟 All information there: https://zulip.com/help/.

Why not good old e-mails?

There is too much going on to flood all@isem by e-mail. But you can setup your zulip account to get you informed by e-mail what's happening there.
If you want to participate in conversations though, then you'll need to connect to zulip.

I don't want to install a new app! I already have like <N> different chat groups.

I know, I'm sorry, we all do.

Fortunately, there is no need to install a new application for everything: most of this chat software (Zulip/Slack/Mattermost/Discord/Whatsapp/Matrix/Element/..) can already be run in your internet browser (= Firefox/Chrome/Safari/Edge/Explorer/Brave/Opera/..). You can:

  • Use separate browser tabs to open all of them simultaneously within the same window.
  • Use a separate browser window to not interfere with your daily navigation / research.
  • Use bookmarks to not forget about any of the groups you are involved in.
  • Use a password manager like KeePass to help you securely manage one different password for every website.

Alternately, you can install Ferdium: one single application to run them all.

Ferdium is free and open-source software ♡

HELP! 🛟
Of course, if you need help doing any of that, drop us a line by e-mail and we'll help you through.

Will I get notifications?

Yes, provided you allow your browser or Ferdium to let them bubble up to your desktop.

There are too many notifications!

Every channel/topic can be fine-grained-muted so you can only focus on the conversations you're interested in. You can also setup your notifications settings at the global level.

Can I run it on my phone?

Sure. Just install the zulip app.

What are these in-person sessions?

The dev-club frequently meets to share computer-science-related skills and knowledge. But we don't all meet together at once! Sessions are meant to be small and focused, so that anyone can feel confident in joining and ask dummy questions about the topic they want to learn.

It is only on Tuesdays?

No. Sessions are held whenever we need, provided we find time and a room to host us. Tuesdays afternoon in building 21 are booked just in case, to help us doing that.

Is it only in English?

Communications on the chat room are written in English for inclusivity (there are like 15+ different countries represented at ISEM). But in-person sessions can be either held in French or in English depending on the audience.

When is the next session?

Upcoming sessions are announced within this channel of the chat room. Click on topics prefixed with a date like 2024-10-25 <session>. to figure what we'll cover and whether there is still room for you.
The other topics there are discussions about sessions not yet decided, join in!

I want to join but there is no room left.

Don't worry. Learning together is easier in small groups. Just ask for a new session and we'll organize a new one for you :)

Can you teach anything?

We wish we could, but of course we can only teach what people in the club are confident enough to teach. If you can find your topic in the catalogue, then it means that we definitely can. If you don't, then don't hesitate to ask anyway, we'll do our best to find someone or redirect you towards online resources.

I would like a session on <X>.

Come and ask on the sessions channel. If <X> is something we can teach, then you'll become the owner of the next session.

I have learned a lot, but I'm not sure how to practice now.

Come and ask in the practice channel. Also, there is ongoing discussion whether/how to hold pure practice in-person sessions. We could possibly practice together on fun toy projects. This is always a great opportunity to learn cool stuff. Join in :)

If you'd rather practice on your own, you can also join one of the numerous Exercism language tracks to find thousands of interesting toy exercises designed to help you make progress.

If you're happy with your solution to a problem, come share it within the code review channel to get feedback from the club.
If you feel stuck and don't understand how to get further, come ask for help within the debug channel.
Anything's good as loong as we keep learning :)

Do you play.. games?

Err.. not sure? Depends on whether you get fun when writing computer programs. If you do then *waow-cool* come play with us! Ever heard of AoC for example? Coding challenges are a very fruitful way to practice 0;)