Merge pull request #455 from NLeSC/431-broken-links

chore: fix broken links and replace HTTP URLs with HTTPS

Author: ewan-escience

README.md

@@ -32,7 +32,7 @@ We also provide [technology guides](/technology/technology_overview.md) on digit
 All of the text in this guide is backed by our own experiences in developing high quality research software.
 However, we also learn from and share knowledge with other community-driven research software guides.
 The two most important of these are [The Turing Way](https://book.the-turing-way.org/index.html) and the
-[Research Software Quality Kit](http://everse.software/RSQKit/).
+[Research Software Quality Kit](https://everse.software/RSQKit/).
 Their scope is slightly different, but we collaborate with them when we can.
 
 ## Contributing

best_practices.md

@@ -12,7 +12,7 @@ Great examples can be found via [FAIR Software NL](https://fair-software.nl/reco
 
 Use a version control tool like `git` to track changes in your codebase.
 This allows you to retrace your steps when debugging, keep your repository clean, easily collaborate with others asynchronously and more.
-More info: [The Turing Way chapter on Version Control](https://book.the-turing-way.org/reproducible-research/vcs), [RSQkit chapter on Version Control](http://everse.software/RSQKit/using_version_control).
+More info: [The Turing Way chapter on Version Control](https://book.the-turing-way.org/reproducible-research/vcs), [RSQkit chapter on Version Control](https://everse.software/RSQKit/using_version_control).
 
 **At the Netherlands eScience Center:** we always use version control and we preferably use GitHub as our online repository and collaboration platform (see the [Project Management Protocol of the Netherlands eScience Center](https://doi.org/10.5281/zenodo.17117777).
 
@@ -58,7 +58,7 @@ Examples include exchange formats like Unicode, NetCDF, and W3C web standards, a
 ## Licensing
 
 Since source code is protected by copyright, to allow people to use your code it needs a license.
-For more information, see [The Turing Way chapter on licensing](https://the-turing-way.netlify.app/reproducible-research/licensing) or the [RSQkit Licensing software task](http://everse.software/RSQKit/licensing_software).
+For more information, see [The Turing Way chapter on licensing](https://the-turing-way.netlify.app/reproducible-research/licensing) or the [RSQkit Licensing software task](https://everse.software/RSQKit/licensing_software).
 
 **At the Netherlands eScience Center:** our first choice is the Apache v2 license.
 See the [our Project Management Protocol](https://doi.org/10.5281/zenodo.17117777) for more details on licensing and our intellectual property policies.
@@ -74,7 +74,7 @@ For more information you can also [read here](https://github.com/the-turing-way/
 Releases are a way to mark or point to a particular milestone in software development.
 This is useful for users and collaborators, e.g. I found a bug running version x.
 For publications that refer to software, refering to a specific release enhances the reproducability.
-See [the RSQkit task on Creating code releases](http://everse.software/RSQKit/releasing_software) for the most essential guidelines.
+See [the RSQkit task on Creating code releases](https://everse.software/RSQKit/releasing_software) for the most essential guidelines.
 The Turing Way offers many related tips in their [chapter on Making Research Objects Citable](https://book.the-turing-way.org/communication/citable), like how to make code citable with CITATION.CFF files.
 
 ## Packaging

language_guides/ccpp.md

@@ -15,7 +15,7 @@ The latest ratified standard of C++ is C++17. The first standardised version of
 There are two main-stream open-source C++ compilers.
 
 - [GCC](https://gcc.gnu.org/)
-- [LLVM - CLANG](http://llvm.org/)
+- [LLVM - CLANG](https://llvm.org/)
 
 Overall, these compilers are more or less similar in terms of features, language support, compile times and (perhaps most importantly) performance of the generated binaries.
 The generated binary performance does differ for specific algorithms.
@@ -44,16 +44,16 @@ And linker flags:
 
 ### Interpreter
 
-There **is** a C++ interpreter called [Cling](https://rawgit.com/vgvassilev/cling/master/www/index.html).
-This also comes with a [Jupyter notebook kernel](http://jupyter.org/try).
+There **is** a C++ interpreter called [Cling](https://rawcdn.githack.com/root-project/cling/master/www/index.html).
+This also comes with a [Jupyter notebook kernel](https://jupyter.org/try).
 
 ### Build systems
 
 There are several build systems that handle C/C++.
 Currently, [the CMake system is most popular](https://www.jetbrains.com/research/devecosystem-2018/cpp/).
 It is not actually a build system itself; it generates build files based on (in theory) platform-independent and compiler-independent configuration files.
 It can generate Makefiles, but also [Ninja](https://ninja-build.org/) files, which gives much faster build times, NMake files for Windows and more.
-Some popular IDEs keep automatic count for CMake, or are even completely built around it ([CLion](http://www.jetbrains.com/clion/)).
+Some popular IDEs keep automatic count for CMake, or are even completely built around it ([CLion](https://www.jetbrains.com/clion/)).
 The major drawback of CMake is the confusing documentation, but this is generally made up for in terms of community support.
 When Googling for ways to write your CMake files, make sure you look for "modern CMake", which is a style that has been gaining traction in the last few years and makes everything better (e.g. dependency management, but also just the CMake files themselves).
 
@@ -70,7 +70,7 @@ With either one of these two (CMake or Autotools), any moderately experienced us
 There are many other systems.
 Microsoft Visual Studio has its own project model / build system and a library like Qt also forces its own build system on you.
 We do not recommend these if you don't also supply an option for building with CMake or Autotools.
-Another modern alternative that has been gaining attention mainly in the GNU/Gnome/Linux world is [Meson](http://mesonbuild.com/), which is also based on [Ninja](https://ninja-build.org/).
+Another modern alternative that has been gaining attention mainly in the GNU/Gnome/Linux world is [Meson](https://mesonbuild.com/), which is also based on [Ninja](https://ninja-build.org/).
 
 ### Package management
 
@@ -111,7 +111,7 @@ You can point `pkg-config` to your additional libraries by setting the `PKG_CONF
 This also helps for instance when trying to automatically locate dependencies from CMake, which has `pkg-config` support as a fallback for when libraries don't support CMake's `find_package`.
 
 If you want to keep things organized on systems where you use multiple versions of the same software for different projects, a simple solution is to use something like `xstow`.
-[XStow](http://xstow.sourceforge.net/) is a poor-mans package manager.
+[XStow](https://xstow.sourceforge.net/) is a poor-mans package manager.
 You install each library in its own directory (`~/.local/pkg/<package>` for instance), then running `xstow` will create symlinks to the files in the `~/.local` directory (one above the XStow package directory).
 Using XStow in this way alows you to keep a single additional search path when compiling your next library.
 
@@ -168,7 +168,7 @@ People of this persuasion would usually recommend any of the following editors:
   - [editorconfig](https://github.com/editorconfig/editorconfig-vim)
   - [stl.vim](https://www.vim.org/scripts/script.php?script_id=4293) adds STL to syntax highlighting
   - [Syntastic](https://github.com/scrooloose/syntastic)
-  - Integrated debugging using [Clewn](http://clewn.sourceforge.net/)
+  - Integrated debugging using [Clewn](https://clewn.sourceforge.net/)
 - Emacs:
   - Has GDB mode for debugging.
 - More modern editors: Atom / Sublime Text / VS Code
@@ -190,7 +190,7 @@ C++ (and C) compilers come with built in linters and tools to check that your pr
 
 #### Automatic Formatting with clang-format
 
-While most IDEs and some editors offer automatic formatting of files, [clang-format](http://clang.llvm.org/docs/ClangFormat.html) is a standalone tool, which offers sensible defaults and a huge range of customisation options. Integrating it into the CI workflow guarantees that checked in code adheres to formatting guidelines.
+While most IDEs and some editors offer automatic formatting of files, [clang-format](https://clang.llvm.org/docs/ClangFormat.html) is a standalone tool, which offers sensible defaults and a huge range of customisation options. Integrating it into the CI workflow guarantees that checked in code adheres to formatting guidelines.
 
 #### Static code analysis with GCC
 
@@ -240,7 +240,7 @@ which is a fast memory error detector. There are also other options available li
 
 #### Dynamic program analysis using the valgrind suite of tools
 
-The [valgrind suite of tools](http://valgrind.org/info/tools.html) has tools similar to what is provided by the `-fsanitize` compiler flag as well as various profiling tools. Using the valgrind tool memcheck to detect memory errors is typically slower than using compiler provided option, so this might be something you will want to do less often. You will probably want to compile your code with debug symbols enabled (`-g`) in order to get useful output with memcheck. When using the profilers, keep in mind that a [statistical profiler](https://en.wikipedia.org/wiki/Profiling_%28computer_programming%29#Statistical_profilers) may give you more realistic results.
+The [valgrind suite of tools](https://valgrind.org/info/tools.html) has tools similar to what is provided by the `-fsanitize` compiler flag as well as various profiling tools. Using the valgrind tool memcheck to detect memory errors is typically slower than using compiler provided option, so this might be something you will want to do less often. You will probably want to compile your code with debug symbols enabled (`-g`) in order to get useful output with memcheck. When using the profilers, keep in mind that a [statistical profiler](https://en.wikipedia.org/wiki/Profiling_%28computer_programming%29#Statistical_profilers) may give you more realistic results.
 
 ### Automated code refactoring
 
@@ -273,7 +273,7 @@ These can typically be installed from a wide range of [package managers](#packag
 These scientific libraries are well known, widely used and have a lot of good online documentation.
 
 - [GNU Scientific library (GSL)](https://www.gnu.org/software/gsl/doc/html/index.html)
-- [FFTW](http://www.fftw.org): Fastest Fourier Transform in the West
+- [FFTW](https://www.fftw.org/): Fastest Fourier Transform in the West
 - [OpenMPI](https://www.open-mpi.org). Use with caution, since it will strongly define the structure of your code, which may or may not be desirable.
 
 ### Boost
@@ -288,7 +288,7 @@ As a general rule, don't use Boost when there is equivalent STL functionality.
 
 ### xtensor
 
-[xtensor](http://github.com/xtensor-stack/xtensor) is a modern (C++14) N-dimensional tensor (array, matrix, etc) library for numerical work in the style of Python's NumPy.
+[xtensor](https://github.com/xtensor-stack/xtensor) is a modern (C++14) N-dimensional tensor (array, matrix, etc) library for numerical work in the style of Python's NumPy.
 It aims for maximum performance (and in most cases it succeeds) and has an active development community.
 This library features, among other things:
 
@@ -313,15 +313,15 @@ This library features, among other things:
 ### Parallel processing
 
 - [oneAPI Threading Building Blocks](https://oneapi-src.github.io/oneTBB/) (oneTBB): template library for task parallelism
-- [ZeroMQ](http://zeromq.org): lower level flexible communication library with a unified interface for message passing between threads and processes, but also between separate machines via TCP.
+- [ZeroMQ](https://zeromq.org/): lower level flexible communication library with a unified interface for message passing between threads and processes, but also between separate machines via TCP.
 
 ## Style
 
 ### Style guides
 
 Good style is not just about layout and linting on trailing whitespace. It will mean the difference between a blazing fast code and a broken one.
 
-- [C++ Core Guidelines](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)
+- [C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)
 - [Guidelines Support Library](https://github.com/Microsoft/GSL)
 - [Google Style Guide](https://google.github.io/styleguide/cppguide.html)
 - [Google Style Guide - github](https://github.com/google/styleguide) Contains the CppLint linter.
@@ -343,18 +343,18 @@ IDE.
 
 ### Documentation
 
-Use [Doxygen](http://www.doxygen.nl/). It is the de-facto standard way of inlining documentation into comment sections of your code. The output is very ugly. Mini-tutorial: run `doxygen -g` (preferably inside a `doc` folder) in a new project to set things up, from then on, run `doxygen` to (re-)generate the documentation.
+Use [Doxygen](https://www.doxygen.nl/). It is the de-facto standard way of inlining documentation into comment sections of your code. The output is very ugly. Mini-tutorial: run `doxygen -g` (preferably inside a `doc` folder) in a new project to set things up, from then on, run `doxygen` to (re-)generate the documentation.
 
-A newer but less mature option is [cldoc](http://jessevdk.github.io/cldoc/).
+A newer but less mature option is [cldoc](https://jessevdk.github.io/cldoc/).
 
 ## Resources
 
 ### Online
 
 - [CppCon videos](https://www.youtube.com/user/CppCon): Many really good talks recorded at the various CppCon meetings.
-- [CppReference.com](http://en.cppreference.com/w/)
+- [CppReference.com](https://en.cppreference.com/w/)
 - [C++ Annotations](http://www.icce.rug.nl/documents/cplusplus/)
-- [CPlusPlus.com](http://www.cplusplus.com/)
+- [CPlusPlus.com](https://cplusplus.com/)
 - [Modern C++, according to Microsoft](https://msdn.microsoft.com/en-us/library/hh279654.aspx)
 
 ### Books

language_guides/fortran.md

@@ -10,8 +10,8 @@ numerical compute workloads, with no existing alternative. In this case it is re
 ## Recommended sources of information
 
 - [Fortran90 best practices](https://github.com/certik/fortran90.org/blob/master/src/best-practices.rst).
-- [Fortran wiki](http://fortranwiki.org/fortran/show/HomePage)
-- [Fortran90 handbook](http://micro.ustc.edu.cn/Fortran/Fortran%2090%20Handbook.pdf)
+- [Fortran wiki](https://fortranwiki.org/fortran/show/HomePage)
+- [Fortran90 handbook](https://micro.ustc.edu.cn/Fortran/Fortran%2090%20Handbook.pdf)
 
 ## Compilers
 
@@ -30,12 +30,12 @@ There exist many commercial performance profiling tools by Intel and the Portlan
 ## Editors and IDEs
 
 Most lightweight editors provide Fortran syntax highlighting. Vim and emacs are most widely used, but for code
-completion and refactoring tools one might consider the [CBFortran](http://cbfortran.sourceforge.net/) distribution of Code::Blocks.
+completion and refactoring tools one might consider the [CBFortran](https://cbfortran.sourceforge.io/) distribution of Code::Blocks.
 
 ## Coding style conventions
 
 If working on an existing code base, adopt the existing conventions. Otherwise we recommend the
-standard conventions, described in the [official documentation](https://github.com/certik/fortran90.org/blob/master/src/best-practices.rst#fortran-style-guide) and the [Fortran company style guide](http://www.fortran.com/). We would like to add the following advice:
+standard conventions, described in the [official documentation](https://github.com/certik/fortran90.org/blob/master/src/best-practices.rst#fortran-style-guide) and the [Fortran company style guide](https://www.fortran.com/). We would like to add the following advice:
 
 - Use free-form text input style (the default), with a maximal line width well below the 132 characters imposed by the Fortran90 standard.
 - When a method does not need to alter any data in any module and returns a single value, use a function for it, otherwise use a subroutine. Minimize the latter to reasonable extent.

language_guides/javascript.md

@@ -74,7 +74,7 @@ Solid has a meta-framework called [SolidStart](https://start.solidjs.com/).
 
 Most JavaScript is run in web browsers, but if you want to run it outside of a browser (e.g. as a server or to run a script locally), you'll need a JavaScript **runtime**. These are the main runtimes available:
 
-- [Node.js](https://nodejs.org) is the most used runtime, mainly for being the only available runtime for a long time. This gives the advantage that there is a lot of documentation available (official and unofficial, e.g. forums) and that many tools are available for Node.js. It comes with a [package manager (npm)](https://www.npmjs.com/) that allows you to install packages from a huge library. Its installation instructions can be found [here](https://nodejs.org/en/learn/getting-started/how-to-install-nodejs).
+- [Node.js](https://nodejs.org) is the most used runtime, mainly for being the only available runtime for a long time. This gives the advantage that there is a lot of documentation available (official and unofficial, e.g. forums) and that many tools are available for Node.js. It comes with a [package manager (npm)](https://www.npmjs.com/) that allows you to install packages from a huge library. Its installation instructions can be found [here](https://nodejs.org/en/download).
 - [Deno](https://deno.com/) can be seen as a successor to Node.js and tries to improve on it in a few ways, most notably:
   - [built-in support](https://docs.deno.com/runtime/fundamentals/typescript/) for TypeScript
   - a better [security model](https://docs.deno.com/runtime/fundamentals/typescript/)