Merge pull request #691 from JuliaLang/tl-linkfix-1

Dead link fixes (1)

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

@@ -8,7 +8,7 @@
 <a href="https://github.com/JeffBezanson/">Jeff Bezanson</a>
 <a href="https://karpinski.org/">Stefan Karpinski</a>
 <a href="https://github.com/ViralBShah/">Viral B. Shah</a>
-<a href="https://www-math.mit.edu/~edelman/">Alan Edelman</a>
+<a href="https://math.mit.edu/~edelman/">Alan Edelman</a>
 ~~~
 
 
@@ -49,19 +49,19 @@
 trackbacks:
 - [Reddit](https://www.reddit.com/r/programming/comments/pv3k9/why_we_created_julia_a_new_programming_language/)
 - [Hacker News](https://news.ycombinator.com/item?id=3606380)
-- [Lambda-the-Ultimate](https://lambda-the-ultimate.org/node/4452)
+- [Lambda-the-Ultimate](http://lambda-the-ultimate.org/node/4452)
 - [Phoronix](https://www.phoronix.com/scan.php?page=news_item&px=MTA2ODg)
 - [The Endeavor (John D. Cook)](https://www.johndcook.com/blog/2012/02/22/julia-random-number-generation/)
-- [Walking Randomly](https://www.walkingrandomly.com/?p=87)
-- [Miguel Bazdresch](https://2pif.info/op/julia.html)
+- [Walking Randomly](http://www.walkingrandomly.com/?p=87)
+- [Miguel Bazdresch](http://2pif.info/op/julia.html)
 - [Douglas Bates](https://dmbates.blogspot.in/2012/03/julia-version-of-multinomial-sampler_12.html)
-- [Vince Buffalo](https://vincebuffalo.org/2012/03/07/thoughts-on-julia.html)
+- [Vince Buffalo](https://vincebuffalo.com/blog/2012/03/07/thoughts-on-julia-and-r.html)
 - [John Myles White](https://www.johnmyleswhite.com/notebook/2012/03/31/julia-i-love-you/)
 - [Shane Conway](https://www.statalgo.com/2012/03/24/statistics-with-julia/)
-- [Tim Salimans](https://timsalimans.com/gibbs-sampling-with-julia/)
+- [Tim Salimans](http://timsalimans.com/gibbs-sampling-with-julia/)
 - [Twitter trackbacks](https://topsy.com/julialang.org/)
 - [Russian translation](https://habrahabr.ru/blogs/programming/138577/)
 - [Linux.org.ru blog post (Russian)](https://www.linux.org.ru/news/opensource/7440863)
 - [Simplified Chinese translation](https://sd.csdn.net/a/20120223/312315.html)
-- [Traditional Chinese translation](https://www.hellogcc.org/archives/666)
+- [Traditional Chinese translation](http://www.hellogcc.org/?p=20)
 - [Linuxfr.org blog post (French)](https://linuxfr.org/news/version-1-0-de-julia)

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

@@ -8,7 +8,7 @@
 <a href="https://github.com/JeffBezanson/">Jeff Bezanson</a>
 <a href="https://karpinski.org/">Stefan Karpinski</a>
 <a href="https://github.com/ViralBShah/">Viral B. Shah</a>
-<a href="https://www-math.mit.edu/~edelman/">Alan Edelman</a>
+<a href="https://math.mit.edu/~edelman/">Alan Edelman</a>
 ~~~
 
 In short, because we are greedy.
@@ -63,19 +63,19 @@ So, if you are also a greedy, unreasonable, demanding programmer, we want you to
 trackbacks:
 - [Reddit](https://www.reddit.com/r/programming/comments/pv3k9/why_we_created_julia_a_new_programming_language/)
 - [Hacker News](https://news.ycombinator.com/item?id=3606380)
-- [Lambda-the-Ultimate](https://lambda-the-ultimate.org/node/4452)
+- [Lambda-the-Ultimate](http://lambda-the-ultimate.org/node/4452)
 - [Phoronix](https://www.phoronix.com/scan.php?page=news_item&px=MTA2ODg)
 - [The Endeavor (John D. Cook)](https://www.johndcook.com/blog/2012/02/22/julia-random-number-generation/)
-- [Walking Randomly](https://www.walkingrandomly.com/?p=87)
-- [Miguel Bazdresch](https://2pif.info/op/julia.html)
+- [Walking Randomly](http://www.walkingrandomly.com/?p=87)
+- [Miguel Bazdresch](http://2pif.info/op/julia.html)
 - [Douglas Bates](https://dmbates.blogspot.in/2012/03/julia-version-of-multinomial-sampler_12.html)
-- [Vince Buffalo](https://vincebuffalo.org/2012/03/07/thoughts-on-julia.html)
+- [Vince Buffalo](https://vincebuffalo.com/blog/2012/03/07/thoughts-on-julia-and-r.html)
 - [John Myles White](https://www.johnmyleswhite.com/notebook/2012/03/31/julia-i-love-you/)
 - [Shane Conway](https://www.statalgo.com/2012/03/24/statistics-with-julia/)
-- [Tim Salimans](https://timsalimans.com/gibbs-sampling-with-julia/)
+- [Tim Salimans](http://timsalimans.com/gibbs-sampling-with-julia/)
 - [Twitter trackbacks](https://topsy.com/julialang.org/)
 - [Russian translation](https://habrahabr.ru/blogs/programming/138577/)
 - [Linux.org.ru blog post (Russian)](https://www.linux.org.ru/news/opensource/7440863)
 - [Simplified Chinese translation](https://sd.csdn.net/a/20120223/312315.html)
-- [Traditional Chinese translation](https://www.hellogcc.org/archives/666)
+- [Traditional Chinese translation](http://www.hellogcc.org/?p=20)
 - [Linuxfr.org blog post (French)](https://linuxfr.org/news/version-1-0-de-julia)

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

@@ -165,7 +165,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/2012/04/nyc-open-stats-meetup-announcement.md

@@ -5,7 +5,7 @@
 @def authors = """<a href="https://karpinski.org/">Stefan Karpinski</a>"""  
 
 
-I'll be giving a talk on Julia at the [New York Open Statistical Programming Meetup on May 1st](https://www.meetup.com/nyhackr/events/60839932/). After my presentation, [John Myles White](https://www.johnmyleswhite.com/) and [Shane Conway](https://www.statalgo.com/) are going to give followup demos of statistical applications using Julia. Then we're going to hang out and grab drinks nearby. Thanks to [Harlan Harris](https://www.harlan.harris.name/) and [Drew Conway](https://www.drewconway.com/) for setting the whole thing up!
+I'll be giving a talk on Julia at the [New York Open Statistical Programming Meetup on May 1st](https://www.meetup.com/nyhackr/events/60839932/). After my presentation, [John Myles White](https://www.johnmyleswhite.com/) and [Shane Conway](https://www.statalgo.com/) are going to give followup demos of statistical applications using Julia. Then we're going to hang out and grab drinks nearby. Thanks to [Harlan Harris](http://www.harlan.harris.name/) and [Drew Conway](http://www.drewconway.com/) for setting the whole thing up!
 
 **Announcement:**
 

blog/2012/08/design-and-implementation-of-julia.md

@@ -8,6 +8,6 @@
 ~~~<a href="https://github.com/JeffBezanson/">Jeff Bezanson</a>
 <a href="https://karpinski.org/">Stefan Karpinski</a>
 <a href="https://github.com/ViralBShah/">Viral B. Shah</a>
-<a href="https://www-math.mit.edu/~edelman/">Alan Edelman</a>~~~
+<a href="https://math.mit.edu/~edelman/">Alan Edelman</a>~~~
 
 We describe the design and implementation of Julia in our first paper - [Julia: A Fast Dynamic Language for Technical Computing](/assets/blog/julia-dynamic-2012-tr.pdf). This is work in progress and comments are appreciated.

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

@@ -33,25 +33,25 @@ This session demonstrates Julia's statistics capabilities, which are provided by
 
 ## Fast Fourier Transforms
 
-Julia provides a built-in interface to the [FFTW](https://www.fftw.org/) library. This session demonstrates the Julia's [signal processing](https://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](https://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.
 
 ~~~<iframe width="560" height="315" src="https://www.youtube.com/embed/1iBLaHGL1AM" frameborder="0" allowfullscreen></iframe>~~~
 
 ## Optimization ([slides](https://github.com/JuliaLang/julia-tutorial/raw/master/NumericalOptimization/presentation.pdf))
 
-This session focuses largely on using Julia for solving linear programming problems. The algebraic modeling language discussed was later released as [JuMP](https://github.com/IainNZ/JuMP.jl). Benchmarks are shown evaluating the performance of Julia for implementing low-level optimization code. Optimization software in Julia has been grouped under the [JuliaOpt](https://juliaopt.org/) project.
+This session focuses largely on using Julia for solving linear programming problems. The algebraic modeling language discussed was later released as [JuMP](https://github.com/IainNZ/JuMP.jl). Benchmarks are shown evaluating the performance of Julia for implementing low-level optimization code. Optimization software in Julia has been grouped under the [JuliaOpt](http://juliaopt.org/) project.
 
 ~~~<iframe width="560" height="315" src="https://www.youtube.com/embed/O1icUP6sajU" frameborder="0" allowfullscreen></iframe>~~~
 
 ## 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](https://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](https://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/#Parallel-Computing-1) 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/2013/04/distributed-numerical-optimization.md

@@ -2,7 +2,7 @@
 @def rss = """ Distributed Numerical Optimization | This post walks through the parallel computing functionality of Julia... """
 @def published = "5 April 2013"
 @def title = "Distributed Numerical Optimization"
-@def authors = """<a href="https://www.mit.edu/~mlubin/">Miles Lubin</a>"""  
+@def authors = """<a href="https://mlubin.github.io/">Miles Lubin</a>"""  
 @def hascode = true
 @def hasmath = true
 
@@ -39,7 +39,7 @@ If it is costly to evaluate $ f_i(x) $, then the algorithm is naturally
 parallelizable at step 2. The minimization in step 3 can be computed by solving
 a linear optimization problem, which is usually very fast. (Let me point out
 here that Julia has interfaces to linear programming and other
-optimization solvers under [JuliaOpt](https://juliaopt.org/).
+optimization solvers under [JuliaOpt](http://www.juliaopt.org/).
 
 Abstracting the math, we can write the algorithm using the following Julia code.
 
@@ -96,7 +96,7 @@ functionality.  This model of parallelism is very different from the typical
 SIMD style of MPI. Both approaches are useful in different contexts, and I
 expect an MPI wrapper for Julia will appear in the future (see also [here](https://github.com/lcw/julia-mpi)).
 
-Reading the [manual](https://docs.julialang.org/en/release-0.1/manual/parallel-computing/) on parallel computing is highly recommended, and I won't try to reproduce it in
+Reading the [manual](https://docs.julialang.org/en/v1/manual/parallel-computing/#Parallel-Computing-1) 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.
 
 The implementation of `pmap` in Julia is

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

@@ -55,7 +55,7 @@ The Julia community participated in Google Summer of Code 2014. Wrap-up blog pos
 
 [JuliaStats](https://juliastats.github.io/) - statistical and machine learning community.
 
-[JuliaOpt](https://www.juliaopt.org/) - optimization community.
+[JuliaOpt](http://www.juliaopt.org/) - optimization community.
 
 [IJulia](https://github.com/JuliaLang/IJulia.jl) - notebook interface built on IPython.
 

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](https://www.juliaopt.org/) - Optimization Packages for Julia
+### [Iain Dunning](https://iaindunning.com/) / [Joey Huchette](https://www.mit.edu/~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.
 

blog/2015/05/juliacon-preview.md

@@ -12,7 +12,7 @@ The [first ever JuliaCon](https://juliacon.org/2014/) was held in Chicago last y
 
 * On Wednesday 24th there will an introduction to Julia workshop run by [David P. Sanders (@dpsanders)](https://github.com/dpsanders) as well as a Julia **hackathon** - a great chance to get some help for your new Julia projects, or to begin contributing to Julia or its many packages.
 * On Thursday 25th and Friday 26th we will be having speakers talking about a range of topics - we were fortunate to have so many fantastic submissions that we had to open up a second track of talks. The near-final [schedule is on the main page](https://juliacon.org). We'll be alternating between ~40 minute long "regular" talks, and ~10 minute long "lightning" talks across all the sessions.
-* On Saturday 27th we will finish with a series of **workshops** on a range of topics: data wrangling and visualization, [optimization](https://juliaopt.org), high-performance computing and more. These workshops run from 1.5 to 3 hours and will be a great way to rapidly boost your Julia skills.
+* On Saturday 27th we will finish with a series of **workshops** on a range of topics: data wrangling and visualization, [optimization](http://www.juliaopt.org/), high-performance computing and more. These workshops run from 1.5 to 3 hours and will be a great way to rapidly boost your Julia skills.
 
 ### Thursday's Talks
 
@@ -33,14 +33,14 @@ Whatever you get up to after the talks end on Thursday, make sure you are up in
 ### Friday's talks
 
 ~~~
-<img src="https://www.juliaopt.org/images/juliaopt.svg" width="20%"><img src="/assets/images/el.png" width="20%">
+<img src="http://www.juliaopt.org/images/juliaopt.svg" width="20%"><img src="/assets/images/el.png" width="20%">
 ~~~
 
 \\\\
 
 If you are interested in learning **how Julia works** from the people who work on it every day, then Friday morning's session is for you. The morning will kick off with newly-minted-PhD and Julia co-founder [Jeff Bezanson (@JeffBezanson)](https://github.com/JeffBezanson), who is still recovering from his defense and will be updating us on the title of his talk soon. We'll be learning more about different stages of the **compilation process** from contributors [Jake Bolewski (@jakebolewski)](https://github.com/jakebolewski) and [Jacob Quinn (@quinnj)](https://github.com/quinnj), and we'll be covering a miscellany of other cutting-edge topics for Julia like tuning LLVM, debugging, and interfaces.
 
-In the afternoon we'll have four sessions split across two rooms. In the second **scientific applications** session we'll be learning more about how Julia is being used to **prevent airborne collisions** from Lincoln Lab's Robert Moss, and [Iain Dunning (@IainNZ)](https://github.com/IainNZ) will give a sequel to last years [JuliaOpt](https://juliaopt.org) talk to update us on how Julia is becoming the language of choice for many for **optimization**. We'll also hear how Julia is enabling rapid development of advanced algorithms for simulating **quantum systems**, evolving graphs, and analyzing **seismic waves**.
+In the afternoon we'll have four sessions split across two rooms. In the second **scientific applications** session we'll be learning more about how Julia is being used to **prevent airborne collisions** from Lincoln Lab's Robert Moss, and [Iain Dunning (@IainNZ)](https://github.com/IainNZ) will give a sequel to last years [JuliaOpt](http://www.juliaopt.org/) talk to update us on how Julia is becoming the language of choice for many for **optimization**. We'll also hear how Julia is enabling rapid development of advanced algorithms for simulating **quantum systems**, evolving graphs, and analyzing **seismic waves**.
 
 The **numerical computing** track kicks of with Stanford's Prof. [Jack Poulson (@poulson)](https://github.com/poulson), creator of the [Elemental](https://github.com/elemental/Elemental) library for **distributed-memory linear algebra**. Right after, the linear algebra wizard [Zhang Xianyi (@xianyi)](https://github.com/xianyi) will give a talk about [OpenBLAS](https://github.com/xianyi/OpenBLAS), the high-performance linear algebra library Julia ships with. After a break, we'll hear Viral's thoughts on how **sparse matrices** currently and should work in Julia, before finishing off with lightning talks about **validated numerics** and **Taylor series**.
 

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

@@ -82,7 +82,7 @@ the #MonthOfJulia series exploring the core language and a number of packages.
 
 [JuliaStats](https://juliastats.github.io/) - statistical and machine learning community.
 
-[JuliaOpt](https://www.juliaopt.org/) - optimization community.
+[JuliaOpt](http://www.juliaopt.org/) - optimization community.
 
 [JuliaQuantum](https://juliaquantum.github.io/) - Julia libraries for quantum-science and technology.