Think Relevance

Durham NC (main office) - REMOTE full-time and contractors Relevance, Inc. http://thinkrelevance.com http://thinkrelevance.com/jobs We are Clojure/core (http://clojure.com). Relevance has been voted as one of the Best Places to Work in the Triangle (Triangle Business Journal). We have a fantastic work environment that includes 20% Fridays (work on open source, giving back to the community, or internal projects), and a fantastic benefits package. Relevance is increasingly a virtual company and have many remote full-time developers around the country. We're now opening up the project manager positions to being remote as well. Come work with some of the best Ruby/Rails and Clojure developers on solving interesting, hard problems that make a difference.

Ruby/Clojure/Lisp/Javascript - dev and PM - Durham, NC, Washington DC, and Columbus, OH areas Relevance (http://thinkrelevance.com) is hiring. We are the guys behind Clojure/Core (http://clojure.com/). We do a lot of Ruby with and without Rails, we are doing at least two production Clojure apps right now (I'm having a hard time keeping track), and we've also done Java, .NET, C, or Javascript as the project dictates. We have a fantastic culture, are small (~25 folks) but growing, and generally kick ass. Email me at rob AT thinkrelevance.com. Tell me your github username, your HN username, and anything else I should know.

What I meant by "the whole org is on board" isn't that there weren't other opinions. There have been multiple opinions on almost every decision we make (and we have an open process and document our decisions in a style very much like this one[1]). In the end, it's not about "shooting down" alternatives, since that's loaded language. It's about making what we think is the best choice we can with the information available to us. Even in this thread, there's a chorus of voices sounding caution based on their limited information of what our situation looks like, but there are others who see why we're doing this, based on the same limited information. We absolutely do know the risks of this project, which is why we're doing this as incrementally as possible. [1]: http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-dec…

Stuart Sierra's Component: https://github.com/stuartsierra/component and his 'reloaded' workflow: http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded I haven't looked into them but the lein startup time kills me too. I love Clojure but I am looking at alternatives like Racket because of this.

Cool stuff! A couple of days ago I listened to Rich Hickey talk more about core.async on the most recent ThinkRelevance podcast: http://thinkrelevance.com/blog/2013/07/10/rich-hickey-and-core-async-p… I've written a few client side projects in ClojureScript, and I haven't been totally happy with the way I end up doing event handling. I'm excited to give this a try. By the way, I love that this is the sort of thing you can do with just a _library_ in Clojure.

On this[1] recent podcast[2] fogus had some amazing insights on Pair Programming, as Relevance also has a pairing policy. [1] http://thinkrelevance.com/blog/2012/03/28/thinkrelevance-the-podcast-e… [2] http://blog.fogus.me/2012/03/29/fogus-on-think-relevance-podcast/

According to the guys I talked to at clojure-conj, most all work at Relevance is pair work. http://thinkrelevance.com/

I find it ambiguous, but on the whole probably a good sign. A negative part is that it appeals to the needy ego. A postive aspect is that it maybe signals a knowledge of the Spolsky school of management, which is a clear improvement over average companies. But it's not as informative as other signs. For example, programming language choices and transparency. In this regard, the most impressive company I know is Relevance: http://thinkrelevance.com/ Other good companies include Freiheit and RethinkDB: http://www.freiheit.com/tag/Jobs (note the google translator) http://rethinkdb.com/jobs/

This is how runkit does it for nodejs and I think it’s working quite well for them. We (at Nextjournal) tried doing the same for other languages (Python, Julia, R) and felt that it didn’t work nearly as well. You often want to change a cell at the top e.g. to add a new import and it can be quite annoying when long-running dependent cells re-execute automatically. I now think that automatic execution of dependent cells works great when your use case is fast executing cells (see observablehq) but we need to figure out something else for longer running cells. One idea that I haven’t tried yet is only run cells automatically that have executed within a given threshold. I hear a lot of complaints about hidden state but I think it’s less of a problem in reality. It’s just a lot faster than always rerunning things from a clean slate. Clojure's live programming model [1] works incredibly well by giving the user full control over what should be evaluated. But Clojure's focus on immutability also makes this work really well. I rarely run into issues where I'm still depending on a var that's been removed and then there's still the reloaded workflow [2]. Overall I think notebooks are currently a great improvement for people that would otherwise create plain scripts – working on it is a lot quicker when you have an easy way to just execute parts of it. Plus there's the obvious benefit of interleaving prose and results. That doesn't mean we should not be thinking about addressing the…

This is an example of how much the Clojure eco-system is maturing. It is important to note that this is coming from http://thinkrelevance.com/ . This company has some of the earliest and crucial contributors to the Clojure eco-system. The summary on that page: "Traditional lean web development languages focus on two things: ease and speed. Ease has meant ease of adoption and ease of development. This has encouraged more people to engage with technology. Speed has meant speed to market and speed of development. This has brought rapid innovation to building straightforward web applications. However there is a new suite of problems that require more. Problems that require multi-layered, fine-grained security. Performance that scales. Dynamically evolving client server communication. Real-time analytics. Complex data transformations. There hasn't traditionally been a right choice for this suite of problems. Why? Because they are difficult and easy solutions aren’t designed to solve them. Rather, you need simple solutions."

OP uses the word "rejected" 9 times. A-level hiring is not about rejection. A-players aren't looking for a "job" and A-managers aren't trying to build an assembly line. It's about finding a mutual relationship where the whole is greater than the sum of its parts, and that requires a lot of things to come together. > As a startup, if you have the opportunity to bring on an A player in a low risk role (like an internship), you do it All circumstances are different, so maybe he should have found room for Dan, or maybe not. Engineering quality (and talent in general) is on a power law distribution. When you consider engineering quality to be a competitive advantage (not all startups, even YC startups, need this), your early hires are your future managers, and will tend to influence the future hires. Its tough to attract and close people smarter/better than you. I imagine myself now at age 26 (pretty decent engineer, doing functional programming and stuff), and compare to age 21 (cocky, overconfident) and while I was smart and driven and all that, it doesn't mean I can contribute to a rockstar team. I would drown and get left behind. World class teams at the top of the power law distribution, say the Clojure team[1], at age 21 I'd be a few orders of magnitude behind them and just not worth paying. at age 26, who knows, probably still at least 1 order of magnitude behind, not worth hiring. Square peg, round hole. At least I can see my trajectory of exponential growth over the…

Durham NC (main office) - REMOTE full-time and contractors Relevance, Inc. www.thinkrelevance.com Rails or Clojure Developers, Project Managers http://thinkrelevance.com/jobs We are Clojure/core (http://clojure.com). Relevance has been voted as one of the Best Places to Work in the Triangle both 2010 and 2011 (Triangle Business Journal). We were also ranked #739 in this year's Inc 500|5000 list. We have a fantastic work environment that includes 20% Fridays (work on open source, giving back to the community, or internal projects) and a great benefits package. Relevance is increasingly a virtual company and have many remote full-time developers around the country. We're now opening up the project manager positions to being remote as well. Come work with some of the best Ruby/Rails and Clojure developers on solving interesting, hard problems that make a difference. email us: jobs [at] thinkrelevance [dot] com Include Hacker News in the subject line

Sure, check out Stuart Sierra' (by now famous) blog post Clojure Workflow Reloaded and his Components library: http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded https://github.com/stuartsierra/component

I second the motion for ADRs (resources below). A side-benefit is that they use Markdown: plain and simple. Try to use Markdown (or similar) as much as possible. Once you are used to it, it is hard to go back to the insane formatting friction in a word processor. [1] - http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-dec… [2] - https://www.youtube.com/watch?v=LMBqGPLvonU

‘Architecture Decision Records’ are one pattern of attempting to document these discussions in a lightweight manner. http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-dec…

Typically Clojure apps are structured to be reloadable meaning that you don't have any global state, and you can easily flush the current REPL state http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded There are also tools like lein-test-refresh https://github.com/jakemcc/lein-test-refresh that figure out what needs to be reloaded automatically. You start it up, it watches your namespaces for changes, and reruns tests as needed. As a bonus it can even hook into your OS notification system and let you know if any tests fail.

Clojure has dealt with this problem actually. If you are curious check out mount, component, and this blog post: http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded

The VCS is still decentralized (you can share code with your neighbour or across the world), it's the administration (tickets, PRs, etc) that aren't. I think it'd be fairly straightforward for github or a competitor to store those things in git as plain markdown files, either alongside the main source code, or (as it does with GH Pages) in a separate branch (that has nothing in common with the master branch but it's still in the same repo). Similar (maybe) is ADR (http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-dec… storing architectural decisions into numbered files in git. See also: https://github.com/npryce/adr-tools

I think maybe documenting architectural decisions might make sense: http://thinkrelevance.com/blog/2011/11/15/documenting-architecture-dec…

What would you describe as "real" interactive development? And while the reloaded[0] workflow is one benefit of using a library like Component or Mount, it's hardly the only benefit. [0]: http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded

Indeed! And not every language that claims to be OO actually follows the basic ideas [1,2]. So, Smalltalk, as e.g Squeak [3] or Pharo [4] is a good place to start looking and learning but also Erlang [5] and Clojure [6]. State is necessary not "evil" but needs to be managed well. And most OO-languages have, apart from the assignment operation, no abstractions for. [1] http://wiki.c2.com/?AlanKayOnMessaging [2] http://worrydream.com/EarlyHistoryOfSmalltalk/ [3] http://squeak.org/ [4] https://pharo.org/ [5] http://www.infoq.com/interviews/johnson-armstrong-oop [6] http://thinkrelevance.com/blog/2013/11/07/when-should-you-use-clojures…

Carin Meier was trying to fly drones with it: http://thinkrelevance.com/blog/2014/02/11/carin-meier-cognicast-episod…

I think it's this podcast, where Rich Hickey explains codeq: http://thinkrelevance.com/blog/2012/10/12/rich-hickey-podcast-episode-…

You even have to restart your development instance from time to time to make sure that your application state remains consistent. There are ways around that. Stuart Sierra uses a scheme wherein the entire application is treated as a value, which can be re-generated on the fly. Of course, that's not terribly different in practice from restarting the whole environment, but it's faster and more convenient. http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded

This was mentioned in Cognicast Episode 50 [1] [1] http://thinkrelevance.com/blog/2014/02/25/luke-vanderhart-and-ryan-neu…

Quite a few members of the Clojure core team and community work there, as evidenced by the intersection of http://thinkrelevance.com/team and http://clojure.com/about.html.

There are Clojure versions of the examples from the book by Stuart Halloway [1] and Michael Fogus [2] [1] http://thinkrelevance.com/blog/2008/12/12/on-lisp-clojure [2] http://blog.fogus.me/tag/onlisp/

Have a look at http://thinkrelevance.com/blog/tags/on-lisp to see Stuart Halloway going through On Lisp in Clojure.

Author here. While I appreciate the reads, I am even more glad for the amusement provided by various comments about how I'm confused about what "100% time" means (since, AFAIK, the post is where the term was first used outside of private conversations with friends of mine), or that it's potentially illegal, or that it's really just the typical 80/20 split and I can't tell the difference. Cheers! :-D Snark aside, Craig Andera asked me about the post on a recent Relevance podcast, and we talked about it and matters related to 100% time for a good stretch: http://thinkrelevance.com/blog/2013/05/14/chas-emerick-mostly-lazy-pod…

You might like this one, its not pure Computer Science but there is a lot of it. Its by the ThinkRelevance guys, of known for clojure, datomic and pedastal. The also talk about company organisation and things like that. They had Rich Hickey on multiple times, most recently to talk about core.async the new CSP library. http://thinkrelevance.com/blog/tags/podcast