Fix dead links (#530)

* Switch to remark-lint

This adds a new Github action to run the remark-lint
plugin remark-lint-no-dead-urls to check for dead
links. I think this is a much better tool as compared
to the previous one as this one skips the relative-urls
and also has an option to skip localhost.

* Update links

This fixes most of the dead/changed links if not all.
Some of the links have been removed since they were not
available anymore. Most of the links have been updated
to their corresponding new links.

Resolves #524

.github/workflows/remark-lint-no-dead-urls.yml

@@ -0,0 +1,17 @@
+name: remark-lint check for dead links
+
+on: [push, pull_request]
+
+jobs:
+  verify-links:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v1
+      - name: Setup Node
+        uses: actions/setup-node@v1
+        with:
+          node-version: '10'
+      - name: Install remark
+        run: npm install -g remark-lint remark-cli remark-lint-no-dead-urls
+      - name: Verify links
+        run: remark -q -u lint-no-dead-urls .

_publications/DTP16.md

@@ -10,6 +10,5 @@ journal: " Transportation Research Part B: Methodological"
 volume: "93"
 pages: "57--74"
 doi: https://doi.org/10.1016/j.trb.2016.07.003
-link: https://shuvomoy.github.io/site/Papers/TR-partB-2016.pdf
 ---
 In this paper we propose a novel two-step linear optimization model to calculate energy-efficient timetables in metro railway networks. The resultant timetable minimizes the total energy consumed by all trains and maximizes the utilization of regenerative energy produced by braking trains, subject to the constraints in the railway network. In contrast to other existing models, which are NP-hard, our model is computationally the most tractable one being a linear program. We apply our optimization model to different instances of service PES2-SFM2 of line 8 of Shanghai Metro network spanning a full service period of one day (18 h) with thousands of active trains. For every instance, our model finds an optimal timetable very quickly (largest runtime being less than 13 s) with significant reduction in effective energy consumption (the worst case being 19.27%). Code based on the model has been integrated with Thales Timetable Compiler - the industrial timetable compiler of Thales Inc that has the largest installed base of communication-based train control systems worldwide.

_publications/DYFF19.md

@@ -38,4 +38,4 @@ While we speculate that a highly-optimized distributed implementation in, say, C
 implementation in Julia, from our perspective as machinelearning researchers (as opposed to HPC researchers), the latter
 also offers a practical and monetary value due to the ease of
 development and abstraction level. Our code is publicly available
-at https://github.com/dinarior/dpmm subclusters.jl
+at https://github.com/dinarior/dpmm_subclusters.jl

_publications/HPOEPP16.md

@@ -15,5 +15,5 @@ volume: "7"
 number: "12145"
 doi: "10.1038/ncomms12145"
 packages:
-  CellwiseEditingDifferentiation.jl: https://github.com/scidom/CellwiseEditingDifferentiation.jl
+  CellwiseEditingDifferentiation.jl: https://github.com/papamarkou/CellwiseEditingDifferentiation.jl
 ---

blog/_posts/2012-02-14-why-we-created-julia-zh_CN.md

@@ -13,17 +13,12 @@ trackbacks:
     - Phoronix: "http://www.phoronix.com/scan.php?page=news_item&px=MTA2ODg"
     - The Endeavor (John D. Cook): "http://www.johndcook.com/blog/2012/02/22/julia-random-number-generation/"
     - Walking Randomly: "http://www.walkingrandomly.com/?p=87"
-    - Miguel Bazdresch: "http://2pif.info/op/julia.html"
     - Douglas Bates: "http://dmbates.blogspot.in/2012/03/julia-version-of-multinomial-sampler_12.html"
     - Vince Buffalo: "http://vincebuffalo.org/2012/03/07/thoughts-on-julia.html"
     - John Myles White: "http://www.johnmyleswhite.com/notebook/2012/03/31/julia-i-love-you/"
-    - Shane Conway: "http://www.statalgo.com/2012/03/24/statistics-with-julia/"
     - Tim Salimans: "http://timsalimans.com/gibbs-sampling-with-julia/"
-    - Twitter trackbacks: "http://topsy.com/julialang.org/"
     - Russian translation: "http://habrahabr.ru/blogs/programming/138577/"
     - Linux.org.ru blog post (Russian): "http://www.linux.org.ru/news/opensource/7440863"
-    - Simplified Chinese translation: "http://sd.csdn.net/a/20120223/312315.html"
-    - Traditional Chinese translation: "http://www.hellogcc.org/archives/666"
     - Linuxfr.org blog post (French): "http://linuxfr.org/news/version-1-0-de-julia"
 ---
 

blog/_posts/2012-02-14-why-we-created-julia.md

@@ -13,17 +13,13 @@ trackbacks:
     - Phoronix: "http://www.phoronix.com/scan.php?page=news_item&px=MTA2ODg"
     - The Endeavor (John D. Cook): "http://www.johndcook.com/blog/2012/02/22/julia-random-number-generation/"
     - Walking Randomly: "http://www.walkingrandomly.com/?p=87"
-    - Miguel Bazdresch: "http://2pif.info/op/julia.html"
     - Douglas Bates: "http://dmbates.blogspot.in/2012/03/julia-version-of-multinomial-sampler_12.html"
     - Vince Buffalo: "http://vincebuffalo.org/2012/03/07/thoughts-on-julia.html"
     - John Myles White: "http://www.johnmyleswhite.com/notebook/2012/03/31/julia-i-love-you/"
-    - Shane Conway: "http://www.statalgo.com/2012/03/24/statistics-with-julia/"
     - Tim Salimans: "http://timsalimans.com/gibbs-sampling-with-julia/"
-    - Twitter trackbacks: "http://topsy.com/julialang.org/"
     - Russian translation: "http://habrahabr.ru/blogs/programming/138577/"
     - Linux.org.ru blog post (Russian): "http://www.linux.org.ru/news/opensource/7440863"
     - Simplified Chinese translation: "https://julialang.org/blog/2012/02/why-we-created-julia-zh_CN"
-    - Traditional Chinese translation: "http://www.hellogcc.org/archives/666"
     - Linuxfr.org blog post (French): "http://linuxfr.org/news/version-1-0-de-julia"
 ---
 

blog/_posts/2012-03-11-shelling-out-sucks.md

@@ -149,7 +149,7 @@ That wasn't successful.
 What's going on?
 
 The heart of the problem is that when you shell out, the commands in the pipeline are not immediate children of the main program, but rather its grandchildren:
-the program spawns a shell, which makes a bunch of UNIX pipes, forks child processes, connects inputs and outputs to pipes using the [`dup2` system call](https://developer.apple.com/library/IOs/#documentation/System/Conceptual/ManPages_iPhoneOS/man2/dup2.2.html), and then execs the appropriate commands.
+the program spawns a shell, which makes a bunch of UNIX pipes, forks child processes, connects inputs and outputs to pipes using the [`dup2` system call](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/dup2.2.html), and then execs the appropriate commands.
 As a result, your main program is not the parent of the commands in the pipeline, but rather, their grandparent.
 Therefore, it doesn't know their process IDs, nor can it wait on them or get their exit statuses when they terminate.
 The shell process, which is their parent, has to do all of that.

blog/_posts/2013-03-30-julia-tutorial-MIT.md

@@ -27,13 +27,13 @@ The rationale and vision behind julia, and its design principles are discussed i
 
 ## Statistical Models in Julia ([slides](https://github.com/JuliaLang/julia-tutorial/raw/master/Stats/slides.pdf))
 
-This session demonstrates Julia's statistics capabilities, which are provided by these packages: [Distributions](https://github.com/JuliaStats/Distributions.jl), [GLM](https://github.com/JuliaStats/GLM.jl), and [LM](https://github.com/JuliaStats/LM.jl).
+This session demonstrates Julia's statistics capabilities, which are provided by these packages: [Distributions](https://github.com/JuliaStats/Distributions.jl), [GLM](https://github.com/JuliaStats/GLM.jl), and [LM](https://github.com/JuliaStats/GLM.jl).
 
 <iframe width="560" height="315" src="https://www.youtube.com/embed/v9Io-p_iymI" frameborder="0" allowfullscreen></iframe>
 
 ## Fast Fourier Transforms
 
-Julia provides a built-in interface to the [FFTW](http://www.fftw.org/) library. This session demonstrates the Julia's [signal processing](http://docs.julialang.org/en/release-0.1/stdlib/base/#signal-processing) capabilities, such as FFTs and DCTs. Also see the [Hadamard](https://github.com/stevengj/Hadamard.jl) package.
+Julia provides a built-in interface to the [FFTW](http://www.fftw.org/) library. This session demonstrates the Julia's signal processing capabilities, such as FFTs and DCTs. Also see the [Hadamard](https://github.com/stevengj/Hadamard.jl) package.
 
 <iframe width="560" height="315" src="https://www.youtube.com/embed/1iBLaHGL1AM" frameborder="0" allowfullscreen></iframe>
 
@@ -45,13 +45,13 @@ This session focuses largely on using Julia for solving linear programming probl
 
 ## Metaprogramming and Macros
 
-Julia is homoiconic: it represents its own code as a data structure of the language itself. Since code is represented by objects that can be created and manipulated from within the language, it is possible for a program to transform and generate its own code. [Metaprogramming](http://docs.julialang.org/en/release-0.1/manual/metaprogramming/) is described in detail in the Julia manual.
+Julia is homoiconic: it represents its own code as a data structure of the language itself. Since code is represented by objects that can be created and manipulated from within the language, it is possible for a program to transform and generate its own code. [Metaprogramming](https://docs.julialang.org/en/v1/manual/metaprogramming/#) is described in detail in the Julia manual.
 
 <iframe width="560" height="315" src="https://www.youtube.com/embed/EpNeNCGmyZE" frameborder="0" allowfullscreen></iframe>
 
 ## Parallel and Distributed Computing ([Lab](https://github.com/JuliaLang/julia-tutorial/raw/master/NumericalOptimization/tutorial.pdf), [Solution](https://github.com/JuliaLang/julia-tutorial/blob/master/NumericalOptimization/Tutorial.jl))
 
-[Parallel and distributed computing](http://docs.julialang.org/en/release-0.1/manual/parallel-computing/) have been an integral part of Julia's capabilities from an early stage. This session describes existing basic capabilities, which can be used as building blocks for higher level parallel libraries.
+[Parallel and distributed computing](https://docs.julialang.org/en/v1/manual/parallel-computing/) have been an integral part of Julia's capabilities from an early stage. This session describes existing basic capabilities, which can be used as building blocks for higher level parallel libraries.
 
 <iframe width="560" height="315" src="https://www.youtube.com/embed/JoRn4ryMclc" frameborder="0" allowfullscreen></iframe>
 

blog/_posts/2013-04-05-distributed-numerical-optimization.md

@@ -104,7 +104,7 @@ expect an MPI wrapper for Julia will appear in the future (see also <a
 href="https://github.com/lcw/julia-mpi">here</a>).
 
 Reading the <a
-href="http://docs.julialang.org/en/release-0.1/manual/parallel-computing/">manual</a>
+href="https://docs.julialang.org/en/v1/manual/parallel-computing/">manual</a>
 on parallel computing is highly recommended, and I won't try to reproduce it in
 this post. Instead, we'll dig into and extend one of the examples it presents.
 
@@ -138,7 +138,7 @@ The implementation of ``pmap`` in Julia is
 
 On first sight, this code is not particularly intuitive. The ``@spawnlocal``
 macro creates a *<a
-href="http://docs.julialang.org/en/latest/manual/control-flow/#man-tasks">task</a>*
+href="https://docs.julialang.org/en/v1/manual/control-flow/#man-tasks">task</a>*
 on the *master process* (e.g. process 1). Each task feeds work to a
 corresponding worker; the call ``remotecall_fetch(p, f, lst[idx])`` function
 calls ``f`` on process ``p`` and returns the result when finished. Tasks are

blog/_posts/2013-04-08-put-this-in-your-pipe.md

@@ -333,6 +333,6 @@ This is the same Cartesian product expansion that the shell does if multiple `{.
 
 ## Further Reading
 
-You can read more in Julia's [online manual](http://docs.julialang.org/en/release-0.1/manual/running-external-programs/), including how to construct complex pipelines, and how shell-compatible quoting and interpolation rules in Julia's backtick syntax make it both simple and safe to cut-and-paste shell commands into Julia code.
+You can read more in Julia's [online manual](https://docs.julialang.org/en/v1/manual/running-external-programs/), including how to construct complex pipelines, and how shell-compatible quoting and interpolation rules in Julia's backtick syntax make it both simple and safe to cut-and-paste shell commands into Julia code.
 The whole system is designed on the principle that the easiest thing to do should also be the right thing.
 The end result is that starting and interacting with external processes in Julia is both convenient and safe.

blog/_posts/2013-05-10-callback.md

@@ -5,7 +5,7 @@ author: <a href="http://math.mit.edu/~stevenj">Steven G. Johnson</a>
 ---
 
 One of the great strengths of Julia is that it is so easy to [call C
-code](http://docs.julialang.org/en/latest/manual/calling-c-and-fortran-code.html) natively, with no special "glue" routines or overhead to marshal
+code](https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/) natively, with no special "glue" routines or overhead to marshal
 arguments and convert return values.  For example, if you want to call
 [GNU GSL](http://www.gnu.org/software/gsl/) to compute a special function
 like a [Debye integral](http://linux.math.tifr.res.in/manuals/html/gsl-ref-html/gsl-ref_7.html), it is as easy as:
@@ -90,7 +90,7 @@ with information about the environment in which the function was
 defined; we will talk more about this below.  In any case, it is a
 very different object than a simple pointer to machine code for one
 set of argument types.  Fortunately, we can get the latter simply by
-calling a [built-in Julia function](https://docs.julialang.org/en/stable/manual/calling-c-and-fortran-code/#Closure-cfunctions-1) called `cfunction`:
+calling a [built-in Julia function](https://docs.julialang.org/en/v1/manual/calling-c-and-fortran-code/#Closure-cfunctions-1) called `cfunction`:
 
     const mycompare_c = cfunction(mycompare, Cint, (Ptr{Cdouble}, Ptr{Cdouble}))
 
@@ -213,7 +213,7 @@ The `qsort` interface is nowadays considered rather antiquated.  Years
 ago, it was supplemented on BSD-Unix systems, and eventually in GNU
 libc, by a function called `qsort_r` that solves the problem of passing
 parameters to the callback in a re-entrant way.  This is how the BSD (e.g. MacOS)
-`qsort_r` function [is defined](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man3/qsort_r.3.html):
+`qsort_r` function [is defined](https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man3/qsort.3.html):
 
     void qsort_r(void *base, size_t nmemb, size_t size, void *thunk,
                  int (*compare)(void *thunk, const void *a, const void *b));
@@ -275,8 +275,8 @@ which of course uses an argument order incompatible with *both* the
 BSD and GNU `qsort_r` functions).  Worse, it will crash on GNU/Linux
 systems, which *do* provide `qsort_r` but with an
 [incompatible](http://www.memoryhole.net/kyle/2009/11/qsort_r.html)
-[calling
-convention](http://www.cygwin.com/ml/libc-alpha/2008-12/msg00008.html). And
+calling
+convention. And
 as a result it is difficult to use `qsort_r` in a way that does not
 crash either on GNU/Linux or BSD (e.g. MacOS) systems.  This is how
 glibc's `qsort_r` is defined:

blog/_posts/2013-05-23-graphical-user-interfaces-part2.md

@@ -247,7 +247,7 @@ You can see these details in `rubberband.jl`.
 For many GUIs in Julia, an important component will be the ability to display data graphically.
 While we could draw graphs directly with Cairo, it would be a lot of work to build from scratch; fortunately, there's an excellent package, Winston, that already does this.
 
-Since there's a nice set of [examples](https://github.com/nolta/Winston.jl/blob/master/doc/examples.md) of some of the things you can do with Winston, here our focus is very narrow: how do you integrate Winston plots into GUIs built with Tk.
+Since there's a nice set of [examples](https://winston.readthedocs.io/en/latest/examples.html) of some of the things you can do with Winston, here our focus is very narrow: how do you integrate Winston plots into GUIs built with Tk.
 Fortunately, this is quite easy.
 Let's walk through an example:
 

blog/_posts/2013-09-04-fast-numeric.md

@@ -254,4 +254,4 @@ Here are a couple of packages that might be useful for those interested in high
 
 * [Devectorize.jl](https://github.com/lindahua/Devectorize.jl) – macros and functions to de-vectorize vector expressions. With this package, users can write computations in high-level vectorized way while enjoying the high run-time performance of hand-coded de-vectorized loops.
 
-Check out the [Julia package list](http://pkg.julialang.org/) for many more packages. Julia also ships with a [sampling profiler](http://docs.julialang.org/en/latest/stdlib/profile) to measure where your code is spending most of its time. When in doubt, measure don't guess!
+Check out the [Julia package list](http://pkg.julialang.org/) for many more packages. Julia also ships with a [sampling profiler](https://docs.julialang.org/en/v1/stdlib/Profile/) to measure where your code is spending most of its time. When in doubt, measure don't guess!

blog/_posts/2014-08-09-juliacon-opt-session.md

@@ -7,7 +7,7 @@ author: <a href="https://github.com/quinnj">Jacob Quinn</a>
 ## Optimization Session
 <br/>
 
-### [Iain Dunning](http://iaindunning.com/) / [Joey Huchette](http://www.mit.edu/~huchette/) — [JuliaOpt](http://www.juliaopt.org/) - Optimization Packages for Julia
+### [Iain Dunning](http://iaindunning.com/) / Joey Huchette — [JuliaOpt](http://www.juliaopt.org/) - Optimization Packages for Julia
 
 Iain Dunning and Joey Huchette are both doctoral students in the Massachusetts Institute of Technology Operations Research Center, where they study constrained continuous and combinatorial numerical optimization methods and theory. In this session they present the JuliaOpt suite of optimization packages and how they interoperate. They also discuss how various Julia features enable exciting functionality in these packages.
 
@@ -27,7 +27,6 @@ Madeleine Udell is a PhD candidate in Computational & Mathematical Engineering a
 
 - **Video:** <http://youtu.be/SoI0lEaUvTs>
 - **Slides:** <http://goo.gl/Nfy14D>
-- **Website:** <http://web.stanford.edu/~udell/>
 
 <br/>
 

blog/_posts/2014-08-20-julia-0.3-release.md

@@ -34,18 +34,18 @@ Happy coding.
 
 **News**
 
-[JuliaBloggers](http://www.juliabloggers.com/) and the [searchable package listing](http://pkg.julialang.org/) were recently introduced.
+[JuliaBloggers](https://www.juliabloggers.com/) and the [searchable package listing](http://pkg.julialang.org/) were recently introduced.
 
 The first ever [JuliaCon](http://www.juliacon.org) was held in Chicago in June, 2014. Several session recordings are available, and the others will be released soon:
 
-- [Opening session](http://julialang.org/blog/2014/08/juliacon-opening-session/)
-- [Optimization session](http://julialang.org/blog/2014/08/juliacon-opt-session/)
+- [Opening session](https://julialang.org/blog/2014/08/juliacon-opening-session)
+- [Optimization session](https://julialang.org/blog/2014/08/juliacon-opt-session)
 
 The Julia community participated in [Google Summer of Code 2014](http://julialang.org/gsoc/2014/). Wrap-up blog posts will be coming soon from the participants:
 
 - [Simon Danisch](https://github.com/SimonDanisch) ([3D visualization](https://randomphantasies.wordpress.com/))
-- [Shashi Gowda](https://github.com/shashi) ([Interactive Widgets for IJulia](https://github.com/shashi/Interact.jl) and [React.jl](http://shashi.github.io/React.jl))
-- [Mike Innes](https://github.com/one-more-minute) ([Julia + LightTable](https://github.com/one-more-minute/Juno-LT))
+- [Shashi Gowda](https://github.com/shashi) ([Interactive Widgets for IJulia](https://github.com/shashi/Interact.jl) and [React.jl](https://juliagizmos.github.io/Reactive.jl/))
+- [Mike Innes](https://github.com/MikeInnes) ([Julia + LightTable](https://github.com/JuliaIDE/Juno-LT))
 
 **Topical highlights**