change links from http to https

Author: puredanger

content/about/clojurescript.adoc

@@ -11,6 +11,6 @@ Rich Hickey
 
 ifdef::env-github,env-browser[:outfilesuffix: .adoc]
 
-http://clojurescript.org[ClojureScript] is a compiler for Clojure that targets JavaScript. It is designed to emit JavaScript code which is compatible with the advanced compilation mode of the http://code.google.com/closure/[Google Closure] optimizing compiler.
+https://clojurescript.org[ClojureScript] is a compiler for Clojure that targets JavaScript. It is designed to emit JavaScript code which is compatible with the advanced compilation mode of the https://developers.google.com/closure/[Google Closure] optimizing compiler.
 
 * https://github.com/clojure/clojurescript[ClojureScript Home]

content/about/concurrent_programming.adoc

@@ -12,13 +12,13 @@ Rich Hickey
 
 ifdef::env-github,env-browser[:outfilesuffix: .adoc]
 
-Today's systems have to deal with many simultaneous tasks and leverage the power of multi-core CPUs. Doing so with threads can be very difficult due to the complexities of synchronization. Clojure simplifies multi-threaded programming in several ways. Because the core data structures are immutable, they can be shared readily between threads. However, it is often necessary to have state change in a program. Clojure, being a practical language, allows state to change but provides mechanism to ensure that, when it does so, it remains consistent, while alleviating developers from having to avoid conflicts manually using locks etc. The <<xref/../../reference/refs#,software transactional memory system>> (STM), exposed through http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/dosync[dosync], http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ref[ref], http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ref-set[ref-set], http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/alter[alter], et al, supports _sharing_ changing state between threads in a _synchronous_ and _coordinated_ manner. The <<xref/../../reference/agents#,agent>> system supports sharing changing state between threads in an _asynchronous_ and _independent_ manner. The <<xref/../../reference/atoms#,atoms>> system supports sharing changing state between threads in a _synchronous_ and _independent_ manner. The <<xref/../../reference/vars#,dynamic var system>>, exposed through <<xref/../../reference/special_forms#def#,def>>, http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/binding[binding], et al, supports isolating changing state within threads.
+Today's systems have to deal with many simultaneous tasks and leverage the power of multi-core CPUs. Doing so with threads can be very difficult due to the complexities of synchronization. Clojure simplifies multi-threaded programming in several ways. Because the core data structures are immutable, they can be shared readily between threads. However, it is often necessary to have state change in a program. Clojure, being a practical language, allows state to change but provides mechanism to ensure that, when it does so, it remains consistent, while alleviating developers from having to avoid conflicts manually using locks etc. The <<xref/../../reference/refs#,software transactional memory system>> (STM), exposed through https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/dosync[dosync], https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ref[ref], https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ref-set[ref-set], https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/alter[alter], et al, supports _sharing_ changing state between threads in a _synchronous_ and _coordinated_ manner. The <<xref/../../reference/agents#,agent>> system supports sharing changing state between threads in an _asynchronous_ and _independent_ manner. The <<xref/../../reference/atoms#,atoms>> system supports sharing changing state between threads in a _synchronous_ and _independent_ manner. The <<xref/../../reference/vars#,dynamic var system>>, exposed through <<xref/../../reference/special_forms#def#,def>>, https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/binding[binding], et al, supports isolating changing state within threads.
 
 In all cases, Clojure does not replace the Java thread system, rather it works with it. Clojure functions are java.util.concurrent.Callable, therefore they work with the Executor framework etc.
 
-Most of this is covered in more detail in the http://www.youtube.com/watch?v=dGVqrGmwOAw[concurrency screencast].
+Most of this is covered in more detail in the https://www.youtube.com/watch?v=dGVqrGmwOAw[concurrency screencast].
 
-<<xref/../../reference/refs#,Refs>> are mutable references to objects. They can be http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ref-set[ref-set] or http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/alter[alter]ed to refer to different objects during transactions, which are delimited by http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/dosync[dosync] blocks. All ref modifications within a transaction happen or none do. Also, reads of refs within a transaction reflect a snapshot of the reference world at a particular point in time, i.e. each transaction is isolated from other transactions. If a conflict occurs between 2 transactions trying to modify the same reference, one of them will be retried. All of this occurs without explicit locking.
+<<xref/../../reference/refs#,Refs>> are mutable references to objects. They can be https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/ref-set[ref-set] or https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/alter[alter]ed to refer to different objects during transactions, which are delimited by https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/dosync[dosync] blocks. All ref modifications within a transaction happen or none do. Also, reads of refs within a transaction reflect a snapshot of the reference world at a particular point in time, i.e. each transaction is isolated from other transactions. If a conflict occurs between 2 transactions trying to modify the same reference, one of them will be retried. All of this occurs without explicit locking.
 
 In this example a vector of Refs containing integers is created _(+refs+)_, then a set of threads are set up _(+pool+)_ to run a number of iterations of incrementing every Ref _(+tasks+)_. This creates extreme contention, but yields the correct result. No locks!
 [source,clojure]
@@ -45,7 +45,7 @@ In this example a vector of Refs containing integers is created _(+refs+)_, then
 ----
 In typical use refs can refer to Clojure collections, which, being persistent and immutable, efficiently support simultaneous speculative 'modifications' by multiple transactions. Mutable objects should not be put in refs.
 
-By default Vars are static, but per-thread bindings for Vars defined with <<xref/../../reference/metadata#,metadata>> mark them as dynamic. <<xref/../../reference/vars#,Dynamic vars>> are also mutable references to objects. They have a (thread-shared) root binding which can be established by <<xref/../../reference/special_forms#def#,def>>, and can be set using _*set!*_, but only if they have been bound to a new storage location thread-locally using http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/binding[binding]. Those bindings and any subsequent modifications to those bindings will only be seen _within_ the thread by code in the dynamic scope of the binding block. Nested bindings obey a stack protocol and unwind as control exits the binding block.
+By default Vars are static, but per-thread bindings for Vars defined with <<xref/../../reference/metadata#,metadata>> mark them as dynamic. <<xref/../../reference/vars#,Dynamic vars>> are also mutable references to objects. They have a (thread-shared) root binding which can be established by <<xref/../../reference/special_forms#def#,def>>, and can be set using _*set!*_, but only if they have been bound to a new storage location thread-locally using https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/binding[binding]. Those bindings and any subsequent modifications to those bindings will only be seen _within_ the thread by code in the dynamic scope of the binding block. Nested bindings obey a stack protocol and unwind as control exits the binding block.
 [source,clojure]
 ----
 (def ^:dynamic *v*)
@@ -69,7 +69,7 @@ By default Vars are static, but per-thread bindings for Vars defined with <<xref
 (set! *v* 4)
 -> java.lang.IllegalStateException: Can't change/establish root binding of: *v* with set
 ----
-Dynamic vars provide a way to communicate between different points on the call stack without polluting the argument lists and return values of the intervening calls. In addition, dynamic vars support a flavor of context-oriented programming. Because fns defined with http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defn[defn] are stored in vars, they too can be dynamically rebound:
+Dynamic vars provide a way to communicate between different points on the call stack without polluting the argument lists and return values of the intervening calls. In addition, dynamic vars support a flavor of context-oriented programming. Because fns defined with https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defn[defn] are stored in vars, they too can be dynamically rebound:
 [source,clojure]
 ----
 (defn ^:dynamic say [& args]

content/about/functional_programming.adoc

@@ -25,7 +25,7 @@ Clojure is a functional programming language. It provides the tools to avoid mut
 (hello)
 -> "Hello world"
 ----
-http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defn[defn] is a macro that makes defining functions a little simpler.
+https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defn[defn] is a macro that makes defining functions a little simpler.
 Clojure supports arity overloading in a _single_ function object, self-reference, and variable-arity functions using *&*:
 [source,clojure]
 ----
@@ -45,7 +45,7 @@ Clojure supports arity overloading in a _single_ function object, self-reference
 (argcount 1 2 3 4 5)
 -> 5
 ----
-You can create local names for values inside a function using http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/let[let]. The scope of any local names is lexical, so a function created in the scope of local names will close over their values:
+You can create local names for values inside a function using https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/let[let]. The scope of any local names is lexical, so a function created in the scope of local names will close over their values:
 [source,clojure]
 ----
 (defn make-adder [x]
@@ -55,7 +55,7 @@ You can create local names for values inside a function using http://clojure.git
 (add2 4)
 -> 6
 ----
-*Locals created with http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/let[let] are not variables. Once created their values never change!*
+*Locals created with https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/let[let] are not variables. Once created their values never change!*
 
 
 == Immutable Data Structures
@@ -75,7 +75,7 @@ The easiest way to avoid mutating state is to use immutable <<xref/../../referen
     my-list))
 -> ([1 2 3 4 5] {:ricky "lucy", :fred "ethel"} (5 4 3 2 1) [1 2 3 4] {:fred "ethel"} (4 3 2 1))
 ----
-Applications often need to associate attributes and other data about data that is orthogonal to the logical value of the data. Clojure provides direct support for this <<xref/../../reference/metadata#,metadata>>. Symbols, and all of the collections, support a metadata map. It can be accessed with the http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/meta[meta] function. Metadata does _not_ impact equality semantics, nor will metadata be seen in operations on the value of a collection. Metadata can be read, and can be printed.
+Applications often need to associate attributes and other data about data that is orthogonal to the logical value of the data. Clojure provides direct support for this <<xref/../../reference/metadata#,metadata>>. Symbols, and all of the collections, support a metadata map. It can be accessed with the https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/meta[meta] function. Metadata does _not_ impact equality semantics, nor will metadata be seen in operations on the value of a collection. Metadata can be read, and can be printed.
 [source,clojure]
 ----
 (def v [1 2 3])
@@ -111,7 +111,7 @@ Many of the Clojure library functions produce and consume seqs _lazily_:
 (take 15 (cycle [1 2 3 4]))
 -> (1 2 3 4 1 2 3 4 1 2 3 4 1 2 3)
 ----
-You can define your own lazy seq-producing functions using the http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/lazy-seq[lazy-seq] macro, which takes a body of expressions that will be called on demand to produce a list of 0 or more items. Here's a simplified http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/take[take]:
+You can define your own lazy seq-producing functions using the https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/lazy-seq[lazy-seq] macro, which takes a body of expressions that will be called on demand to produce a list of 0 or more items. Here's a simplified https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/take[take]:
 [source,clojure]
 ----
 (defn take [n coll]
@@ -138,4 +138,4 @@ In the absence of mutable local variables, looping and iteration must take a dif
 (my-zipmap [:a :b :c] [1 2 3])
 -> {:b 2, :c 3, :a 1}
 ----
-For situations where mutual recursion is called for, recur can't be used. Instead, http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/trampoline[trampoline] may be a good option.
+For situations where mutual recursion is called for, recur can't be used. Instead, https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/trampoline[trampoline] may be a good option.

content/about/jvm_hosted.adoc

@@ -13,7 +13,7 @@ Rich Hickey
 
 ifdef::env-github,env-browser[:outfilesuffix: .adoc]
 
-Clojure is designed to be a hosted language, sharing the JVM type system, GC, threads etc. It compiles all functions to JVM bytecode. Clojure is a great Java library consumer, offering the dot-target-member notation for calls to Java. Class names can be referenced in full, or as non-qualified names after being imported. Clojure supports the dynamic implementation of Java interfaces and classes using http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/reify[reify] and http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/proxy[proxy]:
+Clojure is designed to be a hosted language, sharing the JVM type system, GC, threads etc. It compiles all functions to JVM bytecode. Clojure is a great Java library consumer, offering the dot-target-member notation for calls to Java. Class names can be referenced in full, or as non-qualified names after being imported. Clojure supports the dynamic implementation of Java interfaces and classes using https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/reify[reify] and https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/proxy[proxy]:
 
 Here's a small Swing app:
 [source,clojure]

content/about/runtime_polymorphism.adoc

@@ -15,13 +15,13 @@ ifdef::env-github,env-browser[:outfilesuffix: .adoc]
 Systems that utilize runtime polymorphism are easier to change and extend. Clojure supports polymorphism in several ways:
 
 * Most core infrastructure data structures in the Clojure runtime are defined by Java interfaces.
-* Clojure supports the generation of implementations of Java interfaces in Clojure using http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/proxy[proxy] (<<jvm_hosted#,see JVM Hosted>>).
+* Clojure supports the generation of implementations of Java interfaces in Clojure using https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/proxy[proxy] (<<jvm_hosted#,see JVM Hosted>>).
 * The Clojure language supports polymorphism along both class and custom hierarchies with <<xref/../../reference/multimethods#,multimethod>>s.
 * The Clojure language also supports a faster form of polymorphism with <<xref/../../reference/protocols#,protocols>> (but limited only to class polymorphism to take advantage of the JVMs existing capabilities for invocation).
 
 Clojure multimethods are a simple yet powerful mechanism for runtime polymorphism that is free of the trappings of OO, types and inheritance. The basic idea behind runtime polymorphism is that a single function designator dispatches to multiple independently-defined function definitions based upon some value of the call. For traditional single-dispatch OO languages that value is the type of the 'receiver' or 'this'. CLOS generic functions extend dispatch value to a composite of the type or value of multiple arguments, and are thus multimethods. Clojure multimethods go further still to allow the dispatch value to be the result of an arbitrary function of the arguments. Clojure does not support implementation inheritance.
 
-Multimethods are defined using http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defmulti[defmulti], which takes the name of the multimethod and the dispatch function. Methods are independently defined using http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defmethod[defmethod], passing the multimethod name, the dispatch _value_ and the function body.
+Multimethods are defined using https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defmulti[defmulti], which takes the name of the multimethod and the dispatch function. Methods are independently defined using https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/defmethod[defmethod], passing the multimethod name, the dispatch _value_ and the function body.
 
 [source,clojure]
 ----
@@ -44,6 +44,6 @@ Multimethods are defined using http://clojure.github.io/clojure/clojure.core-api
 -> :fight
 ----
 
-Multimethods are in every respect fns, e.g. can be passed to http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/map[map] etc.
+Multimethods are in every respect fns, e.g. can be passed to https://clojure.github.io/clojure/clojure.core-api.html#clojure.core/map[map] etc.
 
 Similar to interfaces, Clojure protocols define only function specifications (no implementation) and allow types to implement multiple protocols. Additionally, protocols are open to later dynamic extension for new types. Protocols are limited just to dispatch on class type to take advantage of the native Java performance of polymorphic method calls. For more details, see the <<xref/../../reference/protocols#,protocols>> page.

content/about/spec.adoc

@@ -332,7 +332,7 @@ alternative generators for one or more subpaths of a spec.
 In addition to the destructuring use cases above, you can make calls to ``conform`` or ``valid?`` anywhere you want
 runtime checking, and can make lighter-weight internal-only specs for tests you intend to run in production.
 
-Please see the <<xref/../../../guides/spec#,spec Guide>> and http://clojure.github.io/clojure/branch-master/clojure.spec-api.html[API docs] for more examples and usage information.
+Please see the <<xref/../../../guides/spec#,spec Guide>> and https://clojure.github.io/clojure/branch-master/clojure.spec-api.html[API docs] for more examples and usage information.
 
 == Glossary
 === predicates
@@ -374,7 +374,7 @@ These paths are used in ``explain``, ``gen`` overrides and various error reporti
 == Prior Art
 Almost nothing about spec is novel. See all the libraries mentioned above, https://www.w3.org/TR/2014/REC-rdf11-concepts-20140225/[RDF],
 as well as all the work done on various
-contract systems, such as http://docs.racket-lang.org/guide/contracts.html[Racket's contracts].
+contract systems, such as https://docs.racket-lang.org/guide/contracts.html[Racket's contracts].
 
 *I hope you find spec useful and powerful.*