One of the founders is the host of the Techzing podcast http://techzinglive.com. You can hear some of the background on Nugget if you listen to the more recent episodes.
The documentation is amazing. One problem I find with rendered literate haskell is that it because quickly unclear how the indentation across blocks of code fits together. It would be nice if there was some kind of renderer that kept the indentation in the docs, or had some kind of "indentation guide".
In the intro you say that data from >1000 interviews shows:
> men were getting advanced to the next round 1.4 times more than women
> men [...] had an average technical score of 3 out of 4, as compared to a 2.5 out of 4 for women
The conclusion of your experiment was
> masking gender had no effect on interview performance
So the question is: why do women perform worse (by the above metrics) even if the interviewer does not know they are a women?
Unfortunately you spend the remainder of the article showing that women are more likely to quit after bad interviews, and hypothesise that this is due to lower self confidence. This is interesting and all, but it does nothing towards explaining the discrepancy you described in the introduction!
Hi, I'm the author of this post. I found it hard to get good information about this topic in Haskell compared to other languages, so I'm hoping this post will help people get started if they are in a similar situation to where I was. This is a topic I'm still actively learning about, so I'm eager to hear about any suggestions or feedback you might have.
This is what I thought when I first saw the parent comment. It looks like an interesting alternative approach, but from the example I am not clear on why it is more flexible than the version using typeclasses.
I reckon I will need to re-implement my mocks using the technique you describe to really understand the motivation.
I didn't provide an example of the flexibility for sake of brevity.
The key point I want to make with regard to flexibility is the ability to have multiple "instances" and switch between them based on run-time values.
For a trivial example, consider searching an ordered array. Let me define the typeclass:
class Container a where
type Item a
size :: a -> Int
contains :: Item a -> a -> Bool
Now consider that I have the type SortedArray that I want to make an instance of Container.
instance Container (SortedArray a) where
type Item (SortedArray a) = a
size = sortedArraySize
contains = ???
What should my `contains` be? I could linear search or I could binary search. Depending on the size of the array, either could be faster (due to cache performance and constant overheads). For small arrays, linear search could be faster, and for large arrays, binary search could be faster.
I could write my method like this:
contains x xs = if size xs <= 64
then linearSearch x xs
else binarySearch x xs
But having that 64 hard coded in is sort of lame. Suppose I am writing software that will run on unknown hardware. I don't know the cache properties of it. Perhaps 16 is better. Perhaps 256. Since my application could be super high performance, I need it to be nearly optimal.
So on application start-up, I call a function which instantiates arrays of varying sizes and tries linear search vs. binary search to find the point at which one outperforms the other.
How can I use this value? I can't inject it in place of that 64 above (without unsafePerformIO...).
The solution is to instead represent the typeclass at the value level:
data Container a b = Container
{ size :: a -> Int
, contains :: b -> a -> Bool
}
Now I can have code that looks like:
main = do
n <- findOptimalSearchSplitPoint
let sortedArraySearch x xs = if sortedArraySize xs <= n
then linearSearch x xs
else binarySearch x xs
let container = Container sortedArraySize sortedArraySearch
Then I just inject that container "instance" wherever it needs to go.
I think this wouldn't be so hard if you are in the valley (or other large tech cities in the US), or targeting large companies (Glassdoor). But how do you do this if you are in a different situation?
In addition to Glassdoor, try data.jobsintech.io (H1B) or angel.co (startups) for salary information. Go on indeed.com, and look for companies around your area to see if any are in those dbs.
After a while, you should start seeing some common ranges between regular software engineers and senior engineers. Use those as a starting point in negotiations. Interview at enough places (10+), and you should see what your market value is.
Have you tried the FP Haskell Center IDE[1]? It's completely web based, and should make it very easy to set up projects, bring in stable libraries and do builds. I would imagine this would be very useful for beginners.
There's more information in the linked Communities Report.
One of the founders is the host of the Techzing podcast http://techzinglive.com. You can hear some of the background on Nugget if you listen to the more recent episodes.