Merge branch 'main' of https://github.com/TheRenegadeCoder/sample-programs-website into main

Author: jrg94

docs/languages/algol68/index.md

@@ -14,7 +14,23 @@ Welcome to the Algol68 page! Here, you'll find a description of the language as
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+[According to Wikipedia][1], ALGOL 68, also known as Algorithmic Language 68, is a 
+successor to the ALGOL 60 language. As the name suggests, ALGOL 68 first appeared 
+in 1968 as an imperative programming language.
+
+That said, ALGOL 68 has a much wider scope than ALGOL 60. For instance, ALGOL 68 
+includes user-declared types, expression-based syntax, concurrency, and even slicing.
+
+Of course, I think the most interesting language feature is the overwhelming list of 
+reserved words which includes 60 different symbols. Most of these symbols I couldn't 
+even guess their purpose. For example, what do you think `esac` does? How about 
+`ouse`? [James Jones offers a great explanation][2].
+
+In general though, I find that most of the symbols are pretty typical. Many of which 
+provide either control flow or iteration. Meanwhile, others provide typing. So, 
+overall the language seems pretty tame. Feel free to check out the Wikipedia page 
+for the full syntax and features list.
+
 
 ## Articles
 

docs/languages/bash/index.md

@@ -14,7 +14,23 @@ Welcome to the Bash page! Here, you'll find a description of the language as wel
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+According to Wikipedia, Bash is a command language first released back in 1989.
+Despite its age, Bash is till heavily maintained with changes tracked in git.
+
+In terms of features, Bash supports variables, piping, globbing, control flow,
+and even iteration. Of those features, perhaps the coolest is globbing, also
+known as wildcard matching. Globbing can be used to retrieves sets of files that
+match a wildcard expression.
+
+Beyond that, Bash is ubiquitous in the Linux/Unix/Mac communities. After all,
+it's the standard shell on most systems. In fact, it even has support on
+Windows 10. That means shell scripts are fairly portable. However, users will
+have to pay attention to code that doesn't conform the Bourne shell standards.
+
+You'd be hard pressed to find a popular system that doesn't support Bash today.
+Even Jenkins, a continuous integration utility, supports Bash scripting during
+builds.
+
 
 ## Articles
 

docs/languages/befunge/index.md

@@ -14,7 +14,12 @@ Welcome to the Befunge page! Here, you'll find a description of the language as
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+Befunge is a programming language with some very unusual standards, as a two-dimensional, self-modifying, stack-based programming language. [Wikipedia][2] has it that it was designed in 1993 by Chris Pressey, merely to be as difficult to compile as possible.
+
+All operations in Befunge are limited to a single character, and the source text can be traversed in any direction through the file. The "Instruction Pointer" starts in the upper left corner and proceeds to the right, running every character it crosses. When it reaches an arrow, `< > ^ v`, that pointer will turn and travel in the new indicated direction.
+
+Instead of variables, all operations act on one global stack of integers, similar to [Forth][3]. 0-9 will just push their value, `+ - * / %` pop the top two values and push their normal result, `.` prints out the top number, and `,` prints the corresponding character instead.
+
 
 ## Articles
 

docs/languages/brainfuck/index.md

@@ -14,7 +14,26 @@ Welcome to the Brainfuck page! Here, you'll find a description of the language a
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+[According to Wikipedia][1], Brainfuck is an esoteric programming language created in
+1992, and notable for its extreme minimalism. As people have implemented more and
+more ridiculous programs with the language, it has become relatively well-known
+over the years. Nowadays some see it as the ultimate coding challenge to create
+something useful in Brainfuck.
+
+At the core of the language is a more-than-compact instruction set, comprising
+of a whopping eight instructions. Brainfuck uses a machine model consisting of
+an infinite list of one-byte cells, an instruction pointer, and a cell pointer.
+The instructions can be used to interact with this environment: `<` and `>`
+move the cell pointer, `+` and `-` increment or decrement the value of the cell
+at the current pointer, and `[` and `]` denote a loop.
+
+A loop only starts when the value of the current cell is non-zero, otherwise
+execution jumps to the end of the loop. Likewise, a loop ends when the value is
+zero, otherwise the program jumps to the beginning of the loop. The remaining
+two instructions, `,` and `.` read one character from the input into the current
+cell and write one character from the current cell to the output, respectively.
+That's it!
+
 
 ## Articles
 

docs/languages/c/index.md

@@ -14,7 +14,18 @@ Welcome to the C page! Here, you'll find a description of the language as well a
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+As usual, I decided to dive into the history of C with [Wikipedia][1].
+
+According to Wikipedia, C is a general-purpose programming language that 
+was developed as early as 1969 at Bell Labs by Dennis Richie. Today, the 
+C language has influenced the design of many languages such as C++, C#, 
+Go, Java, and many, many more.
+
+Features of C include static typing, lexical variable scope, and recursion. 
+In addition, function parameters are passed by value, not reference, but 
+pass-by-reference can be accomplished by explicitly using pointers. Also, 
+while C has static typing, variables are weakly typed and can be converted implicitly.
+
 
 ## Articles
 

docs/languages/crystal/index.md

@@ -13,7 +13,22 @@ Welcome to the Crystal page! Here, you'll find a description of the language as
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+Like Julia, Crystal is another open-source language with a nice Wikipedia 
+page, so we'll be using that to get some language background.
+
+According to Wikipedia, Crystal is a general-purpose language that first 
+appeared in 2014. As of today, Crystal is self-hosted meaning the compiler 
+is written in an earlier version of Crystal.
+
+That said, Crystal was inspired by Ruby which is the language Crystal was 
+originally written in. However, as previously mentioned, Crystal is a compiled 
+language, so many of the dynamic features of Ruby no longer exist.
+
+Despite the lack of dynamic features, Crystal leverages strong type inference 
+to allow for implicit typing. As a result, the language looks like a high-level 
+scripting language. However, the language's efficiency is much closer to 
+lower-level languages like C.
+
 
 ## Articles
 

docs/languages/d/index.md

@@ -14,7 +14,37 @@ Welcome to the D page! Here, you'll find a description of the language as well a
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+If you haven't heard of D, I'm hardly surprised. After all, it's 
+not exactly a popular language. In fact, it currently ranks 39th by 
+popularity on GitHub. For reference, languages ahead of D include 
+Visual Basic .NET (31st), Haskell (21st), Swift (18th), and C (8th). 
+Meanwhile, D sits narrowly ahead of newer languages like Julia (43rd) 
+and Elixir (45th).
+
+That said, according to Wikipedia, D is still a pretty interesting 
+language. As you can probably imagine, D is supposed to be an 
+improvement on C++. Apparently, the designers weren't a fan of the 
+practical issues surrounding C++ (surprise, surprise!). As a result, 
+D includes features like design by contract, garbage collection, 
+associative arrays, array slicing, and lazy evaluation.
+
+Perhaps the most interesting feature to me has to be the inline 
+assembler. Apparently, developers can write assembly code directly 
+in D source code:
+
+```d
+void *pc;
+asm
+{
+    pop  EBX         ;
+    mov  pc[EBP], EBX ; 
+}
+```
+
+By adding an asm block, developers can quickly tap into the hardware 
+with assembly code. Now, I think that is a pretty cool programming 
+language feature.
+
 
 ## Articles
 

docs/languages/dart/index.md

@@ -14,7 +14,38 @@ Welcome to the Dart page! Here, you'll find a description of the language as wel
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+Dart is a general-purpose language that was designed with five goals:
+
+- Productive
+  - Dart's syntax is clear and concise, its tooling simple yet powerful.
+  Sound typing helps you to identify subtle errors early. Dart has
+  battle-hardened [core libraries][1] and an [ecosystem][2] of thousands of packages
+- Fast
+  - Dart provides optimizing ahead-of-time compilation to get predictably
+  high performance and fast startup across mobile devices and the web.
+- Portable
+  - Dart compiles to ARM and x86 code, so that Dart mobile apps can run natively
+  on iOS, Android, and beyond. For web apps, Dart compiles to JavaScript.
+- Approachable
+  - Dart is familiar to many existing developers, thanks to its unsurprising
+  object orientation and syntax. If you already know C++, C#, or Java, you can
+  be productive with Dart in just a few days.
+- Reactive
+  - Dart is well-suited to reactive programming, with support for managing
+  short-lived objects, such as UI widgets, through Dart's fast object allocation
+  and generational garbage collector. Dart supports asynchronous programming
+  through language features and APIs that use [Future][3] and [Stream][4] objects.
+
+Since its inception, Dart has gone through different phases as Google tried to
+sell its potential to developers. Google has rebuilt it's advertising service
+AdSense with Dart. That demonstrate's Google's commitment to Dart by depending
+on the language for it's main method of generating revenue.
+
+The language also has many great features like garbage collection and a strong
+typing system ([as of Dart 2.0][5]). All of it sits on top of a VM like Java, which
+allows there to be less configuration between the test side and the source code.
+A programmer can just get started from the get-go!
+
 
 ## Articles
 

docs/languages/elixir/index.md

@@ -14,7 +14,52 @@ Welcome to the Elixir page! Here, you'll find a description of the language as w
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+
+According to Wikipedia, Elixir is yet another general-purpose language 
+with functional tendencies. That said, Elixir is quite a bit different 
+from some of our recent languages. For starters, Elixir runs on the 
+Erlang virtual machine known as BEAM. This means that Elixir actually 
+compiles down to bytecode much like Java.
+
+In terms of features, Elixir has a lot to offer. For instance, Elixir 
+has support for macros which modify the abstract syntax tree. You may 
+recall that Rust has the same feature.
+
+In addition, Elixir offers Python-like doc strings which leverage Markdown. 
+This is a great feature for automatically generating documentation.
+
+Another cool feature of Elixir is exactly what I found interesting about 
+Scala: everything is an expression. In other words, everything evaluates 
+to a value.
+
+Finally, my favorite feature of Elixir has to be pattern matching. In 
+Elixir, we can match patterns using the same operator most languages use 
+for assignment: `=`. For example:
+
+```elixir
+myVal = 5
+5 = myVal  # A valid match
+6 = myVal  # (MatchError) no match of right hand side value: 5
+```
+
+In this example, we assign myVal a value of 5. Or in Elixir terminology, 
+we actually bind a value of 5 to myVal through pattern matching. Then, we 
+compare 5 to myVal which is a valid match. With that in mind, it's clear 
+why we get an error when we try to match 6 to myVal.
+
+Of course, pattern matching gets much more fun than that. We can also use 
+pattern matching to destructure other data types:
+
+```elixir
+{x, y, z} = {:hi, 117, "some string"}
+x  # :hi
+y  # 117
+z  # "some string"
+```
+
+In addition, there are several other ways pattern matching can be used, but 
+we have to get to our implementation of Hello World in Elixir.
+
 
 ## Articles
 

docs/languages/elm/index.md

@@ -14,7 +14,71 @@ Welcome to the Elm page! Here, you'll find a description of the language as well
 
 ## Description
 
-No 'Description' section available. [Please consider contributing](https://github.com/TheRenegadeCoder/sample-programs-website).
+According to Wikipedia, Elm is a functional programming language 
+used for building web-based graphical user interfaces.
+
+In terms of features, Elm offers immutability, static typing, and 
+a module system.
+
+## Static Typing
+
+At this point in the series, we've seen a lot of languages which 
+support static typing. Because of that, I'm slowly starting to draw 
+a distinction between statically and dynamically typed languages.
+
+Originally, my understanding of static typing came from languages 
+like Java and C where we have to explicitly state the types of our 
+variables:
+
+```java
+// Java Explicit Typing Example
+int x = 5;
+String helloWorld = "Hello, World!";
+```
+
+Meanwhile, my understanding of dynamically typed languages came 
+from Python where variables don't need type annotations:
+
+```python
+# Python Implicit Typing Example
+x = 5
+hello_world = "Hello, World!"
+```
+
+Because of this rather naive distinction, I was under the impression 
+that Elm couldn't actually be statically typed because the language 
+supports type annotations. Instead, I thought that maybe Elm was more 
+like Hack, a gradually typed language.
+
+Of course, the true distinction between static and dynamic typing is 
+at what point the type checking occurs: before or at runtime. In other 
+words, languages don't need explicit typing to be statically typed. 
+Likewise, languages don't need implicit typing to be dynamically typed.
+
+In the case of Elm, type inference is used to determine value types. 
+However, type annotations can be used to improve program readability.
+And, the compiler will even verify the annotations are correct. However, 
+the annotations, in this case, have nothing to do with gradual typing.
+
+## Immutability
+
+While debating type systems is great, Elm's most interesting feature 
+to me is immutability. Immutability, a byproduct of value semantics, describes
+a value's inability to be changed. In other words, immutable values are 
+values that cannot be changed after creation.
+
+To me, the concept of immutability is interesting because code like the 
+following will fail in Elm:
+
+```elm
+a = 10
+a = a - 5
+```
+
+Because a is immutable, the code above will actually cause a recursion 
+error. You can read more about that in Elm's documentation. At any rate, 
+let's get to the solution!
+
 
 ## Articles