Apply HIGH-priority fixes from REVIEW-20260424b

- ch20: update Scala 2 REPL transcript to Scala 3 format
  (val/def prefixes on output, def signature without parens syntax)
- ch60: replace 4 dead feedproxy.google.com SE Radio links with
  working se-radio.net URLs (eps 12, 19, 29) + add ep 348 (Terrell)
- ch60: update Java 8 java.util.concurrent link to Java 21 API
- ch60: upgrade http Scala docs links to https
- all: bulk upgrade http:// to https:// for wikipedia, scala-lang,
  typelevel, martinfowler, akka, android developer domains
- ch50: fix dead benchmarksgame alioth link to current debian.net URL

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: klaeufer

source/05-overview.rst

@@ -66,7 +66,7 @@ The course begins with context and background (software engineering practices, l
 Bloom's taxonomy
 ~~~~~~~~~~~~~~~~
 
-The letters refer to the successive levels of learning from the cognitive domain of `Bloom's taxonomy <http://en.wikipedia.org/wiki/Bloom's_taxonomy#Cognitive>`_:
+The letters refer to the successive levels of learning from the cognitive domain of `Bloom's taxonomy <https://en.wikipedia.org/wiki/Bloom's_taxonomy#Cognitive>`_:
 
 - K: know/remember the term
 - C: comprehend/understand the concept

source/10-background.rst

@@ -119,7 +119,7 @@ Software design principles and patterns
 
 The software development community has identified various principles intended to guide the design and development process, for example:
 
-- `DRY <http://en.wikipedia.org/wiki/Don%27t_repeat_yourself>`_ (don't repeat yourself)
+- `DRY <https://en.wikipedia.org/wiki/Don%27t_repeat_yourself>`_ (don't repeat yourself)
 - `SoC <https://en.wikipedia.org/wiki/Separation_of_concerns>`_ (separation of concerns)
 - `SOLID <https://en.wikipedia.org/wiki/SOLID_(object-oriented_design)>`_
 

source/20-imperative.rst

@@ -248,19 +248,19 @@ In this section, we discuss the different options for running Scala code, includ
     Type in expressions for evaluation. Or try :help.
 
     scala> 3 + 4
-    res0: Int = 7
+    val res0: Int = 7
 
     scala> def f(x: Int) = x + 2
-    f: (x: Int)Int
+    def f(x: Int): Int
 
     scala> f(3)
-    res1: Int = 5
+    val res1: Int = 5
 
     scala> val z = f(4)
-    z: Int = 6
+    val z: Int = 6
 
     scala> Seq(1, 2, 3).map(f)
-    res2: Seq[Int] = List(3, 4, 5)
+    val res2: Seq[Int] = List(3, 4, 5)
 
 
   This is a very effective, painless way to conduct initial explorations.

source/40-functional.rst

@@ -853,7 +853,7 @@ A closer look at predefined behaviors on lists
 
 In this section, we take a look "under the hood" of some key predefined behaviors on lists.
 
-In terms of performance, we must keep in mind that `lists are head/tail-optimized <http://www.scala-lang.org/api/current/scala/collection/immutable/List.html>`_.
+In terms of performance, we must keep in mind that `lists are head/tail-optimized <https://www.scala-lang.org/api/current/scala/collection/immutable/List.html>`_.
 In other words, these are basically singly-linked lists, so any behaviors where we access the first node of the list are constant-time, while behaviors involving nodes further down in the list are linear-time.
 In practice, acceptable performance usually means linear time for behavior where we process the entire list.
 
@@ -1054,7 +1054,7 @@ On the behavioral side, we recognize the great potential for code reuse resultin
 
 - `Cats library of high-level abstractions <https://typelevel.org/cats>`_
 - `Droste library of recursion schemes <https://github.com/higherkindness/droste>`_
--  Various other `Typelevel.scala projects <http://typelevel.org/projects>`_
+-  Various other `Typelevel.scala projects <https://typelevel.org/projects>`_
 
 For more details on F-algebras and datatype-generic programming, please take a look at these references:
 

source/50-representationinterpretation.rst

@@ -8,7 +8,7 @@ To this end, we need to talk about the toolchain required to do so, as well as t
 Programming language toolchains
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-We will start with an overview of the phases of programming language `compilation <http://en.wikipedia.org/wiki/Compiler>`_/`interpretation <http://en.wikipedia.org/wiki/Interpreter_(computing)>`_ toolchain:
+We will start with an overview of the phases of programming language `compilation <https://en.wikipedia.org/wiki/Compiler>`_/`interpretation <https://en.wikipedia.org/wiki/Interpreter_(computing)>`_ toolchain:
 
 - source code (string stored in file)
 - *lexical analysis*
@@ -91,7 +91,7 @@ Alternative front-end approaches
   - `Getting-started guide <https://github.com/scala/scala-parser-combinators/blob/main/docs/Getting_Started.md>`_
   - `simple expression combinator parser example <https://github.com/lucproglangcourse/expressions-scala/blob/master/src/main/scala/CombinatorParser.scala>`_
 
-- `parsing expression grammars <http://en.wikipedia.org/wiki/Parsing_expression_grammar>`_
+- `parsing expression grammars <https://en.wikipedia.org/wiki/Parsing_expression_grammar>`_
 - `From EBNF to PEG <http://ceur-ws.org/Vol-928/0324.pdf>`_
 - Parboiled 2 PEG library
 
@@ -105,12 +105,12 @@ Programming language semantics
 
 Semantics, a formalization of the *meaning* of programs in a particular language, includes *static* and *dynamic* semantics.
 
-- `static semantics <http://en.wikipedia.org/wiki/Programming_language#Semantics>`_ (compile-time)
+- `static semantics <https://en.wikipedia.org/wiki/Programming_language#Semantics>`_ (compile-time)
 
   - flow analysis
   - typing
 
-- `dynamic semantics <http://en.wikipedia.org/wiki/Semantics_of_programming_languages>`_ (run-time)
+- `dynamic semantics <https://en.wikipedia.org/wiki/Semantics_of_programming_languages>`_ (run-time)
 
   - denotational
   - operational, e.g. our interpreters
@@ -119,7 +119,7 @@ Semantics, a formalization of the *meaning* of programs in a particular language
 The Interpreter pattern is related to the discussion of dynamic semantics.
 
 - http://c2.com/cgi/wiki?InterpreterPattern
-- http://en.wikipedia.org/wiki/Interpreter_pattern
+- https://en.wikipedia.org/wiki/Interpreter_pattern
 
 
 Case study: a simple imperative language
@@ -387,11 +387,11 @@ Type systems are an important aspect of programming languages. We identify the f
 
 Additional information is available here:
 
-- `design space and tradeoffs <http://en.wikipedia.org/wiki/Type_system>`_
-- `representative examples <http://en.wikipedia.org/wiki/Comparison_of_type_systems>`_
+- `design space and tradeoffs <https://en.wikipedia.org/wiki/Type_system>`_
+- `representative examples <https://en.wikipedia.org/wiki/Comparison_of_type_systems>`_
 - `comprehensive list <https://en.wikipedia.org/wiki/Comparison_of_programming_languages_by_type_system>`_
 - `presentation slides 10-29 <http://klaeufer.github.io/luc-amc.html#(10)>`_
-- `performance implications/shootout <http://benchmarksgame.alioth.debian.org/u64q/which-programs-are-fastest.php>`_
+- `performance implications/shootout <https://benchmarksgame-team.pages.debian.net/benchmarksgame/which-programs-are-fastest.html>`_
 
 
 .. note:: **Cardelli/Wegner polymorphism taxonomy**
@@ -440,8 +440,8 @@ In addition, there is a continuum between APIs and internal DSLs.
 Additional information is available here:
 
 - http://c2.com/cgi/wiki?DomainSpecificLanguage
-- http://martinfowler.com/bliki/FluentInterface.html
-- http://martinfowler.com/bliki/DomainSpecificLanguage.html
-- http://martinfowler.com/books/dsl.html
-- http://en.wikipedia.org/wiki/Domain-specific_language
+- https://martinfowler.com/bliki/FluentInterface.html
+- https://martinfowler.com/bliki/DomainSpecificLanguage.html
+- https://martinfowler.com/books/dsl.html
+- https://en.wikipedia.org/wiki/Domain-specific_language
 - `SE Radio episode 182 <http://feedproxy.google.com/~r/se-radio/~3/2VCOnKZ97MU/>`_

source/60-concurrency.rst

@@ -440,19 +440,19 @@ Several specific concurrency mechanisms can come as language constructs, pattern
 - fully synchronized object (pattern/building blocks)
 - Android (also familiar from 313/413)
 
-  - `AsyncTask <http://developer.android.com/reference/android/os/AsyncTask.html>`_ *(deprecated in Android API 30; prefer* `Kotlin coroutines <https://developer.android.com/kotlin/coroutines>`_ *or* `WorkManager <https://developer.android.com/topic/libraries/architecture/workmanager>`_ *)*
-  - `ThreadPoolExecutor <http://developer.android.com/reference/java/util/concurrent/ThreadPoolExecutor.html>`_
+  - `AsyncTask <https://developer.android.com/reference/android/os/AsyncTask.html>`_ *(deprecated in Android API 30; prefer* `Kotlin coroutines <https://developer.android.com/kotlin/coroutines>`_ *or* `WorkManager <https://developer.android.com/topic/libraries/architecture/workmanager>`_ *)*
+  - `ThreadPoolExecutor <https://developer.android.com/reference/java/util/concurrent/ThreadPoolExecutor.html>`_
 
-- `java.util.concurrent <https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/package-summary.html>`_
+- `java.util.concurrent <https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/concurrent/package-summary.html>`_
 
   - atomic variables
   - thread-safe collections
   - FIFO locks
   - ...
 
-- `Scala parallel collections <http://docs.scala-lang.org/overviews/parallel-collections/overview.html>`_
-- `futures and promises intro <http://docs.scala-lang.org/overviews/core/futures.html>`_
-- `composable futures in Scala/Akka <http://doc.akka.io/docs/akka/current/scala/futures.html>`_
+- `Scala parallel collections <https://docs.scala-lang.org/overviews/parallel-collections/overview.html>`_
+- `futures and promises intro <https://docs.scala-lang.org/overviews/core/futures.html>`_
+- `composable futures in Scala/Akka <https://doc.akka.io/docs/akka/current/scala/futures.html>`_
 
   .. note:: As of 2022, Akka is under a commercial license (Lightbend). The open-source Scala ecosystem has largely shifted to `Cats Effect <https://typelevel.org/cats-effect/>`_ and `ZIO <https://zio.dev/>`_ for structured concurrency. Both provide safe, composable, and purely functional abstractions for asynchronous and concurrent programming.
 
@@ -470,10 +470,10 @@ References: concurrent and asynchronous computing
 - Goetz et al., `JCIP <http://jcip.net.s3-website-us-east-1.amazonaws.com>`_
 - Doug Lea, `CPJ <http://gee.cs.oswego.edu/dl/cpj>`_
 - Thiruvathukal and Christopher, `HPJPC <https://code.google.com/p/hpjpc/>`_
-- `SE Radio episode on concurrency: part 1 <http://feedproxy.google.com/~r/se-radio/~3/lJLihLsyf0M/>`_
-- `SE Radio episode on concurrency: part 2 <http://feedproxy.google.com/~r/se-radio/~3/Wh7E6YT1_JI/>`_
-- `SE Radio episode on concurrency: part 3 <http://feedproxy.google.com/~r/se-radio/~3/WZ7h3kzRARY/>`_
-- `SE Radio episode on concurrency: part 4 <http://feedproxy.google.com/~r/se-radio/~3/bqICWnvwuGw/>`_
+- `SE Radio episode 12: Concurrency pt. 1 <https://se-radio.net/2006/04/episode-12-concurrency-pt-1/>`_
+- `SE Radio episode 19: Concurrency pt. 2 <https://se-radio.net/2006/06/episode-19-concurrency-pt-2/>`_
+- `SE Radio episode 29: Concurrency pt. 3 <https://se-radio.net/2006/09/episode-29-concurrency-pt-3/>`_
+- `SE Radio episode 348: Riccardo Terrell on Concurrency <https://se-radio.net/2018/12/se-radio-episode-348-riccardo-terrell-on-concurrency/>`_
 - `futures and promises overview <http://arild.github.io/scala-workshop/#/12>`_
 - `RxJava/RxScala <https://github.com/ReactiveX/RxScala>`_
 - `asynchronous programming video <https://www.youtube.com/watch?v=UKjcJ13bD3s>`_

source/83-resources.rst

@@ -110,9 +110,9 @@ Online Scala resources
 - `Twitter Scala School <http://twitter.github.io/scala_school/>`_ *(Scala 2; syntax may differ from Scala 3)*
 - `Scala resources from an Applied Text Analysis course <http://ata-s12.utcompling.com/links>`_
 - `Scala documentation site <http://docs.scala-lang.org>`_
-- `A Scala Tutorial for Java programmers <http://www.scala-lang.org/docu/files/ScalaTutorial.pdf>`_ *(Scala 2, 2006; for current equivalents use the official Scala 3 tour)*
-- `Scala API documentation <http://www.scala-lang.org/api/current/#package>`_
-- `Scala style guide <http://docs.scala-lang.org/style>`_
+- `A Scala Tutorial for Java programmers <https://www.scala-lang.org/docu/files/ScalaTutorial.pdf>`_ *(Scala 2, 2006; for current equivalents use the official Scala 3 tour)*
+- `Scala API documentation <https://www.scala-lang.org/api/current/#package>`_
+- `Scala style guide <https://docs.scala-lang.org/style>`_
 - `Scala Cookbook (recommended) <http://scalacookbook.com/>`_
 - `parboiled2 parser generator <https://github.com/sirthias/parboiled2>`_
 - `Cats documentation <https://typelevel.org/cats/>`_ — typeclass abstractions (Functor, Monoid, Monad, etc.) for Scala (advanced)
@@ -128,7 +128,7 @@ Resources on program representation and interpretation
 - `Extended BNF <https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_Form>`_
 - `Parser generators <https://en.wikipedia.org/wiki/Compiler-compiler>`_
 - `Parser combinators <https://en.wikipedia.org/wiki/Parser_combinator>`_
-- `Parsing expression grammars (PEGs) <http://en.wikipedia.org/wiki/Parsing_expression_grammar>`_
+- `Parsing expression grammars (PEGs) <https://en.wikipedia.org/wiki/Parsing_expression_grammar>`_
 - `Interpreters <https://en.wikipedia.org/wiki/Interpreter_(computing)>`_
 
 Other resources