Published By
Created On
1 May 2020 17:03:49 UTC
Transaction ID
Cost
Safe for Work
Free
Yes
macOS Development 01 Performance Testing
# Performance Testing
## Introduction
This video is going to document the process of performance testing production code that is being refactored before being used in a couple of app updates. The video will be entirely in Xcode, because the code is eventually going to be integrated into production apps.
The video is aimed at anybody who has an interest in the process of macOS and iOS development. Some knowledge of programming basics might be useful but not entirely necessary. The video is going to skim over a lot of topics and is intended more as an insight rather than a tutorial.
## Moving from NSData to Data
In a couple of production apps I have been using my own Swift wrapper around the CommonCrypto C api. Along with the CommonCrypto wrapper I was also using an NSData extension to get a Hex string representation of the digest.
CryptoKit, which is a native `Swift` api for common cryptographic operations, has recently been introduced and I am going to replace the old CommonCrypto wrapper code on a couple of production apps. CryptoKit has the advantage of being a native Swift api and will allow me to simplify my wrapper code and remove the C bridging header altogether. At the same time I will reimplement the NSData extension as a native Swift `Data` extension and take the time to look at the implementation and see if there are any performance gains to be had.
So, the exercise today is to ensure that my new `Data` implementation is correct and is roughly comparable if not better in terms of performance than the original implementation.
## Setup
I have included my original `NSData` hex extension along with the intended `Data` replacement. There are three different implementations which are to be tested.
To provide some fairly realistic workloads I have included `TestData`. This is just wraps up in a struct a valid SHA256 and SHA512 along with a geojson example and keeps it out of the `main.swift`.
I have also included the `Performance` struct and static functions which will run the test code plenty of times and abstract away the averaging of the results to hopefully smooth out the impact other system resources have on the running code. The `Performance.measure` static method can take a couple of parameters to control how it works, but the basics of it are a number of iterations which is how many times to execute the test code over each run. Executing the code multiple times for each run means that code that executes very fast can still be captured. The purpose of this method is to compare performance, rather than measure absolute execution time. This is then run multiple times so that we can accumulate minimum and maximum values, calculating a mean execution time at the end. The deviation between min and max will just give an indication of how stable the results are.
## Stage 1 - Correctness
The first step is to confirm that the `Data` extension produces the expected output. In the production code I have unit tests that do this more extensively, but just to make sure changes that I make during this optimisation don't break the implementation, a simple equality check will be performed.
```swift
let digest = TestData.sha256
let digestData = Data(hexString: digest)!
let hexLoop = digestData.hexLoop
let hexReduce = digestData.hexReduce
let hexReduceAppend = digestData.hexReduceAppend
let nsdata = NSData(data: digestData)
let hexNSData = nsdata.hex
print(digest == hexLoop && digest == hexReduce && digest == hexNSData && digest == hexReduceAppend)
// true
```
This snipped creates a `Data` instance and runs the new extension methods along with my original NSData method and compares them all. We expect the console to print `true`.
It is now time to measure the performance of the methods.
## Stage 2 - Performance
```swift
[
Performance.measure(label: "Loop") { let _ = digestData.hexLoop },
Performance.measure(label: "ReduceInto") { let _ = digestData.hexReduceInto },
Performance.measure(label: "Reduce") { let _ = digestData.hexReduce },
Performance.measure(label: "NSData") { let _ = nsdata.hex }
]
.sorted { $0.mean < $1.mean }
.forEach { print($0) }
```
A sample output on a 2018 MacBook Pro shows that all the results are in the same ball park. With `hexReduceInto` having a slight edge over the other `Data` methods and within a cats whisker of the original `NSData` implementation. In fact the overall, best case, winner is the `hexReduceInto`. I find this interesting as I had expected the for loop version to be slightly more performant, demonstrating the need for this exercise!
```sh
true
PerformanceResult(label: "ReduceInto", min: 0.08666801452636719, max: 0.089790940284729, mean: 0.08822681903839111, dev: 0.0031229257583618164)
PerformanceResult(label: "NSData", min: 0.08542799949645996, max: 0.09727001190185547, mean: 0.08874142169952393, dev: 0.011842012405395508)
PerformanceResult(label: "Loop", min: 0.08816790580749512, max: 0.09841704368591309, mean: 0.09236581325531006, dev: 0.010249137878417969)
PerformanceResult(label: "Reduce", min: 0.10085892677307129, max: 0.10363304615020752, mean: 0.10235416889190674, dev: 0.0027741193771362305)
```
## Stage 3 - Analysis
> I'm going to be using forced unwrapped optionals here. This is not something I would recommend to do in production, but I am doing it here because I have precise control over the data to be operated on and a crash in this test is no problem
To make it a little clearer which was the winner a little bit of printing to the console will help:
```swift
let winner = results[0]
let secondPlace = results[1]
print("\nThe winner is",
winner.label,
"averaging",
Performance.ops(executionTime: winner.mean, executionCount: executionCount),
"ops / s")
print(winner.label,
"best effort was",
Performance.ops(executionTime: winner.min, executionCount: executionCount),
"ops / s")
print("\nSecond place goes to",
secondPlace.label,
"averaging",
Performance.ops(executionTime: secondPlace.mean, executionCount: executionCount),
"ops / s")
```
## Conculsion
As we can see over numerous runs the flaws in the testing strategy start to show up and overwhelm the results, which are very close. Swapping from NSData to Data has a couple of benefits and the `reduceInto` implementation is, in my opinion, considerably more readable with comparable performance.
## Introduction
This video is going to document the process of performance testing production code that is being refactored before being used in a couple of app updates. The video will be entirely in Xcode, because the code is eventually going to be integrated into production apps.
The video is aimed at anybody who has an interest in the process of macOS and iOS development. Some knowledge of programming basics might be useful but not entirely necessary. The video is going to skim over a lot of topics and is intended more as an insight rather than a tutorial.
## Moving from NSData to Data
In a couple of production apps I have been using my own Swift wrapper around the CommonCrypto C api. Along with the CommonCrypto wrapper I was also using an NSData extension to get a Hex string representation of the digest.
CryptoKit, which is a native `Swift` api for common cryptographic operations, has recently been introduced and I am going to replace the old CommonCrypto wrapper code on a couple of production apps. CryptoKit has the advantage of being a native Swift api and will allow me to simplify my wrapper code and remove the C bridging header altogether. At the same time I will reimplement the NSData extension as a native Swift `Data` extension and take the time to look at the implementation and see if there are any performance gains to be had.
So, the exercise today is to ensure that my new `Data` implementation is correct and is roughly comparable if not better in terms of performance than the original implementation.
## Setup
I have included my original `NSData` hex extension along with the intended `Data` replacement. There are three different implementations which are to be tested.
To provide some fairly realistic workloads I have included `TestData`. This is just wraps up in a struct a valid SHA256 and SHA512 along with a geojson example and keeps it out of the `main.swift`.
I have also included the `Performance` struct and static functions which will run the test code plenty of times and abstract away the averaging of the results to hopefully smooth out the impact other system resources have on the running code. The `Performance.measure` static method can take a couple of parameters to control how it works, but the basics of it are a number of iterations which is how many times to execute the test code over each run. Executing the code multiple times for each run means that code that executes very fast can still be captured. The purpose of this method is to compare performance, rather than measure absolute execution time. This is then run multiple times so that we can accumulate minimum and maximum values, calculating a mean execution time at the end. The deviation between min and max will just give an indication of how stable the results are.
## Stage 1 - Correctness
The first step is to confirm that the `Data` extension produces the expected output. In the production code I have unit tests that do this more extensively, but just to make sure changes that I make during this optimisation don't break the implementation, a simple equality check will be performed.
```swift
let digest = TestData.sha256
let digestData = Data(hexString: digest)!
let hexLoop = digestData.hexLoop
let hexReduce = digestData.hexReduce
let hexReduceAppend = digestData.hexReduceAppend
let nsdata = NSData(data: digestData)
let hexNSData = nsdata.hex
print(digest == hexLoop && digest == hexReduce && digest == hexNSData && digest == hexReduceAppend)
// true
```
This snipped creates a `Data` instance and runs the new extension methods along with my original NSData method and compares them all. We expect the console to print `true`.
It is now time to measure the performance of the methods.
## Stage 2 - Performance
```swift
[
Performance.measure(label: "Loop") { let _ = digestData.hexLoop },
Performance.measure(label: "ReduceInto") { let _ = digestData.hexReduceInto },
Performance.measure(label: "Reduce") { let _ = digestData.hexReduce },
Performance.measure(label: "NSData") { let _ = nsdata.hex }
]
.sorted { $0.mean < $1.mean }
.forEach { print($0) }
```
A sample output on a 2018 MacBook Pro shows that all the results are in the same ball park. With `hexReduceInto` having a slight edge over the other `Data` methods and within a cats whisker of the original `NSData` implementation. In fact the overall, best case, winner is the `hexReduceInto`. I find this interesting as I had expected the for loop version to be slightly more performant, demonstrating the need for this exercise!
```sh
true
PerformanceResult(label: "ReduceInto", min: 0.08666801452636719, max: 0.089790940284729, mean: 0.08822681903839111, dev: 0.0031229257583618164)
PerformanceResult(label: "NSData", min: 0.08542799949645996, max: 0.09727001190185547, mean: 0.08874142169952393, dev: 0.011842012405395508)
PerformanceResult(label: "Loop", min: 0.08816790580749512, max: 0.09841704368591309, mean: 0.09236581325531006, dev: 0.010249137878417969)
PerformanceResult(label: "Reduce", min: 0.10085892677307129, max: 0.10363304615020752, mean: 0.10235416889190674, dev: 0.0027741193771362305)
```
## Stage 3 - Analysis
> I'm going to be using forced unwrapped optionals here. This is not something I would recommend to do in production, but I am doing it here because I have precise control over the data to be operated on and a crash in this test is no problem
To make it a little clearer which was the winner a little bit of printing to the console will help:
```swift
let winner = results[0]
let secondPlace = results[1]
print("\nThe winner is",
winner.label,
"averaging",
Performance.ops(executionTime: winner.mean, executionCount: executionCount),
"ops / s")
print(winner.label,
"best effort was",
Performance.ops(executionTime: winner.min, executionCount: executionCount),
"ops / s")
print("\nSecond place goes to",
secondPlace.label,
"averaging",
Performance.ops(executionTime: secondPlace.mean, executionCount: executionCount),
"ops / s")
```
## Conculsion
As we can see over numerous runs the flaws in the testing strategy start to show up and overwhelm the results, which are very close. Swapping from NSData to Data has a couple of benefits and the `reduceInto` implementation is, in my opinion, considerably more readable with comparable performance.
Author
Content Type
Unspecified
video/mp4
Language
English
More from the publisher
Controlling
VIDEO
FINDI
Finding-Files-by-SHA-Hash
# Finding Files by SHA Hash
## Introduction
This next video in the tutorial series on ShaSearch is about how to use the app to find files that match a given hash. Most of the video is dedicated to the process of how to get the hashes to search for into ShaSearch.
For a couple of use cases why you might find yourself wanting to do this see the video motivation-for-using-shasearch.
## Copy and Paste
Probably the easiest way to search for a single hash is to copy it from wherever has the hash and just paste it in. For example if downloading a release of the Ubuntu operating system visiting http://releases.ubuntu.com/18.04/SHA256SUMS will give the SHA256 hash for the downloaded file. Highlight the hash and press ⌘ + C or right click and choose copy.
In ShaSearch click 'Paste', ⌘ + V or Edit -> Paste from the menu and the hash will have been added. Clicking the show button opens a popup with all the hashes ShaSearch will search for. To remove one from the list, just swipe over it with trackpad or mouse.
## From a text file
If your workflow is a bit more demanding or you need to search for a larger number of hashes at once then importing the hashes from a file may be more appropriate.
Getting and maintaining this list of files it outside the scope of this tutorial. For this tutorial we are going to use a plain text file, called shas.txt, which contains three hashes. ShaSearch will extract hashes from a plain text file so long as there is just one hash per line in the file. As in the example file the hashes can be of both SHA256 and SHA512.
To import from a text file just click the browse button and locate the file containing the hashes. This can be done as many times as necessary, if any duplicate hashes are found they are just ignored.
## From a CSV file
A surprising amount of organisations use spreadsheets for all sorts of database related tasks. In this case, if a spreadsheet is being used to keep track of SHA hashes then the section containing the hashes to be searched for can be exported as a CSV file and ShaSearch will identify all the hashes and add them to the list.
For this demonstration Numbers is being used to keep track of some files and their author. In this case it is quite a simple matter to export the table as CSV.
File -> Export -> CSV
Then back in ShaSearch click browse and choose the CSV file just created. Again, clicking show opens a popup with the imported hashes.
## Choosing a search location
ShaSearch would quite happily search an entire system for files that match the hashes we have added, but that would be a long waste of time. It would be better to narrow down the search to the top level folder, such as Documents, or in this case Downloads, that we know is where our files may be stored. Click the browse button under "Choose search path" and open that folder.
## Starting the search
ShaSearch now has all the information it needs to start the search, it has the hashes to look for and where to look. Click "Start" to begin. The progress of the search can be seen in progress indicator. If the search is taking a long time or you want to stop of any other reason, just click "Stop".
In our case the search is over quickly and the documents have been found. Clicking the "Reveal" button takes us to a finder window with the found file highlighted.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
WRITI
Writing-a-BASH-script-to-use-OpenSSL-to-SHA-hash-all-files-in-a-folder
# Writing a BASH script to use OpenSSL to SHA hash all files in a folder
## Introduction
After my last video focused on some more in depth command line usage of OpenSSL, I though it might also be useful to document the process of writing a BASH / SH / ZSH etc script to create a CSV file from a folder of files. This snaphot of the folder could then be used as the basis for a simple file change tracking system, and I mean simple, we are not looking to reinvent git in a bash script. Then, that CSV file could be manipulated and imported into the ShaSearch macOS application, which could be useful for future ShaSearch tutorial videos.
## Basic setup
I'm going to be using Visual Studio Code on macOS for this video, but it should be compatible with Linux systems with only minor tweaking.
I have ZSH as my shell, but any shell will be okay.
As in previous videos I have a folder with some randomly created files inside.
## Objectives
+ The script should recursively iterate through each file (with exceptions) in a folder and produce a CSV file as output with the SHA256 hash and filename / path.
+ The script needs to be fairly simple as it needs to be writable and explainable in one short video.
+ There should be no external dependencies, libraries, frameworks etc other than that would be found on a stock macOS installation.
+ The script should favour readability over performance in cases where there is a choice to be made, i'm not writing a production app here afterall.
## The Script
First thing is to create the script file and make it executable. Once the file is created run:
```sh
% chmod +x hash-files.sh
```
The script can now be run by typing:
```sh
% ./hash-files.sh
```
As yet the script does nothing.
The first job is to recursively obtain an array of filenames to work on. For this we can use the "find" command with the -L option.
We can then expand this into an array with the following:
```sh
file_list=$(find -L $1)
files=(${file_list})
```
`$1` here will be replaced with the first argument passed to the script. We then need a `for` loop to iterate over each item of the array.
Next job is to filter out folders and .DS_Store files. In this case we are going to use an `if` statement to check for both these cases and then anything else we will consider to be a valid path to operate on.
We will create variables to hold the hash output of OpenSSL (just the hash and not the rest of the output), and the filename.
Once we have these we can then just create a string with a comma to separate and redirect the output to the filename that was passed in as the second argument.
```sh
hash=$(openssl sha256 $path | cut -d " " -f 2)
filename=$(basename $path)
echo "$hash,$filename" >> $output
```
## Conculsion
This video documents the intial process in creating a bash script to create a CSV file containing a list of filenames and hashes. I'm sure there are plenty of optimisations that could be made to the script to make it more robust and more performant. But in upcoming videos I will explore other methods of creating the same output.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
USING
Using-openssl-to-create-SHA-hashes
# Using OpenSSL to create SHA Hashes
## Introduction
This is a quick extra video to provide some extra detail into how to create SHA hashes by other methods than ShaSearch. Its very easy to create hashes with ShaHash but one of the benefits of using the hash of a file to check its integrity is that anybody can do it on their own system, without installing any extra software, and be confident in the results.
This video is filmed on macOS because ShaSearch is a macOS application, but the terminal commands will also apply to any UNIX / Linux type system also. The only prerequisite is that OpenSSL is installed on your system. It comes with macOS by default and if your using Linux it is most likely also installed on your distribution.
If your using Windows then i'm sure a quick internet search will reveal some instructions comparable to this video.
## Creating a SHA256 hash with OpenSSL
In its simplest form OpenSSL can be run with just the sha256 option and the filename, which will output the hash of the file.
```sh
% openssl sha256 Policy-0011.txt
// SHA256(Policy-0011.txt)= 6d401f3d137ab404e615f510342d496d65445e3cbc1d13827f9279dc7f13d18b
```
This is an excellent way to quickly generate the hash. The same thing can be achieved in ShaSearch by tapping the button in the top center of the window, selecting from the menu File -> Hash or tapping ⌘ + R, then browsing for the file. It can be copied to the clipboard by clicking the button.
The same thing can also be done in the terminal. When in the terminal one way to go is to pipe the output of OpenSSL into "cut". We can use "cut" to separate the output using the space character as a delimiter. There are plenty of other ways to do this of course, but we can avoid touching regular expressions because of the way OpenSSL outputs its result.
```sh
% openssl sha256 Policy-0011.txt | cut -d" " -f2
// 6d401f3d137ab404e615f510342d496d65445e3cbc1d13827f9279dc7f13d18b
```
We are now most of the way there, all we need to do next is pipe this stripped out hash into the pasteboard and we are done.
```sh
% openssl sha256 Policy-0011.txt | cut -d" " -f2
// No output... The hash is in the pasteboard
```
Once we have our hex string representation of the hash in the pasteboard we can simply paste it into whatever means we are using to keep track of our files, paste it into email and so on.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
NOD
04-Tamper-Evident
# Nod | Tamper Evident GIS
## Introduction
This video aims to explain the properties of the Nod file format that make it tamper evident.
## Why Tamper Evident
Nod aims to be "Tamper Evident" rather than "Tamper Proof". It is a small change of description but relates to a fairly major change in concept.
### Tamper Evident versus Tamper Proof
If Nod where to claim to be "Tamper Proof" then it would be claiming that it would not be possible to alter the data that it stores in its files. As `.nod` files can be exported and used on other systems it is simply not possible to claim that the data cannot be altered. Even if the resulting data became unreadable it has still be altered and therefore it has not been "Tamper Proof".
Instead, Nod claims to be "Tamper Evident". The distinction being that the app does not attempt to stop alteration of the data directly, but instead make it very clear that data has been altered and at what point in the file the alteration occurred.
## JSON
> JavaScript Object Notation is an open standard file format, and data interchange format, that uses human-readable text to store and transmit data objects consisting of attribute–value pairs and array data types. It is a very common data format, with a diverse range of applications, such as serving as a replacement for XML in AJAX systems
> Wikipedia
### Example
```javascript
{
"action": {
"layerId": "53368C3F-E737-4675-8035-87DCC7C4124D",
"featureType": "Polygon",
"properties": {
"title": "Feature 0"
},
"type": "newStyledFeature",
"featureId": "F0E4A44A-8A13-4C43-B4E3-30987A9DD326"
},
"previousHash": "96e2c4bf24dd509a732fb5371ca40e940424ffdc14bb2f82909ff124b728635e",
"timestamp": "612711017.262419",
"hash": "0175ab2d4999e217d90fa69db9e4716334ba17e58c47c450164c9e5db6223358",
"index": 1
}
```
## Nod
Nod files are __valid JSON__ files.
They are made up of a chain of action objects, similar to the example above. An action object describes an event in the app which would need to be completed in order to recreate the original rendered document.
Crucially they are arranged into a chain where each action object and the hash of the previous object is hashed together. This makes it trivial to spot tampering as any tampering will result in the hash of altered object not matching the expected hash.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
MACOS
macos-development-02-unit-testing
# macOS Development 02 Unit Testing
## Introduction
In my last video I used a command line application to run performance measuring code on some other code I was developing ready for production. So the whole program was just a big test. This is a perfectly legitimate means to run code to test other code. But, when developing a complete application, using the built in testing system in Xcode has some advantages. These advantages will become clear as we progress into this video which is focusing on unit testing. Again the video will be set in Xcode itself.
As before, this video doesn't require any previous knowledge of programming or Swift (although it may be helpful). This video is more an insight into one possible approach to application development. It often gets the name "Test Driven Development". I tend to follow this system because I have found that overall it makes for a more pleasant development experience, and, the end product is designed with testing in mind, so it is much easier to be confident that production releases are stable and suitable for release.
The approach i"m going to demonstrate is my own take on test driven development. I don"t always write tests first, sometimes I find it easier to think about solving the problem first. But having a good degree of test coverage (meaning that a high percentage of production code should have associated units tests), is always one of the end goals. This is where the Xcode Code Coverage tool becomes one of the advantages of using Xcodes `XCTest` framework for unit testing.
## Setup
The `XCTest` framework is designed to be used for unit testing applications with a Graphical User Interface (GUI). So I have created a blank project using the macOS App template in Xcode. Ticking the "include unit tests" checkbox when creating the project made Xcode also create build targets for the test. The video today isn't going to make use of any of the GUI parts of the template, so I have just removed the boilerplate code and they just remain as a "skeleton" to have a app to test against.
## Objective
The purpose of this video is to add tests to this code as if it were being add to a production application. The tests are going to check my implementation's results against a set of known good results. The code is already written and performance optimised and available on GitHub at https://github.com/rase-rocks/Geoflash. But this application needs to run its own unit tests and not rely on some upstream testing on the Geoflash project.
As a source of truth for the results I am relying on the implementation at https://www.movable-type.co.uk/scripts/geohash.html
## Step 1 - Add Geoflash code to the application
Geoflash is designed with performance in mind and to be a single file solution. So I can just create a new `Swift` file and paste in the code from GitHub. There are a multitude of other ways to include code from other projects, but that is not what this video is about, so pasting it in here will suffice.
The Geohash algorithm deserves a video all to itself, but for the purposes of this video we can see that the `Geoflash` struct has one important `static` method and that is `hash`. This method takes a latitude and longitude in the form of two `Double` arguments and a precision, which is how many characters the resulting hash should be (more accuracy, more characters) and returns the hash as a `String`.
As a side note, the geohash algorithm gives us an easy way to find nearby locations without having to calculate the distance, and instead just do a `String` comparision down to a given number of characters that corresponds to the distance we are looking for. For some applications this can be quite a performance gain.
## Step 2 - Add unit tests
To make the testing code a little simpler I have added a test struct to hold the data we need to test.
```swift
struct GeoflashTest {
let latitude : Double // Values to hash
let longitude : Double // Values to hash
let hash : String // Expected / known good geohash
let name : String // Name for easier recognition
}
````
First of all we create an array of tests, with values that were generated by our reference implementation.
```swift
let tests = [
GeoflashTest(latitude: 38.897, longitude: -77.036, hash: "dqcjr0bp7", name: "1600 Pennsylvania Avenue, Washington DC"),
GeoflashTest(latitude: 53.105006, longitude: -3.912463, hash: "gcmnngrp1", name: "Pinnacle Stores, Capel Curig"),
GeoflashTest(latitude: -42.775050, longitude: -65.024357, hash: "683u8m49q", name: "Puerto Madryn, Argentina")
]
```
Then we create a quick `forEach` closure to compare our implementation with the reference. Then it is just a matter of passing in the latitude and longitude values and checking the returned value matches our expected / known good value.
```swift
tests.forEach { test in
let result = Geoflash.hash(latitude: test.latitude, longitude: test.longitude, precision: test.hash.count)
XCTAssertEqual(result, test.hash)
}
```
## Step 3 - Run tests
Xcode can now build and run the test suite.
In order to add code coverage open the build scheme editor with *Product -> Scheme -> Edit Scheme*. Choose the *Test* scheme and go to the *Options* tab. Check the *Code Coverage* box.
Running the tests again will generate coverage data that can be viewed by the Test Inspector.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
MOTIV
Motivation-for-using-ShaSearch
# Motivation for using ShaSearch
## Welcome
Welcome to this short video tutorial series. These videos are designed to help a new user get to grips with using the ShaSearch application for macOS as quickly as possible.
All the videos make a couple of assumptions. The main one is you are using at least macOS Catalina 10.15 and you are able to install applications from the macOS App Store. The second is that you have ShaSearch installed on your machine.
## Installing from the App Store
The process for installing ShaSearch is the same as for any application that is available on the App Store.
A quick way to find ShaSearch is to type the name into the search box from the App Store. The application is free and so just click get and it will be installed.
To run the application just click its icon.
## Introduction to hashing
Before begining to talk about how to use ShaSearch it might be useful to have a quick introduction into what a 'Secure Hash Algorithm' is and what it does. An excellent and in depth explaination is available on wikipedia at https://en.wikipedia.org/wiki/Cryptographic_hash_function SHA-2 specifically at https://en.wikipedia.org/wiki/SHA-2.
In brief, a hashing algorithm takes a variable length amount of data and produces a fixed length 'digest' or hash. It is a one way function, meaning that it should be practically infeasible to reconstruct the original data from the hash. Any alteration at all of the input should produce a totally different output.
Lets have a more concrete example of this in action. I have used the magic of computers to create some folders containing some text files and some html documents. I am going to be using these files in later videos but for now one of the text files will serve as an example to demonstrate what happens when a file is altered, even by a small amount.
I'm going to use the Terminal for this demonstration at first and then demonstrate the same process in ShaSearch. I'm using the terminal as it will keep a history of what we have done as we go.
## Use cases
This property makes it ideal to detect any difference at all between two electronic documents. This in turn makes any tampering or alteration of the document immediately obvious.
A common usage of this property is when downloading files over the internet. Often a hash will also be provided so that when the file is finished downloading a hash can be generated and compared with the expected result. If the two do not match then something has gone wrong, either the file is corrupt or has been tampered with in some way during the download process.
The next video will focus on actually using the application to find files on your computer with a matching SHA hash.
## Use case example
This ability to ensure that two documents are identical (or not) is also useful when having conversations about documents over email for example. Instead on relying on the filename, which can be changed, or some other "best guess" attempt to make sure both parties are referring to the same data, a quick check of SHA hash removes all uncertainty straight away. This is most useful when referring to multiple versions of what is intended to be a single document.
With this in mind the main purpose of ShaSearch, as the name suggests, is to search your computer for files which match a given SHA hash. Using our simple email version control as an example a short story could unfold like this:
Alice and Bob have been working on a presentation together. They are not using any kind of version control or collaboration system. Alice simply created a Keynote presentation and sent it to Bob for him to have a look at over email. He made some changes and emailed them back to Alice. This happened a couple of time and each time they saved the emailed presentation to a folder on their own machine. After a while they each had five or six different versions of the presentation. A couple of these files had even been renamed by Alice to "Presentation-Final", "Presentation-Final 2" and so on. Bob had his own naming scheme. Alice decided which of the documents was going to be the one to be distributed and emailed the SHA hash to Bob. Now Bob could be sure he was able to send out to all the other members of the team the correct document (with his own file naming ideas), by searching his working folder with ShaSearch for the hash that Alice had sent.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
NOD 0
Nod-02-Measuring-Distance
# Nod | Tamper Evident Geographic Information System
This is a very short video to demonstrate how to use Nod for iOS to quickly measure distance.
It picks up straight after the last video and begins by choosing Ruler mode for the Loupe. (The Loupe is the magnify glass style thingy with a toolbar underneath in the Map tab).
Once the ruler mode is selected the Loupe toolbar shows a couple of extra buttons. The left most button adds a new ruler to the map. Tapping it again adds a fixed end point to the ruler. Further rulers can then be added in the same way.
The other extra button is the remove button. This removes all rulers off the map in one go.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
NOD 0
Nod-01-First-Use
# Nod | Tamper Evident GIS
Welcome to this short video tutorial series and thank you for downloading Nod for iOS.
This video will focus on what to expect the first time you run Nod.
The version shown in this video is Nod v1.1.0
Nod for iOS is a Tamper Evident Geographic Information System (GIS). For a comprehensive description of a GIS and their uses, wikipedia has an excellent and in depth article at https://en.wikipedia.org/wiki/Geographic_information_system.
This video details the process of using Nod for the first time and mapping out a small area of land as a polygon feature. It also demonstrates how to view information about the feature, such as its area.
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English
Controlling
VIDEO
MACOS
macos-development-03-swift-playgrounds
# macOS Development 03 Swift Playgrounds
## Introduction
Welcome to this third video in the macOS development series. In this series I am documenting a couple of different strategies I use when developing macOS applications. Many of the concepts are identical to iOS development, but i'm focussing here on macOS.
As before no prior knowledge of programming or the Swift programming language is necessary although I am going to skim over the technical aspects of the video, so some knowledge may aid in the understanding. These videos are about the processes I use and are not Swift language tutorials. Xcode is going to be the IDE (Integrated Development Environment) as the code produced is destined to run on either macOS or iOS.
## Objective
This video is going demonstrate one approach to using Swift Playgrounds as a rapid development tool.
This video is set as if developing a fictitious "dog breed recognition" application. The app is going to help people get to know and recognise different dog breeds. It is going to do this by presenting the user with an image of dog and a multiple choice answer system for the user to choose from. The questions will be chosen at random, but, for reasons of consistency (and because I want to) the questions while appearing to be chosen at random will actually be in the same order for every user, so that every user gets the same learning experience. (This part is made up because I want to use a psuedo random number generator, a linear congruential generator to be precise).
## Playground features to be demonstrated
+ Pre compiled sources from the `sources` folder
+ Resources and getting urls for files in the resources bundle
+ Using JSON files within a playground
Transaction
Created
3 weeks ago
Content Type
Language
video/mp4
English