Random outpourings of a software developer
These are the most common casing rules:
PascalCase
snake_case
camelCase
kebab-case
PascalCase is used in C# for classes and methods.
Java uses PascalCase for classes but camelCase for methods.
Elixir uses PascalCase for modules and snake_case for variables and functions.
CSS uses kebab-case.
These are the notes from working through the new version of the book.
Firstly Phoenix 1.4 has been released so the Phoenix install instructions are out of date so here is the update:
$ mix archive.uninstall phx_new
$ mix archive.install hex phx_new 1.4.0
(from: https://phoenixframework.org/blog/phoenix-1-4-0-released)
I also did not have postgres installed:
$ brew install postgres
initdb /usr/local/var/postgres
/usr/local/opt/postgres/bin/createuser -s postgres
(from https://stackoverflow.com/questions/15301826/psql-fatal-role-postgres-does-not-exist)
This will get you to the end of the hello app.
The common recommendation in Elixir is to let it crash (more accurately it is let a supervisor handle the error ). This is normally the case when you have small processes.
There is another pattern that can be used.
If all of your functions return {:ok, something} or {:error, reason} then technically the function is a Monad. This allows pipelines in which data and errors can be passed through cleanly.
Railway oriented programming takes this a stage further by having defined pipelines that have a good and an error route. It is possible for errors to be handled and returned to the good track.
It’s worth looking over the basics libraries of a language from time to time to see if you have missed anything useful.
For example Elixir has the very useful:
https://hexdocs.pm/elixir/Enum.html#map_join/3
This allows you to map some data then join it together as a single operation.
https://hexdocs.pm/elixir/Enum.html#min_max/2
This finds the smallest and largest items in an Enumerable by a given definition.
https://hexdocs.pm/elixir/String.html#split/3
This splits a string on a pattern and allows you to drop the empty elements. This is especially useful if there are patterns that you want to filter out as well. One iteration will split and remove the irrelevant items.
I have been having fun embedding video on chrome as a looped background image.
The same simple code worked across safari and firefox.
Chrome now bans autoplaying video that has audio. Removing the audio and using mute fixed the problem.
This is a great link for handling counts in RSpec.
It’s not quite as clean as Spock.
Most definitions of the Open Closed Principle talk in terms of extension. This makes it hard to check for because you need to imagine all possible extensions. There is a simpler equivalent test: How much would I need to change to remove this feature? Theoretically it could be as little as deleting one class that self registers (plus the tests). The advantage is that it’s easier to reason about removal.
I have been working on some Java coding kata’s lately.
One of the pain points was the getting the environment set up.
This is one thing that other environments get right:
C# – visual studio has templates for everything.
Elixir – “mix new projectname” does the trick
I have had a look at the Java equivalents:
If you have gradle installed:
gradle init –type java-library
or if you prefer groovy and spock:
gradle init –type groovy-application
If you have maven installed:
mvn archetype:generate –DgroupId=com.mycompany.app –DartifactId=my–app –DarchetypeArtifactId=maven–archetype–quickstart –DinteractiveMode=false
Personally I like the brevity of gradle, both of these should be run inside the directory that you have created.
Property testing looks to be an interesting subject.
This is a journal of my working through the book “Property Based Testing in PropEr with Erlang and Elixir”. Note that the book is on it’s third beta at the time I am writing this.
The book is mostly written in Erlang with the Elixir details following (and in an Appendix).
I have upgraded my version of proper to 1.1 rather than the suggested 1.0. This seems to fix the issue I was having experimenting with :proper_types.term()
The PropEr tests will warn you to run mix.propcheck.clean, however if proper is only installed in test mode you will need to use:
MIX_ENV=”test” mix propcheck.clean
The source for this can be found here:
https://github.com/chriseyre2000/pbt
This is at the end of chapter 2.
Property Testing is the practice of testing code with a range of test data that is generated. Typically a property can have 100 test runs with increasingly complex test data. Only the simplest failure will be reported. Properties are a set of invariants that are asserted about the subject under test with respect to the input data.
For example a sorting function can assert that the data set is the same size as before, all elements of each collection (before and after) reside in the other and that each of the sorted elements is <= the next element. Care must be taken not to repeat the implementation. It is possible to use an older system as a golden master.
Powershell is a very powerful language yet a lot of developers get frustrated by some of it’s little quibbles.
Learning a few little details make working with powershell much easier.
Items to consider are:
Powershell commands are always formed Verb-Noun although they can have a more familiar alias.
The beauty of Powershell is how configurable and reflective it is.
If you don’t like the default behaviour then it can easily be adjusted.
For example to find the automatic variables you can use the simple command:
dir variable::*
This lists the variables defined in global scope, including the automatic variables.
Details of these can be found using:
get-help about_auto | more
For example you can change the continue on error by setting $ErrorActionPreference
If you don’t think that PowerShell is strict enough on checking the parameters and types you can use:
Set-StrictMode -Version Latest
This is the Implicit None from Fortran (or VB’s OPTION STRICT).
It means that you get warned if you try to use an uninitialised variable.
PowerShell uses the prefix [Type] to define a type.
So:
$a = [int]16
is valid.
