242 karma · joined March 20, 2018
socials: - x.com/whizzaf - zafer@algora.io - github.com/zcesur
coincidentally, we did an interview with one of the co-founders a few days ago. dropping the links below in case anyone wants to learn more about their philosophy & how they navigate the oss/startup waters
highlights (7min): https://youtu.be/gymNEH-skAY
full interview (45min): https://youtu.be/BKCuNhyQlGE
1. That's an interesting question that we haven't yet considered. We personally only store the config for the dev environment in our main repo and manage the sensitive production config using k8s Secrets (while version controlling them in a separate repo), so we haven't really run into any issues regarding that. Is there a particular solution that you'd like to see on Algora?
2. Yep! The issue page of each bounty also displays who started a solution (and when), e.g. https://app.algora.io/algora/challenge/bounties/1. We're actually not a fan of having multiple developers compete for the same reward ourselves (though there are some good use cases for that as well).
I wish we had more expertise and time on our hands to publish more thorough posts, but the truth is that we're just two young guys who are hacking up stuff in their home office, scrambling to get feedback on what we've been working on during the dwindling window of opportunity of the YC Build Sprint.
The "article" had no purpose other than to share our story, provide a food for thought and most importantly to learn from the community if what we're doing makes sense and if so how we can improve it.
Earlier this year we decided to hire SWE summer interns. We wanted to know how well someone would perform on the job, so we gave our top candidates a real paid task from our backlog. Introducing a payment allowed us to ask for something challenging and lengthy, while also respecting the candidates’ time. We also found that the strongest candidates self-selected into this paid screening challenge, unlike the traditional and mundane take-home coding assignments. You can find our challenge and the rewarded pull requests here: https://algora.io/algora/challenge/bounties/1
From our experience, hiring by building product predicts on-the-job performance really well.
Similarly, one of our founding customers Lithobyte used Algora to complete $15k of contract work with a developer over four months before hiring him full-time, calling it “trial employment”. Is this something any of you have tried?
Furthermore, as a bootstrapped startup we didn’t feel ready to pay fixed salaries to our interns. Instead, we wanted a more outcome-based way to collaborate, making sure any money we spent was consequential. That’s why we used bounties for all of our work during the internship — you can see a sample here: https://algora.io/demo/bounties
If you’d like to try Algora, today we are launching our first public release! In addition, we are really curious about your thoughts and relevant experience; how do you all go about hiring developers? We’d love to hear from you, also feel free to reach out to us at zafer@algora.io and ioannis@algora.io
On a different note, in case anyone finds it helpful, here's a CLI tool [3] I wrote last week which you can use to build opening repertoires. The intended use case is to 1) download the games of a chess player from a website like openingtree.com, 2) run the tool on the fetched PGN file to generate an opening repertoire, and 3) import the output into a study tool like lichess or chessable.
[1]: https://www.youtube.com/watch?v=dxUuueHFfFs
So I built this CLI tool. The intended use case is to 1) download the games of a chess player from a website like openingtree.com, 2) run the program on the fetched PGN file to generate an opening repertoire, and 3) import the output into a study tool like lichess or chessable.
This has been my first foray into Rust and I learnt a lot while coding. One thing that particularly gave me trouble was modeling the opening tree given how stringent Rust's requirements are when it comes to lifetimes & mutability. Fortunately I found out about arena allocation [2] in a blog post [3] by Niko Matsakis, a Rust core dev, and inspired by the approach he advocates I was able to implement it in a fairly straightforward way. Although pruning the opening tree results in a leak as a consequence of this impl, I don't think it causes any safety issues in this case.
[1]: Shout out to Eric Rosen, Jonathan Schrantz & the chessbrahs. [2]: https://en.wikipedia.org/wiki/Region-based_memory_management [3]: http://smallcultfollowing.com/babysteps/blog/2015/04/06/mode...
[1]: https://existentialtype.wordpress.com/2011/04/16/modules-mat...
interface HKT<F, A> {
_URI: F
_A: A
}
interface Mappable<F> {
map<A, B>(f: (a: A) => B, fa: HKT<F, A>): HKT<F, B>
}
where F is a unique identifier representing the type constructor and A its type parameter.[1]: https://www.cl.cam.ac.uk/~jdy22/papers/lightweight-higher-ki... [2]: https://github.com/gcanti/fp-ts [3]: https://gist.github.com/gcanti/2b455c5008c2e1674ab3e8d5790cd...
interface Mappable<Array> {
map<A, B>(f: (a: A) => B, fa: Array<A>): Array<B>
}
Likewise, for `Promise`s we could write: interface Mappable<Promise> {
map<A, B>(f: (a: A) => B, fa: Promise<A>): Promise<B>
}
But in order to generalize this interface to an arbitrary type constructor such that `F: * -> *`, we would need to write interface Mappable<F> {
map<A, B>(f: (a: A) => B, fa: ?): ?
}
which is not possible in TypeScript since it does not support higher-kinded types or type parameters that take type parameters or parametrized modules.