fixes

Author: Martinsos

site/get-started.markdown

@@ -7,14 +7,21 @@ isGettingStarted: true
 # Get started
 Welcome, new Haskeller! Read on to quickly set up your Haskell dev environment, execute your first lines of code, and get directions for further learning!
 
+## Content
+  - [Set up Haskell dev environment](#set-up-haskell-dev-environment)
+    - [GHCup: universal installer](#ghcup-universal-installer)
+    - [Editor](#editor)
+  - [Running first lines of code](#running-first-lines-of-code)
+  - [Writing your first Haskell program](#writing-your-first-haskell-program)
+  - [Join the community](#join-the-community)
+  - [Next steps](#next-steps)
+
 ## Set up Haskell dev environment
 
-### GHCup - universal installer
+### GHCup: universal installer
 
 [GHCup](https://www.haskell.org/ghcup/#) is a universal installer for Haskell that will install for you everything you need to program in Haskell, and then will also help you manage those installations in the future (update, switch versions, ...).
 
-It is simple to use, works the same way on all platforms (Linux, macOS, Windows), and gives you one central place/method to take care of your Haskell development setup.
-
 Follow instructions at [GHCup webpage](https://www.haskell.org/ghcup/#) to install GHCup. Then, use it to install the Haskell Toolchain, which consists of:
 
 1. **GHC** -> Haskell compiler. We will use it below to run our examples, but in practice, you will mostly be using a build tool like `cabal` or `Stack` to build your code, instead of `GHC` directly.
@@ -26,21 +33,11 @@ Follow instructions at [GHCup webpage](https://www.haskell.org/ghcup/#) to insta
 <div class="bs-callout bs-callout-info">
   <p>
     <h4>cabal and Stack -> which one should I install?</h4>
-    cabal is the original build tool, while Stack was created as an alternative to cabal a time ago to solve some of the problems that cabal had and provide a more user-friendly experience. In the meantime, cabal solved most of those issues (including "cabal hell") and caught up with Stack regarding user experience, so the main difference between them at the moment is how they resolve dependencies, which for you as a beginner isn't a concern. Therefore, both are a good choice, and if not sure, you can install both and then use whatever the learning resources you will later use will point you to.
+    We recommend installing both. Most Haskell projects can be built using Cabal, but some might require Stack. Installing both guarantees that you can use either, and while following the tutorial/book you can use whatever they recommend.
   </p>
 </div>
 
-To confirm it is all installed correctly, you can run the following commands:
-```
-> ghc --version
-> haskell-language-server-wrapper --version
-> cabal --version                               # If you installed cabal
-> stack --version                               # If you installed Stack
-```
-
 ### Editor
-HLS (Haskell Language Server), which you just installed via GHCup, is the one that brings all the cool IDE features to editors, so as long as your editor has a decent Haskell language extension that utilizes HLS, you are good.
-
 **Visual Studio Code** is a popular choice with well supported editor integration. Install the [Haskell extension](https://marketplace.visualstudio.com/items?itemName=haskell.haskell) and you are all set. It should work out of the box and use your installation of HLS.
 
 Of other editors that have good Haskell extensions, the most popular ones are Vim and Emacs.
@@ -58,11 +55,10 @@ Let's do a simple calculation to check Haskell's computing capabilities:
 > 6 + 3^2 * 4
 42
 ```
-Hey, they call Haskell lazy, but that was quick!
 
-42 is a nice even number, but what about the even numbers after it? Let's get the first 10 even numbers after 42.
+42 is a nice even number, but what about the first 10 even numbers after it?
 ```
-> take 10 $$ filter even [43..]
+> take 10 (filter even [43..])
 [44,46,48,50,52,54,56,58,60,62]
 ```
 
@@ -77,42 +73,43 @@ Great, you got the first taste of Haskell! Now let's get to running a real progr
 
 ## Writing your first Haskell program
 
-In your editor, create a new file named `hievb.hs`.
+In your editor, create a new file named `hello.hs`.
 
 Write the following in it:
-```
+```hs
 main = do
-  putStrLn "Hi, everybody!"
-  putStrLn $$ "Pls look at my favorite odd numbers: " ++ filter odd [10..20]
+  putStrLn "Hello, everybody!"
+  putStrLn ("Please look at my favorite odd numbers: " ++ filter odd [10..20])
 ```
 
-You can now compile it with `ghc`, which will produce `hievb` binary that we will then run:
+You can now compile it with `ghc`, which will produce `hello` binary that we will then run:
 ```
-> ghc hievb.hs
-> ./hievb
-Hi, everybody!
-Pls look at my favorite odd numbers: [11,13,15,17,19]
+> ghc hello.hs
+> ./hello
+Hello, everybody!
+Please look at my favorite odd numbers: [11,13,15,17,19]
 ```
 
 There you go, you just wrote a short, polite program in Haskell!
 
 **TIP**: To interpret the source file directly, without producing any build artifacts, you can use the special `runghc` command like this:
 ```
-> runghc hievb.hs
-Hi, everybody!
-Pls look at my favorite odd numbers: [11,13,15,17,19]
+> runghc hello.hs
+Hello, everybody!
+Please look at my favorite odd numbers: [11,13,15,17,19]
 ```
 
-**GHCI TIP**: You can also load your file directly into `ghci`, which will enable you to play with any functions and other definitions you defined in it. So for our example, we can just load hievb.hs with ghci and then call the function `main` like this:
+**GHCI TIP**: You can also load your file directly into `ghci`, which will enable you to play with any functions and other definitions you defined in it. So for our example, we can just load `hello.hs` with ghci and then call the function `main` like this:
 ```
-> ghci hievb.hs
-... Compiling ...
+> ghci hello.hs
+GHCi, version 8.10.7: https://www.haskell.org/ghc/  :? for help
+[1 of 1] Compiling Main             ( hello.hs, interpreted )
+Ok, one module loaded.
 > main
-Hi, everybody!
+Hello, everybody!
+Please look at my favorite odd numbers: [11,13,15,17,19]
 ```
 
-**PRO TIP**: Once you progress a bit more in your Haskell journey, you will very likely want to use `cabal` or `Stack` for building your projects, and not `ghc` directly.
-
 ## Join the community
 
 By joining the Haskell community you will find a great place to ask for help and learn about new developments in the Haskell ecosystem.
@@ -129,9 +126,7 @@ Check [https://www.haskell.org/community](https://www.haskell.org/community) for
 
 ## Next steps
 
-There is a myth going around that you need Ph.D. in maths to be able to learn Haskell - and while it is true that Haskell in its elegance does often come close to the elegance of mathematics and borrows a lot of concepts from it, you certainly don't need any advanced math knowledge to be proficient with Haskell. Instead, what you need are some good learning resources!
-
-Some popular free learning resources for beginners:
+Popular free learning resources for beginners:
 
  - [Introductory Haskell course of the University of Pennsylvania (CIS194)](https://www.seas.upenn.edu/~cis1940/spring13/lectures.html) (course)
  - [Learn You a Haskell for Great Good!](http://learnyouahaskell.com/) (book)