Update more links to HTTPS

For most of these links with redirects the redirect only works for HTTP
but not for HTTPS; however the redirect destination does support HTTPS.

Author: Marcono1234

_events/2015-10-24-lambda-world.md

@@ -6,5 +6,5 @@ location: Cádiz, Spain
 description: The largest Functional programming event in the country, carefully crafted for you by 47 Degrees and the Scala and Java communities of Spain. Located in Cádiz, one of the most beautiful cities in Spain. Workshops, hands-on experience, hacking, and debugging. Learn to tame your favorite functional languages.
 start: 24 October 2015
 end: 24 October 2015
-link-out: http://lambda.world/
+link-out: https://www.lambda.world/
 ---

_events/2017-10-26-lambda-world.md

@@ -6,5 +6,5 @@ location: Cádiz, Spain
 description: Lambda World is the largest functional programming event in Spain and orients around various FP languages such as Scala, Kotlin, Java, Haskell, Elm, Clojure, and Javascript
 start: 26 October 2017
 end: 27 October 2017
-link-out: http://lambda.world/
+link-out: https://www.lambda.world/
 ---

_events/2018-09-17-lambda-world.md

@@ -6,5 +6,5 @@ location: Seattle, WA, USA
 description: A Functional Programming event, carefully crafted for you by 47 Degrees with support from local Functional Programming communities
 start: 17 September 2018
 end: 18 September 2018
-link-out: http://lambda.world/
+link-out: https://www.lambda.world/
 ---

_events/2018-10-25-lambda-world.md

@@ -6,5 +6,5 @@ location: Cádiz, Spain
 description: The largest Functional programming event in the country, carefully crafted for you by 47 Degrees and the Scala and Java communities of Spain
 start: 25 October 2018
 end: 26 October 2018
-link-out: http://lambda.world/
+link-out: https://www.lambda.world/
 ---

_events/2019-10-17-lambda-world.md

@@ -6,5 +6,5 @@ location: Cádiz, Spain
 description: One of the largest Functional programming events in Europe
 start: 17 October 2019
 end: 18 October 2019
-link-out: http://lambda.world/
+link-out: https://www.lambda.world/
 ---

_posts/2013-03-20-gsoc13.md

@@ -66,7 +66,7 @@ Currently, the Scala Parallel Collections incur some abstraction  penalties, tha
 
 ## Slick
 
-<http://slick.lightbend.com>
+<https://scala-slick.org/>
 
 ### Schema manipulations for Slick
 

_posts/2014-03-06-release-notes-2.11.0-RC1.md

@@ -102,7 +102,7 @@ Finally, some notable improvements and bug fixes:
 To catch future changes like this early, you can run the compiler under -Xfuture, which makes it behave like the next major version, where possible, to alert you to upcoming breaking changes.
 
 ### Deprecations
-Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](http://java.dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
+Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](https://dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
 
 The following language "warts" have been deprecated:
 

_posts/2014-03-20-release-notes-2.11.0-RC3.md

@@ -111,7 +111,7 @@ Finally, some notable improvements and bug fixes:
 To catch future changes like this early, you can run the compiler under -Xfuture, which makes it behave like the next major version, where possible, to alert you to upcoming breaking changes.
 
 ### Deprecations
-Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](http://java.dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
+Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](https://dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
 
 The following language "warts" have been deprecated:
 

_posts/2014-04-08-release-notes-2.11.0-RC4.md

@@ -115,7 +115,7 @@ Finally, some notable improvements and bug fixes:
 To catch future changes like this early, you can run the compiler under -Xfuture, which makes it behave like the next major version, where possible, to alert you to upcoming breaking changes.
 
 ### Deprecations
-Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](http://java.dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
+Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](https://dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
 
 The following language "warts" have been deprecated:
 

_posts/2014-04-21-release-notes-2.11.0.md

@@ -176,7 +176,7 @@ Finally, some notable improvements and bug fixes:
 To catch future changes like this early, you can run the compiler under -Xfuture, which makes it behave like the next major version, where possible, to alert you to upcoming breaking changes.
 
 ### Deprecations
-Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](http://java.dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
+Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](https://dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
 
 The following language "warts" have been deprecated:
 

_posts/2014-05-21-release-notes-2.11.1.md

@@ -201,7 +201,7 @@ Finally, some notable improvements and bug fixes:
 To catch future changes like this early, you can run the compiler under -Xfuture, which makes it behave like the next major version, where possible, to alert you to upcoming breaking changes.
 
 ### Deprecations
-Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](http://java.dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
+Deprecation is essential to two of the 2.11.x series' three themes ([faster/smaller/stabler](https://dzone.com/articles/state-scala-2013)). They make the language and the libraries smaller, and thus easier to use and maintain, which ultimately improves stability. We are very proud of Scala's first decade, which brought us to where we are, and we are actively working on minimizing the downsides of this legacy, as exemplified by 2.11.x's focus on deprecation, modularization and infrastructure work.
 
 The following language "warts" have been deprecated:
 

_posts/2016-05-06-multiversal-equality.md

@@ -14,7 +14,7 @@ Proposal](https://github.com/lampepfl/dotty/issues/1247) which I summarize in th
 
 Scala prides itself of its strong static type system. Its type discipline is particularly useful when it comes to refactoring. Indeed, it's possible to write programs in such a way that refactoring problems show up with very high probability as type errors. This is essential for being able to refactor with the confidence that nothing will break. And the ability to do such refactorings is in turn very important for keeping code bases from rotting.
 
-Of course, getting such a robust code base requires the cooperation of the developers. They should avoid type `Any`, casts, [stringly typed](http://c2.com/cgi/wiki?StringlyTyped) logic, and more generally any operation over loose types that do not capture the important properties of a value. Unfortunately, there is one area in Scala where such loose types are very hard to avoid: That's equality. Comparisons with `==` and `!=` are _universal_. They compare any two values, no matter what their types are. This causes real problems for writing code and more problems for refactoring it.
+Of course, getting such a robust code base requires the cooperation of the developers. They should avoid type `Any`, casts, [stringly typed](https://wiki.c2.com/?StringlyTyped) logic, and more generally any operation over loose types that do not capture the important properties of a value. Unfortunately, there is one area in Scala where such loose types are very hard to avoid: That's equality. Comparisons with `==` and `!=` are _universal_. They compare any two values, no matter what their types are. This causes real problems for writing code and more problems for refactoring it.
 
 For instance, one might want to introduce a proxy for some data structure so that instead of accessing the data structure directly one goes through the proxy. The proxy and the underlying data would have different types. Normally this should be an easy refactoring. If one passes by accident a proxy for the underlying type or _vice versa_ the type checker will flag the error. However, if one accidentally compares a proxy with the underlying type using `==` or a pattern match, the program is still valid, but will just always say `false`. This is a real worry in practice. I recently abandoned a desirable extensive refactoring because I feared that it would be too hard to track down such errors.
 

_posts/2018-02-13-key-transition.md

@@ -10,7 +10,7 @@ Hash: SHA256
 
 From today, 2018-02-13, we will sign Scala release artifacts with a [new 4096-bit key](http://pgp.mit.edu/pks/lookup?op=vindex&search=0xA9052B1B6D92E560) with fingerprint `3D3A 4396 458F D629 DEAE 0F88 E9DF 618B B41F 2BCE`.
 
-Our old 2048-bit key [B41F2BCE](http://pgp.mit.edu/pks/lookup?op=vindex&search=0xE9DF618BB41F2BCE), originally created on 2013-04-30, will no longer be used.
+Our old 2048-bit key [B41F2BCE](https://pgp.mit.edu/pks/lookup?op=vindex&search=0xE9DF618BB41F2BCE), originally created on 2013-04-30, will no longer be used.
 
 The team member responsible for a new Scala release will continue to use their personal key to sign the git tag from which the release is built.
 

gsoc/2014.md

@@ -446,7 +446,7 @@ should introduce themselves on the [group's mailing list][br2].
 [br1]: https://www.github.com/scalanlp/breeze
 [br2]: https://groups.google.com/forum/#!forum/scala-breeze
 [br3]: https://www.numpy.org/
-[br4]: http://wiki.scipy.org/Tentative_NumPy_Tutorial#head-6a1bc005bd80e1b19f812e1e64e0d25d50f99fe2
+[br4]: https://scipy.github.io/old-wiki/pages/Tentative_NumPy_Tutorial#The_Basics
 [br5]: https://github.com/milessabin/shapeless
 [br6]: https://github.com/non/spire
 [br7]: https://github.com/twitter/algebird

gsoc/2015.md

@@ -59,7 +59,7 @@ More info at [email protected]
 
 ### The New Face of Slick
 
-[Slick](http://slick.lightbend.com/) is a modern database query and access library for Scala. It allows you to work with stored data almost as if you were using Scala collections while at the same time giving you full control over when a database access happens and which data is transferred. You can write your database queries in Scala instead of SQL, thus profiting from the static checking, compile-time safety, and compositionality of Scala.
+[Slick](https://scala-slick.org/) is a modern database query and access library for Scala. It allows you to work with stored data almost as if you were using Scala collections while at the same time giving you full control over when a database access happens and which data is transferred. You can write your database queries in Scala instead of SQL, thus profiting from the static checking, compile-time safety, and compositionality of Scala.
 
 Slick's interface, uses the type-based deep embedding that imposes some limitations on the interface:
 * Native language constructs can not be used (e.g., `==` must be replaced with `===`).

gsoc/2016.md

@@ -219,7 +219,7 @@ via higher-order functions -- [parser combinators](https://www.cs.nott.ac.uk/~ps
 
 As a program, parser generator should be programmed easily and work fast.
 Popular parser generators in Scala ([Scala Combinator Parsers](https://github.com/scala/scala-parser-combinators),
-[parboiled2](http://parboiled2.org), [FastParse](https://github.com/lihaoyi/fastparse ),
+[parboiled2](https://github.com/sirthias/parboiled2), [FastParse](https://github.com/lihaoyi/fastparse),
 [PapaCarlo](https://lakhin.com/projects/papa-carlo/), etc.) can be much faster
 or have complications in development.
 

gsoc/2017.md

@@ -103,7 +103,7 @@ debugging support in the ENSIME text editors (Emacs, Vim, Atom,
 VSCode, Sublime) as well as to add features such as expression
 evaluation and time travel into the debugging library.
 
-- http://ensime.org/
+- https://ensime.github.io/
 - https://scala-debugger.org/
 - https://scalacamp.pl/data/async-debugger-slides/index.html#/