Unified header style

Author: VaclavMacha

docs/make.jl

@@ -22,48 +22,49 @@ installation = [
     "Julia" => "./installation/julia.md",
     "Visual Studio Code" => "./installation/vscode.md",
     "Git" => "./installation/git.md",
-    "Quick Start Guide" => "./installation/tutorial.md",
+    "Quickstart guide" => "./installation/tutorial.md",
 ]
 
 lecture_01 = [
     "Variables" => "./lecture_01/variables.md",
-    "Elementary Functions" => "./lecture_01/operators.md",
+    "Elementary functions" => "./lecture_01/operators.md",
     "Strings" => "./lecture_01/strings.md",
     "Arrays" => "./lecture_01/arrays.md",
-    "Data Structures" => "./lecture_01/data_structures.md",
+    "Data structures" => "./lecture_01/data_structures.md",
 ]
 
 lecture_02 = [
-    "Conditional Evaluations" => "./lecture_02/conditions.md",
-    "Loops and Iterators" => "./lecture_02/loops.md",
-    "Soft Local Scope" => "./lecture_02/scope.md",
+    "Conditional evaluations" => "./lecture_02/conditions.md",
+    "Loops and iterators" => "./lecture_02/loops.md",
+    "Soft local scope" => "./lecture_02/scope.md",
     "Exercises" => "./lecture_02/exercises.md",
 ]
 
 lecture_03 = [
     "Functions" => "./lecture_03/functions.md",
     "Methods" => "./lecture_03/methods.md",
-    "Scope of Variables" => "./lecture_03/scope.md",
-    "Exception Handling" => "./lecture_03/exceptions.md",
+    "Scope of variables" => "./lecture_03/scope.md",
+    "Exception handling" => "./lecture_03/exceptions.md",
     "Exercises" => "./lecture_03/exercises.md",
 ]
 
 lecture_04 = [
-    "Standard Library" => "./lecture_04/standardlibrary.md",
+    "Standard library" => "./lecture_04/standardlibrary.md",
     "Plots.jl" => "./lecture_04/Plots.md",
     "DataFrames.jl" => "./lecture_04/DataFrames.md",
-    "Other Useful Packages" => "./lecture_04/otherpackages.md",
+    "Other useful packages" => "./lecture_04/otherpackages.md",
+    "Interaction with other languages" => "./lecture_04/interaction.md",
 ]
 
 lecture_05 = [
     "Abstract and composit types" => "./lecture_05/compositetypes.md",
-    "Generic Programming" => "./lecture_05/currencies.md",
+    "Generic programming" => "./lecture_05/currencies.md",
 ]
 
 lecture_06 = [
-    "Modules" => "./lecture_06/modules.md",
-    "Package Manager" => "./lecture_06/pkg.md",
-    "Package Development" => "./lecture_06/develop.md",
+    "Files and modules" => "./lecture_06/modules.md",
+    "Package manager" => "./lecture_06/pkg.md",
+    "Package development" => "./lecture_06/develop.md",
 ]
 
 finalproject = joinpath.("./final_project/", [
@@ -127,7 +128,7 @@ makedocs(;
         "3: Functions and methods" => lecture_03,
         "4: Packages" => lecture_04,
         "5: Type system and generic programming" => lecture_05,
-        "6: Modules and packages" => lecture_06,
+        "6: Code organization" => lecture_06,
         "Course requirements" => finalproject,
         "7: Optimization" => lecture_07,
         "8: Regression and classification" => lecture_08,

docs/src/installation/tutorial.md

@@ -26,7 +26,7 @@ The new file will open in the editor to the right of the File Explorer sidebar.
 
 ![](tutorial_6.png)
 
-## Initialize Git Repository
+## Initialize Git repository
 
 Now that we have created a new project, it is time to initialize the git repository to track the project's changes. Go to the `Source Control` bar by pressing the appropriate button in the activity bar. Then press the `Initialize Repository` button, which will create a new Git repository in the project folder.
 

docs/src/lecture_01/data_structures.md

@@ -79,7 +79,7 @@ julia> a, b, c, d = t
 </p></details>
 ```
 
-## Named Tuples
+## Named tuples
 
 Named tuples are similar to tuples, i.e., a named tuple is immutable, ordered, fixed-sized group of elements. The only difference is that each element consists of a name (identifier) and a value. Named tuples are created by the following syntax:
 

docs/src/lecture_01/operators.md

@@ -511,7 +511,7 @@ julia> round(x; sigdigits = 3)
 </p></details>
 ```
 
-## Numerical Conversions
+## Numerical conversions
 
 The previous section showed that numerical conversions could be done by using rounding functions with a specified type of output variable. This works only for converting floating-point numbers to integers. Julia also provides a more general way of how to perform conversions between different (not only numerical) types: notation `T(x)` or `convert(T,x)` converts `x` to a value of type `T`.
 - If `T` is a floating-point type, the result is the nearest representable value, which could be positive or negative infinity

docs/src/lecture_01/variables.md

@@ -98,7 +98,7 @@ There are many types in Julia. In fact, every object in Julia has its type. As a
 
 All types shown in blue are abstract types, i.e., it is impossible to create an instance of such a type. Abstract types are useful for creating logical type hierarchy. Types highlighted in green are concrete types. In many cases, it is useful to have the choice to choose which type to use. As an example, we can see floating-point numbers. There are four concrete types for floating-point numbers. If we want to maximize the precision of some calculations, we can use `BigFloat`. Using `BigFloat` increases precision but also increases computational time. On the other hand, if we want to speed up the code, we can use the type with lower precision, such as `Float32`. However, in most cases, the user does not have to take care of types and use the default type.
 
-## Variable Names
+## Variable names
 
 Julia provides an extremely flexible system for naming variables. Variable names are case-sensitive and have no semantic meaning, i.e., the language will not treat variables differently based on their names.
 

docs/src/lecture_02/scope.md

@@ -1,6 +1,6 @@
-# Soft Local Scope
+# Soft local scope
 
-The scope of a variable is the region of a code where the variable is visible. There are two main types of scopes in Julia: **global** and **local**, and we will discuss it [later](@ref Scope-of-Variables). In this section, we will only focus on loops.
+The scope of a variable is the region of a code where the variable is visible. There are two main types of scopes in Julia: **global** and **local**, and we will discuss it [later](@ref Scope-of-variables). In this section, we will only focus on loops.
 
 Every variable created inside a loop is local, i.e., it is possible to use it only inside the loop.
 

docs/src/lecture_03/exceptions.md

@@ -1,4 +1,4 @@
-# Exception Handling
+# Exception handling
 
 Unexpected behaviour may often occur during running code, which may lead to the situation that some function cannot return a reasonable value. Such behaviour should be handled by either terminating the program with a proper diagnostic error message or allowing that code to take appropriate action.
 

docs/src/lecture_03/functions.md

@@ -781,7 +781,7 @@ open("outfile", "w") do io
 end
 ```
 
-## Dot Syntax for Vectorizing Functions
+## Dot syntax for vectorizing functions
 
 In technical-computing languages, it is common to have *vectorized* versions of functions. Consider that we have a function `f(x)`. Its vectorized version is a function that applies function `f` to each element of an array `A` and returns a new array `f(A)`. Such functions are beneficial in languages, where loops are slow and vectorized versions of functions are written in a low-level language (C, Fortran,...) and are much faster.
 

docs/src/lecture_03/methods.md

@@ -439,9 +439,7 @@ nothing # hide
 </p></details>
 ```
 
-
-
-## Method Ambiguities
+## Method ambiguities
 
 It is possible to define a set of function methods with no most specific method applicable to some combinations of arguments.
 

docs/src/lecture_03/scope.md

@@ -1,5 +1,4 @@
-
-# Scope of Variables
+# Scope of variables
 
 The scope of a variable is the region of a code where the variable is visible. There are two main scopes in Julia: **global** and **local**. The global scope can contain multiple local scope blocks. Local scope blocks can be nested. There is also a distinction in Julia between constructs which introduce a *hard scope* and those which only introduce a *soft scope*. This affects whether shadowing a global variable by the same name is allowed.