Updated 'Weighing Machine ' exercise (#1672)

Update `weighing-machine` exercise

Co-authored-by: Erik Schierboom <erik_schierboom@hotmail.com>

Author: 18-F-cali

exercises/concept/weighing-machine/.docs/hints.md

@@ -5,29 +5,41 @@
 - [Properties][docs.microsoft.com-properties]
 - [Using Properties][docs.microsoft.com-using-properties]
 
-## 1. Allow the weight to be set on the weighing machine
+## 1. Allow the weighing machine to have a precision
 
-A property with a private [backing field][docs.microsoft.com-properties-with-backing-fields] is appropriate here.
+- You need to add a [get-only property][stackoverflow.com-get-only-properties] to store the precision in.
+- You can initialize the `get`-only property from the constructor (and only from the constructor).
 
-## 2. Ensure that a negative input weight is rejected.
+## 2. Allow the weight to be set on the weighing machine
 
-Add [validation][stackoverflow.com-validating-properties] to the `InputWeight`'s `set` accessor to throw an exception.
+- You should add a property with a private [backing field][docs.microsoft.com-properties-with-backing-fields].
 
-## 3. Allow the US weight to be retrieved
+## 3. Ensure that a negative input weight is rejected
 
-A property can return a reference to an object.
+- The `value` keyword is used to refer to the value the caller wants the property to have.
+- Add [validation][stackoverflow.com-validating-properties] to the `Weight`'s `set` accessor to throw an exception when the value is invalid.
 
-## 4. Allow the machine's units to be set to pounds
+## 4. Allow a tare adjustment to be applied to the weighing machine
 
-`Units` is a good candidate for an [auto-implemented property][docs.microsoft.com-auto-implemented-properties].
+- You should add an [auto-implemented property][docs.microsoft.com-auto-implemented-properties] for the tare adjustment.
 
-## 5. Allow a tare adjustment to be applied to the weighing machine
+## 5. Ensure that the weighing machine has a default tare adjustment
 
-Accessors can have [different access levels][docs.microsoft.com-properties-and-restricted-access] to each other.
+- You can initialize an [auto-implemented property][docs.microsoft.com-auto-implemented-properties] like you can initialize a field.
+
+## 6. Allow the weight to be retrieved
+
+- You should add a `get`-only property in which the correct display weight is calculated.
+
+## 7. Show the Display weight string properly
+
+- You should [format-string][stackoverflow.com-format-string] appropriately.
 
 [docs.microsoft.com-properties]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties
 [docs.microsoft.com-using-properties]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/using-properties
 [docs.microsoft.com-properties-with-backing-fields]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties#properties-with-backing-fields
 [stackoverflow.com-validating-properties]: https://stackoverflow.com/questions/4946227/validating-properties-in-c-sharp
 [docs.microsoft.com-auto-implemented-properties]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/auto-implemented-properties
 [docs.microsoft.com-properties-and-restricted-access]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/restricting-accessor-accessibility
+[stackoverflow.com-get-only-properties]: https://stackoverflow.com/questions/2719699/when-should-use-readonly-and-get-only-properties
+[stackoverflow.com-format-string]: https://stackoverflow.com/questions/7108850/variable-decimal-places-in-net-string-formatters

exercises/concept/weighing-machine/.docs/instructions.md

@@ -1,100 +1,74 @@
 # Instructions
 
-In this exercise you'll be modelling a weighing machine.
+In this exercise you'll be modelling a weighing machine with Kilograms as a Unit.
 
-The weight can be set and retrieved in pounds or kilograms and cannot be negative.
+You have 6 tasks each of which requires you to implement one or more properties:
 
-The weight can be displayed in SI units or US units
-, pounds and ounces.
+## 1. Allow the weighing machine to have a precision
 
-A tare adjustment can be applied to the weight (for instance to deduct the
-weight of a container). This can be any value (even negative or a value that makes the display weight negative)
-as there are doubts about the accuracy
-of the weighing machine. For security reasons this value cannot be retrieved.
-
-Note that:
-
-```
-display-weight = input-weight - tare-adjustment
-```
-
-Conversion ratios are as follows:
-
-- 16 ounces to a pound
-- 2.20462 kg to a pound
-
-For Example:
-
-- 60 kilograms == 132.2772 ponds
-- 132.2772 pounds == 132 pounds 4 ounces
-
-You have 5 tasks each of which requires you to implement one or
-more properties:
-
-## 1. Allow the weight to be set on the weighing machine
-
-Implement the `WeigingMachine.InputWeight` property to allow the weight to be get and set:
+To cater to different demands, we allow each weighing machine to be customized with a precision (the number of digits after the decimal separator).
+Implement the `WeigingMachine` class to have a get-only `Precision` property set to the constructor's `precision` argument:
 
 ```csharp
-var wm = new WeighingMachine();
-wm.InputWeight = 60m;
+var wm = new WeighingMachine(precision: 3);
 
-//  => wm.InputWeight == 60m
+//  => wm.Precision == 3
 ```
 
-## 2. Allow specifying the unit used by the weighing machine
-
-Implement the `WeigingMachine.Unit` property to allow the unit to be set. `Unit.Kilograms` should be the default value:
+## 2. Allow the weight to be set on the weighing machine
 
+Implement the `WeigingMachine.Weight` property to allow the weight to be get _and_ set:
 
 ```csharp
-var wm = new WeighingMachine();
+var wm = new WeighingMachine(precision: 3);
+wm.Weight = 60.5;
 
-//  => wm.Unit == Kilograms
+//  => wm.Weight == 60.5
 ```
 
 ## 3. Ensure that a negative input weight is rejected
 
-Add validation to the `WeighingMachine.InputWeight` property to throw an `ArgumentOutOfRangeException` when trying to set it to a negative weight:
+Clearly, someone cannot have a negative weight. 
+Add validation to the `WeighingMachine.Weight` property to throw an `ArgumentOutOfRangeException` when trying to set it to a negative weight:
 
 ```csharp
-var wm = new WeighingMachine();
-wm.InputWeight = -10m; // Throws an ArgumentOutOfRangeException
+var wm = new WeighingMachine(precision: 3);
+wm.Weight = -10; // Throws an ArgumentOutOfRangeException
 ```
 
-## 4. Allow the US weight to be retrieved
+## 4. Allow a tare adjustment to be applied to the weighing machine
 
-Implement the `WeighingMachine.USDisplayWeight` property and the `USWeight` class:
+The tare adjustment can be any value (even negative or a value that makes the display weight negative)
+Implement the `WeighingMachine.TareAdjustment` property to allow the tare adjustment to be set:
 
 ```csharp
-var wm = new WeighingMachine();
-wm.InputWeight = 60m;
+var wm = new WeighingMachine(precision: 3);
+wm.TareAdjustment = -10.6;
 
-var usw = wm.USDisplayWeight;
-// => usw.Pounds == 132 && usw.Ounces == 4
+// => wm.TareAdjustment == -10.6
 ```
 
-## 5. Allow the machine's unit to be set to pounds
+## 5. Ensure that the weighing machine has a default tare adjustment
 
-Implement the `WeighingMachine.Unit` property:
+After some thorough testing, it appears that due to a manifacturing issue all weighing machines have a bias towards overestimating the weight by `5`.
+Change the `WeighingMachine.TareAdjustment` property to `5` as its default value.
 
 ```csharp
-var wm = new WeighingMachine();
-wm.InputWeight = 175.5m;
-wm.Unit = Unit.Pounds;
+var wm = new WeighingMachine(precision: 3);
 
-var usw = wm.USDisplayWeight;
-// => usw.Pounds == 175 && usw.Ounces == 8
+// => wm.TareAdjustment == 5.0
 ```
 
-## 6. Allow a tare adjustment to be applied to the weighing machine
+## 6. Allow the weight to be retrieved
 
-Implement the `WeighingMachine.TareAdjustment` and `WeighingMachine.DisplayWeight` properties:
+Implement the `WeighingMachine.DisplayWeight` property which shows weight after tare adjustment and with the correct precision applied:
+Note that:
+``` display-weight = input-weight - tare-adjustment ```
 
 ```csharp
-var wm = new WeighingMachine();
-wm.InputWeight = 100m;
-wm.TareAdjustment = 10m;
+var wm = new WeighingMachine(precision: 3);
+wm.TareAdjustment = 10;
+wm.Weight = 60.567;
 
-// => wm.DisplayWeight == 90m
-```
+// => wm.DisplayWeight == "50.567 kg"
+```

exercises/concept/weighing-machine/.meta/Exemplar.cs

@@ -1,80 +1,36 @@
 using System;
 
-enum Unit
-{
-    Pounds,
-    Kilograms
-}
-
 class WeighingMachine
 {
-    private const decimal POUNDS_PER_KILOGRAM = 2.20462m;
+    private double _weight;
 
-    private decimal inputWeight;
+    public WeighingMachine(int precision)
+    {
+        Precision = precision;
+    }
 
-    public Unit Unit { get; set; } = Unit.Kilograms;
+    public int Precision { get; }
 
-    public decimal InputWeight
+    public double TareAdjustment { get; set; } = 5.0;
+
+    public double Weight
     {
         get
         {
-            return inputWeight;
+            return _weight;
         }
         set
         {
-            if (value < 0)
-            {
-                throw new ArgumentOutOfRangeException("weight cannot be negative");
-            }
-
-            inputWeight = value;
-        }
-    }
-
-    public decimal DisplayWeight
-    {
-        get
-        {
-            return ApplyTareAdjustment(inputWeight);
+            if (value < 0) throw new ArgumentOutOfRangeException();
+            _weight = value;
         }
     }
 
-    public USWeight USDisplayWeight
+    public string DisplayWeight
     {
         get
         {
-            return new USWeight(WeightInPounds(DisplayWeight));
-        }
-    }
-
-    public decimal TareAdjustment { set; private get; }
-
-    private decimal ApplyTareAdjustment(decimal weight)
-    {
-        return weight - TareAdjustment;
-    }
-
-    private decimal WeightInPounds(decimal weight)
-    {
-        if (Unit == Unit.Kilograms)
-        {
-            return weight * POUNDS_PER_KILOGRAM;
+            return $"{Math.Round(Weight - TareAdjustment, Precision).ToString($"F{Precision}")} kg";
         }
-
-        return weight;
     }
-}
-
-class USWeight
-{
-    private const decimal OUNCES_PER_POUND = 16m;
-
-    public USWeight(decimal displayWeightInPounds)
-    {
-        Pounds = (int)displayWeightInPounds;
-        Ounces = (int)(OUNCES_PER_POUND * (displayWeightInPounds - (int)displayWeightInPounds));
-    }
-
-    public int Pounds { get; }
-    public int Ounces { get; }
-}
+}

exercises/concept/weighing-machine/.meta/config.json

@@ -2,7 +2,8 @@
   "blurb": "Learn about properties by modelling a weighing machine.",
   "contributors": [
     "ErikSchierboom",
-    "yzAlvin"
+    "yzAlvin",
+    "18-F-Cali"
   ],
   "authors": [
     "mikedamay"

exercises/concept/weighing-machine/.meta/design.md

@@ -29,7 +29,6 @@ Note that students may choose to implement expression-bodied members.
 ## Prerequisites
 
 - `numbers`: using the `int` type and using mathematical operators and number conversions.
-- `floating-point-numbers`: using the `decimal` type.
 - `classes`: defining classes and working with members.
 - `enums`: working with enums.
 - `exceptions`: throwing an exception.
@@ -65,41 +64,24 @@ It is difficult to get the student to exercise all different aspects of
 properties through tests alone. We need comments to address the following
 practices:
 
-1. If `WeighingMachine.Units` is not auto-implemented
-   then the following comment should be made: "The appropriate form
-   for a property such as `WeighingMachine.Units` which has no validation or other processing required is
-   that for an auto-implemented property". - Approved with comment.
+1. If `WeighingMachine.Precision` is auto-implemented property set in constructor then  the following comment       should be made: "It is not appropriate
+   for a property such as `WeighingMachine.Precision` to simply intializes a value with a
+   set accessor. That should be removed.". - Approved with comment.
 
-2. If `WeighingMachine.DisplayWeight` has a non-private set accessor
-   then the following comment should be made: "It is not approprirate
-   for a property such as `WeighingMachine.DisplayWeight` which simply returns a value
-   to have a set accessor. That should be removed.". - Approved with comment.
-
-3. If `WeighingMachine.USDisplayWeight` has a non-private set accessor
-   then the following comment should be made: "It is not approprirate
-   for a property such as `USWeighingMachine.DisplayWeight` which simply returns a value
-   to have a set accessor. That should be removed.". - Approved with comment.
-
-4. If `USDisplayWeight.Pounds` has a non-private set accessor
-   then the following comment should be made: "It is not approprirate
-   for a property such as `USDisplayWeight.Pounds` which simply returns a value
+2. If `WeighingMachine.Precision` has a set accessor
+   then the following comment should be made: "It is not appropriate
+   for a property such as `WeighingMachine.Precision` which simply returns a value
    to have a set accessor. That should be removed.". - Approved with comment.
 
-5. If `USDisplayWeight.Ounces` has a non-private set accessor
-   then the following comment should be made: "It is not approprirate
-   for a property such as `USDisplayWeight.Ounces` which simply returns a value
+3. If `WeighingMachine.DisplayWeight` has a non-private set accessor
+   then the following comment should be made: "It is not appropriate
+   for a property such as `WeighingMachine.DisplayWeight` which simply returns a value
    to have a set accessor. That should be removed.". - Approved with comment.
-
-6. If `WeighingMachine.TareAdjustement` is not an auto-implemented property
-   then the following commen should be made: "A succinct way of implementing
-   `WeighingMachine.TareAdjustment` is as an auto-implemented property with a
-   `private` get accessor". - Approved with comment.
-
-7. If `WeighingMachine.TareAdjustment` is an auto-implemented property
-   but the get accessor is non-private then the following comment should be made:
-   "A non-private set accessor is not appropriate for `WeighingMachine.TareAdjustment`
-   as the instructions stipulate that the value must not be available outside the
-   class". - Disapproved.
+    
+4. If `WeighingMachine.TareAdjustement` is not an auto-implemented property with initial value
+   then the following comment should be made: "A succinct way of implementing
+   `WeighingMachine.TareAdjustment` is as an auto-implemented property initialized with a 
+   value". - Approved with comment.
 
 ## Implementing
 

exercises/concept/weighing-machine/WeighingMachine.cs

@@ -1,32 +1,12 @@
 using System;
 
-enum Unit
-{
-    Pounds,
-    Kilograms
-}
-
 class WeighingMachine
 {
-    // TODO: define the 'InputWeight' property
+    // TODO: define the 'Precision' property
 
-    // TODO: define the 'DisplayWeight' property
+    // TODO: define the 'Weight' property
 
-    // TODO: define the 'USDisplayWeight' property
+    // TODO: define the 'DisplayWeight' property
 
     // TODO: define the 'TareAdjustment' property
-
-    // TODO: define the 'Units' property
-}
-
-struct USWeight
-{
-    public USWeight(decimal weightInPounds)
-    {
-        throw new NotImplementedException("Please implement the USWeight classes' constructor");
-    }
-
-    // TODO: define the 'Pounds' property
-
-    // TODO: define the 'Ounces' property
 }