Merge branch 'release/v1.0'

Author: NicMcPhee

Diff for: .gitignore

@@ -1,10 +1,23 @@
+# C/C++ ignores
+
+# Prerequisites
+*.d
+
 # Object files
 *.o
+*.ko
+*.obj
+*.elf
+
+# Precompiled Headers
+*.gch
+*.pch
 
 # Libraries
 *.lib
 *.a
-!lib/libcmockery_la-cmockery.o
+*.la
+*.lo
 
 # Shared objects (inc. Windows DLLs)
 *.dll
@@ -16,3 +29,16 @@
 *.exe
 *.out
 *.app
+*.i*86
+*.x86_64
+*.hex
+
+# Debug files
+*.dSYM/
+*.su
+
+############
+
+# Emacs
+
+*~

Diff for: Credits.md

@@ -0,0 +1,4 @@
+# Credits
+
+People that contributed to this write-up before the project was moved
+to Github included Nic McPhee, Vincent Borchardt, and KK Lamberty.

Diff for: README.md

@@ -1,19 +1,14 @@
+# Tips and suggestions
+
 Some general comments, tip, and suggestions for this lab:
 
-# Correctness
+## Correctness
 
 The one non-subtle issue that came up in several places was that
     people simply failed to free temporary memory they'd allocated.
     `valgrind` is very good about catching these kinds of problems, so
     there's really no reason for not finding and fixing those problems.
 
-There was a strong inverse correlation between length and
-    correctness. The broken `array_merge` submissions were almost all
-    well onto the second page, where the correct ones almost all fit
-    nicely on a single page. This may be partly due to the increased
-    tendency of broken programs to have print code and commented code,
-    but probably more generally reflects a lack of clarity.
-
 Several people got lost in their array indices, and some remained
     lost there throughout. This is a nice example of a problem where
     loop invariants could be really useful in helping you stay clear
@@ -37,30 +32,11 @@ Several groups had off-by-one errors where they weren't allocating
     you need to make sure that you allocate *N+1* characters so there's
     room for the null terminator at the end. This can be tricky to find
     because the tests actually pass even if you make this make this
-    mistake. (To be honest, I'm not entirely sure *why* the tests pass.
-    I assume that somehow we're getting lucky and getting a 0 byte at
-    the end of our strings. I suspect that if we dug around some we
-    could come up with a test that would fail, but I haven't been able
-    to do so yet.) `valgrind` picks it up, though, and complains about
+    mistake. `valgrind` notices this problem and complains about
     illegal reads and writes when we try to access the memory location
     where the null terminator would need to be, but which we never
     allocated space for.
 
-A number of groups had a subtle mistake where they 
-
-1. Dynamically allocated an array that was potentially empty: `int *a = calloc(n, sizeof(int));`. 
-1. Copied some data into that array using a loop that (correctly) did nothing if *n=0*. 
-1. Accessed the first item in the array, which might not actually be there, e.g., `int i = a[0];`. 
-1. Protected the remainder of the code (through an `if` or loop with appropriate bounds) so that the value taken from the array was never *used* if n=0.
-
-This is broken since the line `int i = a[0];` is accessing a
-memory location that hasn't been allocated to your program. It's
-probably a legal memory address, though, so it's unlikely to actually
-*fail*. And since the subsequent guards ensure that you never actually
-use the (probably random) value that you got back, there probably aren't
-any tests that will actually catch the mistake. Luckily `valgrind` catches
-it, complaining about an illegal read.
-
 # Style and clarity: The big issues
 
 Please use decent variable names! C is a challenging language and
@@ -75,20 +51,9 @@ Initialize variables where you use them. Several people declared
     between. (Breaking things up into smaller functions would do much to
     lessen this problem - see below.)
 
-Use functions to break things up! Many of the submissions have
-    `array_merge` as a single function that went on for over a page. Several people have a
-    second function that looks for duplicates, which is nice, but that
-    was about it by way of modularity for most folks. Remember the bit
-    about C being a challenging language, and not making it worse?
-    Applies here, too. A nice rule of thumb (for any language) is that a
-    function should have at most one loop. Almost everyone had at least
-    three loops in their `array_merge` function, with several people
-    getting as high as 6. I'd have a look at that if I were you.
-
-On a related note, *many* people have their vowel check in
-        `disemvowel` as a huge long chain of `||` statements. Pull that
-        stuff out into a named function, *especially* if you end up
-        repeating it!
+Use functions to break things up! In the past, for example, many people 
+have had their vowel check in `disemvowel` as one huge long chain of `||` statements. Pull that stuff out into a named function, *especially* if 
+you end up repeating it!
 
 # Style and clarity: Odds and ends
 
@@ -107,20 +72,10 @@ Don't `#include` `.c` files; you want to compile `.c` files
     linker pulls them all together into a working executable.
 
 Pay attention to warnings, and ask if you don't understand what it's
-    saying. There were several cases where the compiler warnings pointed
-    right to the problem.
+    saying. It's not uncommon for people to ask questions when the
+    compiler warnings are pointing right to the problem.
 
-Use C's `bool` type (with values `true` and `false`) instead of `int`s
+As appropriate, use C's `bool` type (with values `true` and `false`) 
+instead of `int`s
 with the values 0 and 1. Booleans are a lot more readable and less error
 prone.
-
-# Algorithmic issues
-
-Several people did a variant of linear search to see if an item was
-    duplicated. Use the fact that your array is sorted (or go ahead and
-    sort it if it isn't) to simplify this (and speed it up, but the
-    simplicity is arguably the bigger issue).
-    
----
-
-These notes were started by Vincent Borchardt, 16 Aug 2012

Diff for: Tips_and_suggestions.md

@@ -0,0 +1,3 @@
+# We don't want to commit the generated binaries.
+main
+disemvowel_test

Diff for: array_merge/array_merge.h

@@ -3,5 +3,5 @@
 #include "disemvowel.h"
 
 char* disemvowel(char* str) {
-  return "";
+  return (char*) "";
 }