Fix track 2/procedures.jl

Author: stefanocampanella

index.jl

@@ -10,19 +10,16 @@ using Markdown
 using InteractiveUtils
 
 # ╔═╡ efc045a0-41b1-471d-9c51-fa828eb411b0
-# ╠═╡ disabled = true
-#=╠═╡
 # Automatically create a local environment and install needed packages
 using PyCall, BenchmarkTools
-  ╠═╡ =#
 
 # ╔═╡ 8d964530-9e3d-11ed-301f-43882004bcd5
 md"""
 # A tour of Julia
 
 Julia is a general purpose programming language designed with technical and scientific computing in mind. 
 
-It is a dynamic, high-level language, and its syntax is similar to other interpreted languages, like MATLAB or Python. The performance of Julia programs can match programs written using statically compiled languages, like C or Fortran. This is possible thanks to a clever design and Just In Time (JIT) compilation.
+It is a dynamic, high-level language, and its syntax is similar to other interpreted languages, like MATLAB or Python. The performance of Julia programs can match those of other implementations written in statically compiled languages, like C or Fortran. This is possible thanks to a clever design and Just In Time (JIT) compilation.
 
 In the following I will introduce the language, its syntax and main features.
 """
@@ -131,50 +128,32 @@ Another scenario might be **data-model integration using machine learning**: cha
 """
 
 # ╔═╡ b0caa168-c18e-4f71-a4af-6dd3d6110b91
-# ╠═╡ disabled = true
-#=╠═╡
 md"""
 ## Brief features/performance show-off
 
 Consider the following oversimplified illustration of the capabilities of Julia.
 """
-  ╠═╡ =#
 
 # ╔═╡ 28a20b93-b534-4c7d-a4aa-d105537c22f8
-# ╠═╡ disabled = true
-#=╠═╡
 # Import a Python library as Julia object
 np = pyimport("numpy")
-  ╠═╡ =#
 
 # ╔═╡ e02dba57-3e24-404e-84a9-5244793943cb
-# ╠═╡ disabled = true
-#=╠═╡
 # Create a random Julia array of ten thousands elements
 xs = rand(10_000_000)
-  ╠═╡ =#
 
 # ╔═╡ 8fbbf443-3220-4069-8fa4-b13936740c13
-# ╠═╡ disabled = true
-#=╠═╡
 # Pass a Julia array to the `numpy.sort` Python function, evaluate several times the function, print the minimum of the evaluation times to terminal, and convert the resulting `numpy.array` to a Julia array and assign it to a local variable.
 # ... In one line of code
 xs_sorted_numpy = @btime np.sort(xs)
-  ╠═╡ =#
 
 # ╔═╡ 05ff3195-a071-4d0b-80e5-82395652ceae
-# ╠═╡ disabled = true
-#=╠═╡
 # Perform the same operations in Julia (the Julia implementation is as fast as, if not faster than, the low-level language implementation used by NumPy).
 xs_sorted_julia = @btime sort(xs)
-  ╠═╡ =#
 
 # ╔═╡ 1e03fa5f-966a-443e-a488-987457887776
-# ╠═╡ disabled = true
-#=╠═╡
 # The compare the results
 xs_sorted_numpy == xs_sorted_julia
-  ╠═╡ =#
 
 # ╔═╡ 00000000-0000-0000-0000-000000000001
 PLUTO_PROJECT_TOML_CONTENTS = """
@@ -393,7 +372,7 @@ version = "1.52.0+1"
 # ╟─a5c40f9a-0109-4baa-8225-a15e59010e35
 # ╟─98a176d7-5140-4492-8a18-b42ca3c3e87d
 # ╟─fff6699a-ae06-4ec5-8cd6-bdea86d84371
-# ╠═b0caa168-c18e-4f71-a4af-6dd3d6110b91
+# ╟─b0caa168-c18e-4f71-a4af-6dd3d6110b91
 # ╠═efc045a0-41b1-471d-9c51-fa828eb411b0
 # ╠═28a20b93-b534-4c7d-a4aa-d105537c22f8
 # ╠═e02dba57-3e24-404e-84a9-5244793943cb

track 2/procedures.jl

@@ -343,17 +343,101 @@ bar(; kwargs...) = kwargs
 # ╔═╡ cf8cdafd-4814-4a18-8b96-29db5a86872f
 bar(x=1, y=2)
 
+# ╔═╡ ee5d1867-7ca3-4bc3-a916-b3567be207ae
+md"""
+## Is Julia a FP language?
+
+Some (if not most) concepts in computer science don't have rigorous definitions, as in math, at least when it comes to real systems. Functional Programming (FP) and Object-Oriented Programming (OOP) are examples of them.
+
+Functional programming is a paradigm that has its roots in lambda calculus, and express computations as function application and composition, where the arguments and the return values of functions might be other functions (functions are _first-class citizens_).
+
+In purely functional programming languages, programs are modeled as mathematical functions, that maps arguments to return values without changing the state of the world (side-effects). Evaluating the same function with the same arguments will return the same value every time, which means that functions could be substituted by a look-up tables, or _memoized_. This property provides certain guarantees about programs written in these languages, for example that they always terminate and that they can be executed concurrently without worrying about, for example, data races or deadlocks.
+
+However, in most of real applications, a programming language has to deal with the state of the system, by reading it or changing it. For example, Haskell leverage its type system to clearly separate pure functions from impure functions.
+
+Julia is heavily inspired by Lisp, and Scheme in particular. These are considered functional programming languages, and hence we might include Julia in this programming paradigm. As Lisp, Julia follows a more practical approach than Haskell, and allows to mix freely pure and impure functions.
+
+In particular, Julia has full support for higher-order functions, such as [closures](https://people.csail.mit.edu/gregs/ll1-discuss-archive-html/msg03277.html).
+"""
+
+# ╔═╡ 49d5b966-8e00-4a56-b3b1-c3a9a6fbe6e9
+let
+	# You can return both functions defined locally and lambdas from functions
+
+	function greater_than(y) # equilvalent to `greater_than(y) = x -> x > y`
+		function greater_than_value(x)
+			x > y
+		end
+		return greater_than_value # pleonastic
+	end
+
+	f = greater_than(0.5)
+
+	f(rand())
+end
+
+# ╔═╡ c0693f3e-dadf-4755-9d49-468b2703ec09
+let
+	# Indeed, comparison operators applied to only one arguments are functions
+	f = >(0.5)
+	
+	f(rand())
+end
+
+# ╔═╡ 6c0579df-9fc3-4835-8623-54595e29bb6d
+# Hence they can be used in maps, as you would do with an anonymous function
+map(>(0.5), rand(10)) # == map(x -> x > 0.5, rand(10))
+
+# ╔═╡ 045f2618-63eb-4bdb-8f22-cae4a7b1e649
+md"""
+Furthermore, there is a special syntax for defining lambdas and passing them to functions that accept a function as their first argument.
+
+The following block of code
+```julia
+f(args...) do a, b, ...
+	# function body
+end
+```
+is equivalent to the following
+```julia
+f((a, b, ...) -> begin #= function body =# end, args...)
+```
+
+This makes working with files, reminiscent of what you would do in Python, using context managers:
+```julia
+open("outfile", "w") do io
+    write(io, data)
+end
+```
+where `open` is defined the following way
+```julia
+function open(f::Function, args...)
+    io = open(args...)
+    try
+        f(io)
+    finally
+        close(io)
+    end
+end
+```
+"""
+
+# ╔═╡ 349d01e3-1a55-4a9d-a80f-464830606ec6
+map(rand(10)) do x
+	x > 0.5
+end
+
 # ╔═╡ f070f6c1-6a42-46e6-bb42-616204534074
 md"""
 !!! exercise
-	Define an higher-order function `nonmutating` that takes a function `f!` that mutates its first argument and returns a non-matating function `f` that takes the same arguments. The `nonmutating` function should have a keyword argument for choosing if to use `copy` or `deepcopy` in its implementation. Check your results.
+	Define an higher-order function `nonmutating` that takes a function `f!` that mutates its first argument and returns a non-mutating function `f` that takes the same arguments. The `nonmutating` function should have a keyword argument for choosing if to use `copy` or `deepcopy` in its implementation. Check your results.
 """
 
 # ╔═╡ 84d5e04e-f828-42e6-a45e-cebdcd13cd1a
 md"""
 ## Is Julia an OOP language?
 
-Some (if not most) concepts in computer science don't have rigorous definitions, at least when it comes to real systems, and in contrast with mathematics or physics. Object-Oriented Programming (OOP) is one of them. I'll quote verbatim the first few paragraph of "What Is Object-Oriented Programming?" from the chapter 18 of Types and Programming Languages, by Benjamin Pierce.
+I'll quote verbatim the first few paragraph of "What Is Object-Oriented Programming?" from the chapter 18 of Types and Programming Languages, by Benjamin Pierce.
 
 > Most arguments about "What is the essence of...?" do more to reveal the prejudices of the partecipants than to uncover any objective truth about the topic of discussion. Attempts to define the term "object-oriented" precisely are no exception. Nonetheless, we can identify a few fundamental features that are found in most object-oriented languages and that, in concert, support a distinctive programming style with well-understood advantages and disadvantages.
 > 1. **Multiple representations.** Perhaps the most basic characteristic of the object-oriented style is that, when an operation is invoked on an object, the object itself determines what code gets executed. [...] These implementations are called the object's _methods_. Invoking an operation on a object--called _method invocation_ or, more colorfully, sending it a _message_--involves looking up the operation's name at run time in a method table associated with the object, a process called _dynamic dispatch_. [...]
@@ -1050,6 +1134,12 @@ version = "17.4.0+2"
 # ╠═bc41ad7b-883f-45de-bf5b-9759471fe380
 # ╠═1c7c4966-428f-483c-acea-25b4e7c677fb
 # ╠═cf8cdafd-4814-4a18-8b96-29db5a86872f
+# ╟─ee5d1867-7ca3-4bc3-a916-b3567be207ae
+# ╠═49d5b966-8e00-4a56-b3b1-c3a9a6fbe6e9
+# ╠═c0693f3e-dadf-4755-9d49-468b2703ec09
+# ╠═6c0579df-9fc3-4835-8623-54595e29bb6d
+# ╟─045f2618-63eb-4bdb-8f22-cae4a7b1e649
+# ╠═349d01e3-1a55-4a9d-a80f-464830606ec6
 # ╟─f070f6c1-6a42-46e6-bb42-616204534074
 # ╟─84d5e04e-f828-42e6-a45e-cebdcd13cd1a
 # ╟─80768236-9675-11ed-3cfb-c31606f7223e