Merge pull request #692 from JuliaLang/tl-linkfix-2

more link fixes

Author: tlienart

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

@@ -212,7 +212,7 @@ Now for the fun part. The complete cutting-plane algorithm (along with
 additional variants) is implemented in [JuliaBenders](https://github.com/mlubin/JuliaBenders). The code is
 specialized for [stochastic
 programming](https://en.wikipedia.org/wiki/Stochastic_programming) where the cutting-plane algorithm is known as the [L-shaped
-method](https://www.springerreference.com/docs/html/chapterdbid/72429.html) or Benders decomposition and is used to decompose the solution of
+method](http://www.springerreference.com/docs/html/chapterdbid/72429.html) or Benders decomposition and is used to decompose the solution of
 large linear optimization problems. Here, `solvesubproblem` entails solving a
 relatively small linear optimization problem. Test instances are taken from [the
 previously mentioned paper](https://dx.doi.org/10.1023/A:1021858008222).

blog/2013/05/callback.md

@@ -7,10 +7,10 @@
 
 
 One of the great strengths of Julia is that it is so easy to [call C
-code](https://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](https://www.gnu.org/software/gsl/) to compute a special function
-like a [Debye integral](https://linux.math.tifr.res.in/manuals/html/gsl-ref-html/gsl-ref_7.html), it is as easy as:
+like a [Debye integral](http://linux.math.tifr.res.in/manuals/html/gsl-ref-html/gsl-ref_7.html), it is as easy as:
 
 ```
 debye_1(x) = ccall((:gsl_sf_debye_1,:libgsl), Cdouble, (Cdouble,), x)
@@ -229,7 +229,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_r.3.html):
 
 ```julia
 void qsort_r(void *base, size_t nmemb, size_t size, void *thunk,
@@ -290,7 +290,7 @@ The example above has one major problem that has nothing to do with
 Julia: the `qsort_r` function is not portable.  The above example
 won't work on Windows, since the Windows C library doesn't define
 `qsort_r` (instead, it has a function called
-[qsort_s](https://msdn.microsoft.com/en-us/library/4xc60xas%28VS.80%29.aspx),
+[qsort_s](https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/qsort-s?view=vs-2019),
 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
@@ -529,7 +529,7 @@ about 10 digits.
 
 At this point, I will shamelessly plug my own [NLopt
 package](https://github.com/stevengj/NLopt.jl) for Julia, which wraps
-around my free/open-source [NLopt](https://ab-initio.mit.edu/nlopt) library
+around my free/open-source [NLopt](https://nlopt.readthedocs.io/en/latest/) library
 to provide many more optimization algorithms than GSL, with perhaps a nicer
 interface.   However, the techniques used to pass callback functions to
 NLopt are actually quite similar to those used for GSL.

blog/2013/05/graphical-user-interfaces-part1.md

@@ -2,7 +2,7 @@
 @def rss = """ Building GUIs with Julia, Tk, and Cairo, Part I | This is the first of two blog posts designed to walk users through the process of creating GUIs in Julia.... """
 @def published = "23 May 2013"
 @def title = "Building GUIs with Julia, Tk, and Cairo, Part I"
-@def authors = """ <a href="https://holylab.wustl.edu">Timothy E. Holy</a>"""  
+@def authors = """ <a href="http://holylab.wustl.edu">Timothy E. Holy</a>"""  
 @def hascode = true
 
 This is the first of two blog posts designed to walk users through the process of creating GUIs in Julia.

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

@@ -2,7 +2,7 @@
 @def rss = """ Building GUIs with Julia, Tk, and Cairo, Part II | In this installment, we'll cover both low-level graphics (using Cairo) and plotting graphs inside GUIs (using Winston).... """
 @def published = "23 May 2013"
 @def title = "Building GUIs with Julia, Tk, and Cairo, Part II"
-@def authors = """<a href="https://holylab.wustl.edu">Timothy E. Holy</a>"""  
+@def authors = """<a href="http://holylab.wustl.edu">Timothy E. Holy</a>"""  
 @def hascode = true
 
 
@@ -272,7 +272,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 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/2014/08/julia-0.3-release.md

@@ -38,16 +38,16 @@ Happy coding.
 
 [JuliaBloggers](https://www.juliabloggers.com/) and the [searchable package listing](https://pkg.julialang.org/) were recently introduced.
 
-The first ever [JuliaCon](https://www.juliacon.org) was held in Chicago in June, 2014. Several session recordings are available, and the others will be released soon:
+The first ever [JuliaCon](https://juliacon.org) was held in Chicago in June, 2014. Several session recordings are available, and the others will be released soon:
 
 - [Opening session](/blog/2014/08/juliacon-opening-session/)
 - [Optimization session](/blog/2014/08/juliacon-opt-session/)
 
 The Julia community participated in Google Summer of Code 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](https://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/one-more-minute/Juno-LT))
 
 **Topical highlights**
 
@@ -63,4 +63,4 @@ The Julia community participated in Google Summer of Code 2014. Wrap-up blog pos
 
 [Gadfly](https://gadflyjl.org/) - Grammar of Graphics-inspired statistical plotting.
 
-[Winston](https://github.com/nolta/Winston.jl) - 2D plotting.
+[Winston](https://github.com/JuliaGraphics/Winston.jl) - 2D plotting.

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

@@ -8,7 +8,7 @@
 
 ## Optimization Session
 
-### [Iain Dunning](https://iaindunning.com/) / [Joey Huchette](https://www.mit.edu/~huchette/) — [JuliaOpt](http://www.juliaopt.org/) - Optimization Packages for Julia
+### [Iain Dunning](https://iaindunning.com/) / [Joey Huchette](https://joehuchette.github.io/) — [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.
 
@@ -26,7 +26,7 @@ Madeleine Udell is a PhD candidate in Computational & Mathematical Engineering a
 
 - **Video:** [https://youtu.be/SoI0lEaUvTs](https://youtu.be/SoI0lEaUvTs)
 - **Slides:** [https://goo.gl/Nfy14D](https://goo.gl/Nfy14D)
-- **Website:** [https://web.stanford.edu/~udell/](https://web.stanford.edu/~udell/)
+- **Website:** [https://people.orie.cornell.edu/mru8/](https://people.orie.cornell.edu/mru8/)
 
 ~~~
 <div style="text-align: center"><iframe width="560" height="315" src="https://www.youtube.com/embed/SoI0lEaUvTs?list=PLP8iPy9hna6TSRouJfvobfxkZFYiPSvPd" frameborder="0" allowfullscreen></iframe></div>

blog/2015/10/julia-0.4-release.md

@@ -69,7 +69,7 @@ Nightly builds will use the versioning scheme 0.5.0-dev.
 The Julia ecosystem continues to grow, and there are now
 [over 700](https://pkg.julialang.org/pulse.html) registered packages! (highlights below)
 
-The second [JuliaCon](https://www.juliacon.org) was held in Cambridge (USA) in June, 2015.
+The second [JuliaCon](https://juliacon.org) was held in Cambridge (USA) in June, 2015.
 Over 60 talks were recorded and
 [are available for viewing](https://www.youtube.com/playlist?list=PLP8iPy9hna6Sdx4soiGrSefrmOPdUWixM).
 
@@ -94,6 +94,6 @@ the #MonthOfJulia series exploring the core language and a number of packages.
 
 [Gadfly](https://gadflyjl.org/) - Grammar of Graphics-inspired statistical plotting.
 
-[Winston](https://github.com/nolta/Winston.jl) - 2D plotting.
+[Winston](https://github.com/JuliaGraphics/Winston.jl) - 2D plotting.
 
 [JunoLab](https://junolab.org/) - LightTable-based interactive environment.

blog/2016/02/iteration.md

@@ -2,7 +2,7 @@
 @def rss = """ Multidimensional algorithms and iteration | Julia makes it easy to write elegant and... """
 @def published = "1 February 2016"
 @def title = "Multidimensional algorithms and iteration"
-@def authors = """ <a href="https://holylab.wustl.edu">Tim Holy</a>"""  
+@def authors = """ <a href="http://holylab.wustl.edu">Tim Holy</a>"""  
 @def hascode = true
 
 **Note: updated December 2018 for Julia 1.1**

blog/2016/03/arrays-iteration.md

@@ -2,7 +2,7 @@
 @def rss = """ Generalizing AbstractArrays: opportunities and challenges | Somewhat unusually, this blog post is future-looking: it mostly... """
 @def published = "27 March 2016"
 @def title = "Generalizing AbstractArrays: opportunities and challenges"
-@def authors = """ <a href="https://holylab.wustl.edu">Tim Holy</a>"""  
+@def authors = """ <a href="http://holylab.wustl.edu">Tim Holy</a>"""  
 @def hascode = true
 
 

blog/2016/04/biojulia2016.md

@@ -46,7 +46,7 @@ Many databases distribute their data in some standardized file formats. As for g
 <iframe width="560" height="315" src="https://www.youtube.com/embed/sQvNNj3MthQ" frameborder="0" allowfullscreen></iframe>
 ~~~
 
-Sometimes you may need only a part of data provided by a database. In such a case, web-based APIs are handy to fetch necessary data on demand. [BioMart Central Portal](https://www.biomart.org/) offers a unified access point to a range of biological databases that is programmatically accessible via REST and SOAP APIs. Julian wrapper to BioMart will make it much easier to access data by automatically converting response to Julia objects. In the R language, the [biomaRt](https://bioconductor.org/packages/release/bioc/html/biomaRt.html) package is one of the most downloaded packages in Bioconductor packages: <https://www.bioconductor.org/packages/stats/>.
+Sometimes you may need only a part of data provided by a database. In such a case, web-based APIs are handy to fetch necessary data on demand. [BioMart Central Portal](http://www.biomart.org/) offers a unified access point to a range of biological databases that is programmatically accessible via REST and SOAP APIs. Julian wrapper to BioMart will make it much easier to access data by automatically converting response to Julia objects. In the R language, the [biomaRt](https://bioconductor.org/packages/release/bioc/html/biomaRt.html) package is one of the most downloaded packages in Bioconductor packages: <https://www.bioconductor.org/packages/stats/>.
 
 
 ## Try BioJulia!

blog/2017/01/moredots.md

@@ -109,7 +109,7 @@ One possible solution is to vectorize *every function automatically*.   The
 language [Chapel](https://en.wikipedia.org/wiki/Chapel_%28programming_language%29)
 does this: every function `f(x...)` implicitly
 defines a function `f(x::Array...)` that evaluates `map(f, x...)`
-[(Chamberlain et al, 2011)](https://pgas11.rice.edu/papers/ChamberlainEtAl-Chapel-Iterators-PGAS11.pdf).
+[(Chamberlain et al, 2011)](http://pgas11.rice.edu/papers/ChamberlainEtAl-Chapel-Iterators-PGAS11.pdf).
 This could be implemented in Julia as well via
 function-call overloading [(Bezanson, 2015: chapter 4)](https://github.com/JeffBezanson/phdthesis/blob/master/main.pdf),
 but we chose to go in a different direction.
@@ -269,7 +269,7 @@ One approach that may occur to you, and which has been implemented in a
 variety of languages (e.g. [Kennedy & McKinley, 1993](https://dl.acm.org/citation.cfm?id=665526);
 [Lewis et al., 1998](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.46.6627);
 [Chakravarty & Keller, 2001](https://dl.acm.org/citation.cfm?id=507661);
-[Manjikian & Abdelrahman, 2002](https://ieeexplore.ieee.org.libproxy.mit.edu/document/577265/);
+[Manjikian & Abdelrahman, 2002](http://ieeexplore.ieee.org.libproxy.mit.edu/document/577265/);
 [Sarkar, 2010](https://ieeexplore.ieee.org/document/5389392/);
 [Prasad et al., 2011](https://dl.acm.org/citation.cfm?id=1993517);
 [Wu et al., 2012](https://dl.acm.org/citation.cfm?id=2457490)), is to only
@@ -281,7 +281,7 @@ implemented as libraries (e.g. template libraries in C++:
 languages (DSLs)](https://en.wikipedia.org/wiki/Domain-specific_language)
 as extensions of existing languages; in Python, for example, loop fusion for a small
 set of vector operations and array/scalar types can be found in the
-[Theano](https://deeplearning.net/software/theano/introduction.html),
+[Theano](http://deeplearning.net/software/theano/introduction.html),
 [PyOP2](https://op2.github.io/PyOP2/), and [Numba](https://github.com/numba/numba/pull/1110)
 software. Likewise, in Julia we could
 potentially build the compiler to recognize that it can fuse
@@ -377,7 +377,7 @@ like `x += y` to be equivalent to calls to a special function,
 like `x = plusequals!(x, y)`, that can be defined as an in-place operation, rather
 than `x += y` being a synonym for `x = x + y` as in Julia today.
 ([NumPy does this](https://docs.python.org/3.3/reference/datamodel.html#object.__iadd__).)
-By itself, this can be used to [avoid temporary arrays in some simple cases](https://blog.svenbrauch.de/2016/04/13/processing-scientific-data-in-python-and-numpy-but-doing-it-fast/) by breaking them into a sequence of in-place updates, but
+By itself, this can be used to [avoid temporary arrays in some simple cases](http://blog.svenbrauch.de/2016/04/13/processing-scientific-data-in-python-and-numpy-but-doing-it-fast/) by breaking them into a sequence of in-place updates, but
 it doesn't handle more complex expressions, is limited to a few
 operations like `+`, and doesn't address the cache inefficiency of
 multiple loops.   (In Julia 0.6, you can do `x .+= y` and it is

blog/2017/03/piday.md

@@ -239,7 +239,7 @@ abs(pi - pi_approx3)
 
 ## Finding guaranteed bounds on π
 
-by [David P. Sanders](https://sistemas.fciencias.unam.mx/~dsanders/),  Department of Physics, Faculty of Sciences, National University of Mexico (UNAM)
+by [David P. Sanders](http://sistemas.fciencias.unam.mx/~dsanders/),  Department of Physics, Faculty of Sciences, National University of Mexico (UNAM)
 
 ### Using standard floating-point arithmetic
 

blog/2017/04/offset-arrays.md

@@ -2,7 +2,7 @@
 @def rss = """ Knowing where you are: custom array indices in Julia | Arrays are a crucial component of any programming language,... """
 @def published = "18 April 2017"
 @def title = "Knowing where you are: custom array indices in Julia"
-@def authors = """<a href="https://holylab.wustl.edu">Tim Holy</a>"""  
+@def authors = """<a href="http://holylab.wustl.edu">Tim Holy</a>"""  
 @def hasmath = true
 @def hascode = true
 

blog/2017/08/dsl.md

@@ -347,4 +347,4 @@ For some more in-depth discussion of metaprogramming techniques and macros, see
 - link to [the video](https://www.youtube.com/watch?v=rAxzR7lMGDM)
 - link to the [Jupyter notebooks](https://github.com/dpsanders/intermediate_julia)
 
-**Author**: [David P. Sanders](https://sistemas.fciencias.unam.mx/~dsanders/), Associate Professor, Department of Physics, Faculty of Sciences, National University of Mexico (UNAM).
+**Author**: [David P. Sanders](http://sistemas.fciencias.unam.mx/~dsanders/), Associate Professor, Department of Physics, Faculty of Sciences, National University of Mexico (UNAM).

blog/2017/10/gsoc-NeuralNetDiffEq.md

@@ -12,7 +12,7 @@ The purpose of the project was to provide an additional DE solver using Neural N
 I chose to work on this project as I have interest in mathematics and machine learning and it involved concepts of both the fields. The package uses [DifferentialEquations.jl](https://github.com/JuliaDiffEq/DifferentialEquations.jl) for the solver interface and [KNet.jl](https://github.com/denizyuret/Knet.jl) for NN solver implementation.
 
 ## How to use Neural Network for solving Differential Equations?
-The concept of this solver is based on the UAT (Universal Approximation Theorem) which says that a NN with at least one hidden layer can approximate any continuous function. The neural network is made to minimize a loss function, defined as the difference between the NN's derivative and the derivative of the differential equation, which then results in the convergence of our trial solution towards the actual (analytical) solution of the differential equation. To know more about UAT [click here](https://neuralnetworksanddeeplearning.com/chap4.html).
+The concept of this solver is based on the UAT (Universal Approximation Theorem) which says that a NN with at least one hidden layer can approximate any continuous function. The neural network is made to minimize a loss function, defined as the difference between the NN's derivative and the derivative of the differential equation, which then results in the convergence of our trial solution towards the actual (analytical) solution of the differential equation. To know more about UAT [click here](http://neuralnetworksanddeeplearning.com/chap4.html).
 
 ## Research aspect of the project and the challenge
 The research paper we referred to on the topic is quite old and understanding the examples as well as explanations was quite challenging. Not much research has been done on using NNs for this purpose and thus we were not able to get much help from the research papers related to the topic.